OpenMessage domain type last adjustments:

Alenar · Alenar · commit d0fa0819239e · 2023-04-27T12:20:35.000+02:00
* use it in the multisigner
* include the `created_at` field since it's used for the certificate
  creation
* cleanups
diff --git a/mithril-aggregator/src/certifier_service.rs b/mithril-aggregator/src/certifier_service.rs
@@ -260,13 +260,14 @@ impl CertifierService for MithrilCertifierService {
         signed_entity_type: &SignedEntityType,
     ) -> StdResult<Option<Certificate>> {
         debug!("CertifierService::create_certificate(signed_entity_type: {signed_entity_type:?})");
-        let open_message = self
+        let open_message_record = self
             .get_open_message_record(signed_entity_type)
             .await?
             .ok_or_else(|| {
                 warn!("CertifierService::create_certificate: OpenMessage not found for type {signed_entity_type:?}.");
                 CertifierServiceError::NotFound(signed_entity_type.clone())
             })?;
+        let open_message: OpenMessage = open_message_record.clone().into();
 
         if open_message.is_certified {
             warn!("CertifierService::create_certificate: open message {signed_entity_type:?} is already certified, cannot create certificate.");
@@ -343,7 +344,7 @@ impl CertifierService for MithrilCertifierService {
             .create_certificate(certificate)
             .await?;
 
-        let mut open_message_certified: OpenMessageRecord = open_message.into();
+        let mut open_message_certified: OpenMessageRecord = open_message_record.into();
         open_message_certified.is_certified = true;
         self.open_message_repository
             .update_open_message(&open_message_certified)
diff --git a/mithril-aggregator/src/database/provider/open_message.rs b/mithril-aggregator/src/database/provider/open_message.rs
@@ -1,6 +1,6 @@
 use mithril_common::StdError;
 
-use mithril_common::entities::{PartyId, ProtocolMessage, SingleSignatures};
+use mithril_common::entities::{ProtocolMessage, SingleSignatures};
 use mithril_common::{
     entities::{Epoch, SignedEntityType},
     sqlite::{HydrationError, Projection, SqLiteEntity, WhereCondition},
@@ -355,16 +355,6 @@ pub struct OpenMessageWithSingleSignaturesRecord {
     pub created_at: NaiveDateTime,
 }
 
-impl OpenMessageWithSingleSignaturesRecord {
-    /// Gather all signers party_id for this open message
-    pub fn get_signers_id(&self) -> Vec<PartyId> {
-        self.single_signatures
-            .iter()
-            .map(|sig| sig.party_id.to_owned())
-            .collect()
-    }
-}
-
 impl SqLiteEntity for OpenMessageWithSingleSignaturesRecord {
     fn hydrate(row: Row) -> Result<Self, HydrationError>
     where
diff --git a/mithril-aggregator/src/entities/open_message.rs b/mithril-aggregator/src/entities/open_message.rs
@@ -1,4 +1,7 @@
-use mithril_common::entities::{Epoch, ProtocolMessage, SignedEntityType, SingleSignatures};
+use chrono::NaiveDateTime;
+use mithril_common::entities::{
+    Epoch, PartyId, ProtocolMessage, SignedEntityType, SingleSignatures,
+};
 
 use crate::database::provider::{OpenMessageRecord, OpenMessageWithSingleSignaturesRecord};
 
@@ -9,9 +12,6 @@ use crate::database::provider::{OpenMessageRecord, OpenMessageWithSingleSignatur
 /// generated if possible.
 #[derive(Debug, Clone, PartialEq)]
 pub struct OpenMessage {
-    /// OpenMessage unique identifier
-    // pub open_message_id: Uuid, // do we need it in the entity ?
-
     /// Epoch
     pub epoch: Epoch,
 
@@ -26,9 +26,20 @@ pub struct OpenMessage {
 
     /// associated single signatures
     pub single_signatures: Vec<SingleSignatures>,
+
+    /// Message creation datetime
+    pub created_at: NaiveDateTime,
 }
 
 impl OpenMessage {
+    /// Gather all signers party_id for this open message
+    pub fn get_signers_id(&self) -> Vec<PartyId> {
+        self.single_signatures
+            .iter()
+            .map(|sig| sig.party_id.to_owned())
+            .collect()
+    }
+
     #[cfg(test)]
     /// Create a dumb OpenMessage instance mainly for test purposes
     pub fn dummy() -> Self {
@@ -47,6 +58,7 @@ impl OpenMessage {
                 fake_data::single_signatures(vec![1, 4, 5]),
                 fake_data::single_signatures(vec![2, 3, 8]),
             ],
+            created_at: chrono::Local::now().naive_local(),
         }
     }
 }
@@ -59,6 +71,7 @@ impl From<OpenMessageRecord> for OpenMessage {
             protocol_message: record.protocol_message,
             is_certified: record.is_certified,
             single_signatures: vec![],
+            created_at: record.created_at,
         }
     }
 }
@@ -71,6 +84,7 @@ impl From<OpenMessageWithSingleSignaturesRecord> for OpenMessage {
             protocol_message: record.protocol_message,
             is_certified: record.is_certified,
             single_signatures: record.single_signatures,
+            created_at: record.created_at,
         }
     }
 }
@@ -89,20 +103,22 @@ mod test {
 
     #[test]
     fn test_from_record() {
+        let created_at = chrono::Local::now().naive_local();
         let record = OpenMessageRecord {
             open_message_id: Uuid::new_v4(),
             epoch: Epoch(1),
             signed_entity_type: SignedEntityType::dummy(),
             protocol_message: ProtocolMessage::default(),
             is_certified: false,
-            created_at: chrono::Local::now().naive_local(),
+            created_at,
         };
         let expected = OpenMessage {
             epoch: Epoch(1),
             signed_entity_type: SignedEntityType::dummy(),
             protocol_message: ProtocolMessage::default(),
             is_certified: false,
             single_signatures: vec![],
+            created_at,
         };
         let result: OpenMessage = record.into();
 
@@ -111,13 +127,14 @@ mod test {
 
     #[test]
     fn test_from_record_with_single_signatures() {
+        let created_at = chrono::Local::now().naive_local();
         let record = OpenMessageWithSingleSignaturesRecord {
             open_message_id: Uuid::new_v4(),
             epoch: Epoch(1),
             signed_entity_type: SignedEntityType::dummy(),
             protocol_message: ProtocolMessage::default(),
             is_certified: false,
-            created_at: chrono::Local::now().naive_local(),
+            created_at,
             single_signatures: vec![fake_data::single_signatures(vec![1, 4, 5])],
         };
         let expected = OpenMessage {
@@ -126,6 +143,7 @@ mod test {
             protocol_message: ProtocolMessage::default(),
             is_certified: false,
             single_signatures: vec![fake_data::single_signatures(vec![1, 4, 5])],
+            created_at,
         };
         let result: OpenMessage = record.into();
 
diff --git a/mithril-aggregator/src/multi_signer.rs b/mithril-aggregator/src/multi_signer.rs
@@ -14,8 +14,8 @@ use mithril_common::{
 };
 
 use crate::{
-    database::provider::OpenMessageWithSingleSignaturesRecord, store::VerificationKeyStorer,
-    ProtocolParametersStore, ProtocolParametersStorer, VerificationKeyStore,
+    entities::OpenMessage, store::VerificationKeyStorer, ProtocolParametersStore,
+    ProtocolParametersStorer, VerificationKeyStore,
 };
 
 #[cfg(test)]
@@ -184,7 +184,7 @@ pub trait MultiSigner: Sync + Send {
     /// Creates a multi signature from single signatures
     async fn create_multi_signature(
         &self,
-        open_message: &OpenMessageWithSingleSignaturesRecord,
+        open_message: &OpenMessage,
     ) -> Result<Option<ProtocolMultiSignature>, ProtocolError>;
 }
 
@@ -539,7 +539,7 @@ impl MultiSigner for MultiSignerImpl {
     /// Creates a multi signature from single signatures
     async fn create_multi_signature(
         &self,
-        open_message: &OpenMessageWithSingleSignaturesRecord,
+        open_message: &OpenMessage,
     ) -> Result<Option<ProtocolMultiSignature>, ProtocolError> {
         debug!("MultiSigner:create_multi_signature({open_message:?})");
         let protocol_parameters = self
@@ -582,15 +582,13 @@ impl MultiSigner for MultiSignerImpl {
 mod tests {
     use super::*;
     use crate::{store::VerificationKeyStore, ProtocolParametersStore};
-    use chrono::Local;
     use mithril_common::{
         crypto_helper::tests_setup::*,
         entities::SignedEntityType,
         store::{adapter::MemoryAdapter, StakeStore},
         test_utils::{fake_data, MithrilFixtureBuilder},
     };
     use std::{collections::HashMap, sync::Arc};
-    use uuid::Uuid;
 
     async fn setup_multi_signer() -> MultiSignerImpl {
         let beacon = fake_data::beacon();
@@ -805,16 +803,15 @@ mod tests {
             "they should be at least one signature that can be registered without reaching the quorum"
         );
 
-        let mut open_message = OpenMessageWithSingleSignaturesRecord {
-            open_message_id: Uuid::parse_str("193d1442-e89b-43cf-9519-04d8db9a12ff").unwrap(),
+        let mut open_message = OpenMessage {
             epoch: start_epoch,
             signed_entity_type: SignedEntityType::CardanoImmutableFilesFull(
                 multi_signer.current_beacon.clone().unwrap(),
             ),
             protocol_message: message.clone(),
             is_certified: false,
             single_signatures: Vec::new(),
-            created_at: Local::now().naive_local(),
+            ..OpenMessage::dummy()
         };
 
         // No signatures registered: multi-signer can't create the multi-signature
