Remove signed_message from SingleSignatures entity

Alenar · Alenar · commit eeb23cf4e8d4 · 2024-09-19T10:40:41.000+02:00
As we won't be able to always set this value (ie: with the upcoming p2p
registration).

In order to do so an refactor have to be done in `mithril-signer` so the
`RegisterSignatureMessage::signed_message` property can be set.
diff --git a/mithril-aggregator/src/database/record/buffered_single_signature_record.rs b/mithril-aggregator/src/database/record/buffered_single_signature_record.rs
@@ -53,7 +53,7 @@ impl BufferedSingleSignatureRecord {
         // the signatures are different for party_id/discriminant pairs.
         // We can't just reuse fake_data::single_signatures as they are static.
         Self::try_from_single_signatures(
-            &SingleSignatures::fake_with_signed_message(party_id.into(), discriminant.to_string()),
+            &SingleSignatures::fake(party_id.into(), discriminant.to_string()),
             discriminant,
         )
         .unwrap()
@@ -85,7 +85,6 @@ impl TryFrom<BufferedSingleSignatureRecord> for SingleSignatures {
             party_id: value.party_id,
             won_indexes: value.lottery_indexes,
             signature: value.signature.try_into()?,
-            signed_message: None,
             authentication_status: Default::default(),
         };
 
diff --git a/mithril-aggregator/src/database/record/single_signature.rs b/mithril-aggregator/src/database/record/single_signature.rs
@@ -54,7 +54,6 @@ impl TryFrom<SingleSignatureRecord> for SingleSignatures {
             party_id: value.signer_id,
             won_indexes: value.lottery_indexes,
             signature: value.signature.try_into()?,
-            signed_message: None,
             authentication_status: Default::default(),
         };
 
diff --git a/mithril-aggregator/src/message_adapters/from_register_signature.rs b/mithril-aggregator/src/message_adapters/from_register_signature.rs
@@ -22,7 +22,6 @@ impl TryFromMessageAdapter<RegisterSignatureMessage, SingleSignatures>
                     "'FromRegisterSingleSignatureAdapter' can not convert the single signature"
                 })?,
             won_indexes: register_single_signature_message.won_indexes,
-            signed_message: register_single_signature_message.signed_message,
             authentication_status: SingleSignatureAuthenticationStatus::Unauthenticated,
         };
 
@@ -43,9 +42,5 @@ mod tests {
         .unwrap();
 
         assert_eq!("party_id".to_string(), signatures.party_id);
-        assert_eq!(
-            Some("signed_message".to_string()),
-            signatures.signed_message
-        );
     }
 }
diff --git a/mithril-common/src/entities/single_signatures.rs b/mithril-common/src/entities/single_signatures.rs
@@ -21,13 +21,6 @@ pub struct SingleSignatures {
     #[serde(rename = "indexes")]
     pub won_indexes: Vec<LotteryIndex>,
 
-    /// Message that is signed by the signer
-    ///
-    /// Used to buffer the signature for later if the aggregator has yet to create an open message
-    /// for the signed entity type.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub signed_message: Option<String>,
-
     /// Status of the authentication of the signer that emitted the signature
     #[serde(skip)]
     pub authentication_status: SingleSignatureAuthenticationStatus,
@@ -54,23 +47,6 @@ impl SingleSignatures {
             party_id: party_id.into(),
             signature,
             won_indexes,
-            signed_message: None,
-            authentication_status: SingleSignatureAuthenticationStatus::Unauthenticated,
-        }
-    }
-
-    /// `SingleSignatures` factory including the signed message
-    pub fn new_with_signed_message<T: Into<PartyId>>(
-        party_id: T,
-        signature: ProtocolSingleSignature,
-        won_indexes: Vec<LotteryIndex>,
-        signed_message: String,
-    ) -> SingleSignatures {
-        SingleSignatures {
-            party_id: party_id.into(),
-            signature,
-            won_indexes,
-            signed_message: Some(signed_message),
             authentication_status: SingleSignatureAuthenticationStatus::Unauthenticated,
         }
     }
@@ -88,18 +64,10 @@ impl SingleSignatures {
 
 cfg_test_tools! {
 impl SingleSignatures {
-    /// Create a fake [SingleSignatures] with valid cryptographic data for testing purposes.
-    pub fn fake<T1: Into<String>, T2: Into<String>>(party_id: T1, message: T2) -> Self {
-        Self {
-            signed_message: None,
-            ..Self::fake_with_signed_message(party_id, message)
-        }
-    }
-
     /// Create a fake [SingleSignatures] with valid cryptographic data for testing purposes.
     // TODO: this method is slow due to the fixture creation, we should either make
     // the fixture faster or find a faster alternative.
-    pub fn fake_with_signed_message<T1: Into<String>, T2: Into<String>>(party_id: T1, message: T2) -> Self {
+    pub fn fake<T1: Into<String>, T2: Into<String>>(party_id: T1, message: T2) -> Self {
         use crate::entities::{ProtocolParameters};
         use crate::test_utils::{MithrilFixtureBuilder, StakeDistributionGenerationMethod};
 
@@ -118,7 +86,6 @@ impl SingleSignatures {
             party_id,
             signature: signature.signature,
             won_indexes: vec![10, 15],
-            signed_message: Some(message),
             authentication_status: SingleSignatureAuthenticationStatus::Unauthenticated,
         }
     }
@@ -131,8 +98,7 @@ impl Debug for SingleSignatures {
         let mut debug = f.debug_struct("SingleSignatures");
         debug
             .field("party_id", &self.party_id)
-            .field("won_indexes", &format_args!("{:?}", self.won_indexes))
-            .field("signed_message", &self.signed_message);
+            .field("won_indexes", &format_args!("{:?}", self.won_indexes));
 
         match is_pretty_printing {
             true => debug
diff --git a/mithril-common/src/protocol/single_signer.rs b/mithril-common/src/protocol/single_signer.rs
@@ -29,11 +29,10 @@ impl SingleSigner {
             Some(signature) => {
                 let won_indexes = signature.indexes.clone();
 
-                Ok(Some(SingleSignatures::new_with_signed_message(
+                Ok(Some(SingleSignatures::new(
                     self.party_id.to_owned(),
                     signature.into(),
                     won_indexes,
-                    signed_message,
                 )))
             }
             None => Ok(None),
@@ -75,32 +74,4 @@ mod test {
 
         assert!(signature.is_some());
     }
-
-    #[test]
-    fn embed_signed_message_in_issued_signature() {
-        let fixture = MithrilFixtureBuilder::default().with_signers(3).build();
-        let signers = fixture.signers_fixture();
-        let signer = signers.first().unwrap();
-
-        let (single_signer, _) = SignerBuilder::new(
-            &fixture.signers_with_stake(),
-            &fixture.protocol_parameters(),
-        )
-        .unwrap()
-        .build_test_single_signer(
-            signer.signer_with_stake.clone(),
-            signer.kes_secret_key_path(),
-        )
-        .unwrap();
-
-        let message = ProtocolMessage::default();
-        let signature = single_signer
-            .sign(&message)
-            .expect("Single signer should be able to issue single signature");
-
-        assert_eq!(
-            Some(message.compute_hash()),
-            signature.and_then(|s| s.signed_message)
-        );
-    }
 }
diff --git a/mithril-common/src/test_utils/mithril_fixture.rs b/mithril-common/src/test_utils/mithril_fixture.rs
@@ -234,11 +234,10 @@ impl SignerFixture {
             .map(|signature| {
                 let won_indexes = signature.indexes.clone();
 
-                SingleSignatures::new_with_signed_message(
+                SingleSignatures::new(
                     self.signer_with_stake.party_id.to_owned(),
                     signature.into(),
                     won_indexes,
-                    message,
                 )
             })
     }
diff --git a/mithril-signer/src/message_adapters/to_register_signature_message.rs b/mithril-signer/src/message_adapters/to_register_signature_message.rs
@@ -1,15 +1,23 @@
 use anyhow::Context;
-use mithril_common::entities::{SignedEntityType, SingleSignatures};
+use mithril_common::entities::{ProtocolMessage, SignedEntityType, SingleSignatures};
 use mithril_common::messages::{RegisterSignatureMessage, TryToMessageAdapter};
+use mithril_common::protocol::AsMessage;
 use mithril_common::StdResult;
 
 pub struct ToRegisterSignatureMessageAdapter;
 
-impl TryToMessageAdapter<(SignedEntityType, SingleSignatures), RegisterSignatureMessage>
-    for ToRegisterSignatureMessageAdapter
+impl
+    TryToMessageAdapter<
+        (SignedEntityType, SingleSignatures, &ProtocolMessage),
+        RegisterSignatureMessage,
+    > for ToRegisterSignatureMessageAdapter
 {
     fn try_adapt(
-        (signed_entity_type, single_signature): (SignedEntityType, SingleSignatures),
+        (signed_entity_type, single_signature, protocol_message): (
+            SignedEntityType,
+            SingleSignatures,
+            &ProtocolMessage,
+        ),
     ) -> StdResult<RegisterSignatureMessage> {
         let message = RegisterSignatureMessage {
             signed_entity_type,
@@ -18,7 +26,7 @@ impl TryToMessageAdapter<(SignedEntityType, SingleSignatures), RegisterSignature
                 "'ToRegisterSignatureMessageAdapter' can not convert the single signature"
             })?,
             won_indexes: single_signature.won_indexes,
-            signed_message: single_signature.signed_message,
+            signed_message: Some(protocol_message.message_string()),
         };
 
         Ok(message)
@@ -35,14 +43,15 @@ mod tests {
     fn adapt_ok() {
         let message: RegisterSignatureMessage = ToRegisterSignatureMessageAdapter::try_adapt((
             SignedEntityType::dummy(),
-            SingleSignatures {
-                signed_message: Some("signed_message".to_string()),
-                ..fake_data::single_signatures([1, 3].to_vec())
-            },
+            fake_data::single_signatures([1, 3].to_vec()),
+            &ProtocolMessage::default(),
         ))
         .unwrap();
 
         assert_eq!("party_id".to_string(), message.party_id);
-        assert_eq!(Some("signed_message".to_string()), message.signed_message);
+        assert_eq!(
+            Some(ProtocolMessage::default().message_string()),
+            message.signed_message
+        );
     }
 }
diff --git a/mithril-signer/src/runtime/runner.rs b/mithril-signer/src/runtime/runner.rs
@@ -61,6 +61,7 @@ pub trait Runner: Send + Sync {
         &self,
         signed_entity_type: &SignedEntityType,
         maybe_signature: Option<SingleSignatures>,
+        signed_message: &ProtocolMessage,
     ) -> StdResult<()>;
 
     /// Read the current era and update the EraChecker.
@@ -390,6 +391,7 @@ impl Runner for SignerRunner {
         &self,
         signed_entity_type: &SignedEntityType,
         maybe_signature: Option<SingleSignatures>,
+        protocol_message: &ProtocolMessage,
     ) -> StdResult<()> {
         debug!("RUNNER: send_single_signature");
 
@@ -398,7 +400,7 @@ impl Runner for SignerRunner {
 
             self.services
                 .certificate_handler
-                .register_signatures(signed_entity_type, &single_signatures)
+                .register_signatures(signed_entity_type, &single_signatures, protocol_message)
                 .await?;
 
             Ok(())
@@ -1047,14 +1049,15 @@ mod tests {
         certificate_handler
             .expect_register_signatures()
             .once()
-            .returning(|_, _| Ok(()));
+            .returning(|_, _, _| Ok(()));
         services.certificate_handler = Arc::new(certificate_handler);
         let runner = init_runner(Some(services), None).await;
 
         runner
             .send_single_signature(
                 &SignedEntityType::dummy(),
                 Some(fake_data::single_signatures(vec![2, 5, 12])),
+                &ProtocolMessage::default(),
             )
             .await
             .expect("send_single_signature should not fail");
diff --git a/mithril-signer/src/runtime/state_machine.rs b/mithril-signer/src/runtime/state_machine.rs
@@ -444,7 +444,7 @@ impl StateMachine {
                 message: format!("Could not compute single signature during 'ready to sign → ready to sign' phase (current epoch {current_epoch:?})"),
                 nested_error: Some(e)
             })?;
-        self.runner.send_single_signature(signed_entity_type, single_signatures).await
+        self.runner.send_single_signature(signed_entity_type, single_signatures, &message).await
             .map_err(|e| RuntimeError::KeepState {
                 message: format!("Could not send single signature during 'ready to sign → ready to sign' phase (current epoch {current_epoch:?})"),
                 nested_error: Some(e)
@@ -952,7 +952,7 @@ mod tests {
         runner
             .expect_send_single_signature()
             .once()
-            .returning(|_, _| Ok(()));
+            .returning(|_, _, _| Ok(()));
         runner
             .expect_can_sign_signed_entity_type()
             .once()
diff --git a/mithril-signer/src/services/aggregator_client.rs b/mithril-signer/src/services/aggregator_client.rs
diff --git a/mithril-signer/tests/test_extensions/certificate_handler.rs b/mithril-signer/tests/test_extensions/certificate_handler.rs

Original file line number	Diff line number	Diff line change
`@@ -234,11 +234,10 @@ impl SignerFixture {`
`234`	`234`	`.map(\|signature\| {`
`235`	`235`	`let won_indexes = signature.indexes.clone();`
`236`	`236`
`237`		`- SingleSignatures::new_with_signed_message(`
	`237`	`+ SingleSignatures::new(`
`238`	`238`	`self.signer_with_stake.party_id.to_owned(),`
`239`	`239`	`signature.into(),`
`240`	`240`	`won_indexes,`
`241`		`- message,`
`242`	`241`	`)`
`243`	`242`	`})`
`244`	`243`	`}`