refactor: rename SingleSignatures to SingleSignature

Author: Clément TURMEL

mithril-aggregator/src/database/record/buffered_single_signature_record.rs

@@ -1,7 +1,7 @@
 use chrono::{DateTime, Utc};
 
 use mithril_common::entities::{
-    HexEncodedSingleSignature, LotteryIndex, SignedEntityTypeDiscriminants, SingleSignatures,
+    HexEncodedSingleSignature, LotteryIndex, SignedEntityTypeDiscriminants, SingleSignature,
 };
 use mithril_common::{StdError, StdResult};
 use mithril_persistence::sqlite::{HydrationError, Projection, SqLiteEntity};
@@ -27,8 +27,8 @@ pub struct BufferedSingleSignatureRecord {
 }
 
 impl BufferedSingleSignatureRecord {
-    pub(crate) fn try_from_single_signatures(
-        other: &SingleSignatures,
+    pub(crate) fn try_from_single_signature(
+        other: &SingleSignature,
         signed_entity_id: SignedEntityTypeDiscriminants,
     ) -> StdResult<Self> {
         let record = BufferedSingleSignatureRecord {
@@ -50,10 +50,10 @@ impl BufferedSingleSignatureRecord {
         discriminant: SignedEntityTypeDiscriminants,
     ) -> Self {
         // Note: due to the unique constraint on the signature column, we want to make sure that
-        // 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(party_id.into(), discriminant.to_string()),
+        // the signature are different for party_id/discriminant pairs.
+        // We can't just reuse fake_data::single_signature as they are static.
+        Self::try_from_single_signature(
+            &SingleSignature::fake(party_id.into(), discriminant.to_string()),
             discriminant,
         )
         .unwrap()
@@ -77,18 +77,18 @@ impl BufferedSingleSignatureRecord {
     }
 }
 
-impl TryFrom<BufferedSingleSignatureRecord> for SingleSignatures {
+impl TryFrom<BufferedSingleSignatureRecord> for SingleSignature {
     type Error = StdError;
 
     fn try_from(value: BufferedSingleSignatureRecord) -> Result<Self, Self::Error> {
-        let signatures = SingleSignatures {
+        let signature = SingleSignature {
             party_id: value.party_id,
             won_indexes: value.lottery_indexes,
             signature: value.signature.try_into()?,
             authentication_status: Default::default(),
         };
 
-        Ok(signatures)
+        Ok(signature)
     }
 }
 
@@ -181,9 +181,9 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_convert_single_signatures() {
-        let single_signature = fake_data::single_signatures(vec![1, 3, 4, 6, 7, 9]);
-        let single_signature_record = BufferedSingleSignatureRecord::try_from_single_signatures(
+    fn test_convert_single_signature() {
+        let single_signature = fake_data::single_signature(vec![1, 3, 4, 6, 7, 9]);
+        let single_signature_record = BufferedSingleSignatureRecord::try_from_single_signature(
             &single_signature,
             CardanoTransactions,
         )

mithril-aggregator/src/database/record/open_message_with_single_signatures.rs

@@ -2,7 +2,7 @@ use chrono::{DateTime, Utc};
 use sqlite::Row;
 use uuid::Uuid;
 
-use mithril_common::entities::{Epoch, ProtocolMessage, SignedEntityType, SingleSignatures};
+use mithril_common::entities::{Epoch, ProtocolMessage, SignedEntityType, SingleSignature};
 use mithril_persistence::sqlite::{HydrationError, Projection, SqLiteEntity};
 
 use crate::database::record::OpenMessageRecord;
@@ -29,7 +29,7 @@ pub struct OpenMessageWithSingleSignaturesRecord {
     pub is_expired: bool,
 
     /// associated single signatures
-    pub single_signatures: Vec<SingleSignatures>,
+    pub single_signatures: Vec<SingleSignature>,
 
     /// Message creation datetime, it is set by the database.
     pub created_at: DateTime<Utc>,
@@ -59,7 +59,7 @@ impl SqLiteEntity for OpenMessageWithSingleSignaturesRecord {
         Self: Sized,
     {
         let single_signatures = &row.read::<&str, _>(9);
-        let single_signatures: Vec<SingleSignatures> = serde_json::from_str(single_signatures)
+        let single_signatures: Vec<SingleSignature> = serde_json::from_str(single_signatures)
             .map_err(|e| {
                 HydrationError::InvalidData(format!(
                     "Could not parse single signatures JSON: '{single_signatures}'. Error: {e}"

mithril-aggregator/src/database/record/single_signature.rs

@@ -1,7 +1,7 @@
 use chrono::{DateTime, Utc};
 use uuid::Uuid;
 
-use mithril_common::entities::{Epoch, HexEncodedSingleSignature, LotteryIndex, SingleSignatures};
+use mithril_common::entities::{Epoch, HexEncodedSingleSignature, LotteryIndex, SingleSignature};
 use mithril_common::{StdError, StdResult};
 use mithril_persistence::sqlite::{HydrationError, Projection, SqLiteEntity};
 
@@ -28,8 +28,8 @@ pub struct SingleSignatureRecord {
 }
 
 impl SingleSignatureRecord {
-    pub(crate) fn try_from_single_signatures(
-        other: &SingleSignatures,
+    pub(crate) fn try_from_single_signature(
+        other: &SingleSignature,
         open_message_id: &Uuid,
         registration_epoch_settings_id: Epoch,
     ) -> StdResult<Self> {
@@ -46,18 +46,18 @@ impl SingleSignatureRecord {
     }
 }
 
-impl TryFrom<SingleSignatureRecord> for SingleSignatures {
+impl TryFrom<SingleSignatureRecord> for SingleSignature {
     type Error = StdError;
 
     fn try_from(value: SingleSignatureRecord) -> Result<Self, Self::Error> {
-        let signatures = SingleSignatures {
+        let signature = SingleSignature {
             party_id: value.signer_id,
             won_indexes: value.lottery_indexes,
             signature: value.signature.try_into()?,
             authentication_status: Default::default(),
         };
 
-        Ok(signatures)
+        Ok(signature)
     }
 }
 
@@ -138,10 +138,10 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_convert_single_signatures() {
-        let single_signature = fake_data::single_signatures(vec![1, 3, 4, 6, 7, 9]);
+    fn test_convert_single_signature() {
+        let single_signature = fake_data::single_signature(vec![1, 3, 4, 6, 7, 9]);
         let open_message_id = Uuid::parse_str("193d1442-e89b-43cf-9519-04d8db9a12ff").unwrap();
-        let single_signature_record = SingleSignatureRecord::try_from_single_signatures(
+        let single_signature_record = SingleSignatureRecord::try_from_single_signature(
             &single_signature,
             &open_message_id,
             Epoch(1),

mithril-aggregator/src/database/repository/buffered_single_signature_repository.rs

@@ -2,7 +2,7 @@ use anyhow::Context;
 use async_trait::async_trait;
 use std::sync::Arc;
 
-use mithril_common::entities::{SignedEntityTypeDiscriminants, SingleSignatures};
+use mithril_common::entities::{SignedEntityTypeDiscriminants, SingleSignature};
 use mithril_common::{StdError, StdResult};
 use mithril_persistence::sqlite::{ConnectionExtensions, SqliteConnection};
 
@@ -60,13 +60,13 @@ impl BufferedSingleSignatureStore for BufferedSingleSignatureRepository {
     async fn buffer_signature(
         &self,
         signed_entity_type_discriminant: SignedEntityTypeDiscriminants,
-        signature: &SingleSignatures,
+        signature: &SingleSignature,
     ) -> StdResult<()> {
-        let record = BufferedSingleSignatureRecord::try_from_single_signatures(
+        let record = BufferedSingleSignatureRecord::try_from_single_signature(
             signature,
             signed_entity_type_discriminant,
         )
-        .with_context(|| "Failed to convert SingleSignatures to BufferedSingleSignatureRecord")?;
+        .with_context(|| "Failed to convert SingleSignature to BufferedSingleSignatureRecord")?;
 
         self.connection
             .fetch_first(InsertOrReplaceBufferedSingleSignatureRecordQuery::one(
@@ -79,14 +79,14 @@ impl BufferedSingleSignatureStore for BufferedSingleSignatureRepository {
     async fn get_buffered_signatures(
         &self,
         signed_entity_type_discriminant: SignedEntityTypeDiscriminants,
-    ) -> StdResult<Vec<SingleSignatures>> {
+    ) -> StdResult<Vec<SingleSignature>> {
         self.get_by_discriminant(signed_entity_type_discriminant)
     }
 
     async fn remove_buffered_signatures(
         &self,
         signed_entity_type_discriminant: SignedEntityTypeDiscriminants,
-        single_signatures: Vec<SingleSignatures>,
+        single_signatures: Vec<SingleSignature>,
     ) -> StdResult<()> {
         let signatures_party_ids = single_signatures.into_iter().map(|s| s.party_id).collect();
         self.connection.fetch_first(
@@ -186,7 +186,7 @@ mod tests {
             store
                 .buffer_signature(
                     CardanoTransactions,
-                    &SingleSignatures::new(
+                    &SingleSignature::new(
                         "party1",
                         fake_keys::single_signature()[0].try_into().unwrap(),
                         vec![1],
@@ -197,7 +197,7 @@ mod tests {
             store
                 .buffer_signature(
                     CardanoTransactions,
-                    &SingleSignatures::new(
+                    &SingleSignature::new(
                         "party2",
                         fake_keys::single_signature()[1].try_into().unwrap(),
                         vec![2],
@@ -212,12 +212,12 @@ mod tests {
                 .unwrap();
             assert_eq!(
                 vec![
-                    SingleSignatures::new(
+                    SingleSignature::new(
                         "party2",
                         fake_keys::single_signature()[1].try_into().unwrap(),
                         vec![2],
                     ),
-                    SingleSignatures::new(
+                    SingleSignature::new(
                         "party1",
                         fake_keys::single_signature()[0].try_into().unwrap(),
                         vec![1],
@@ -231,7 +231,7 @@ mod tests {
             store
                 .buffer_signature(
                     MithrilStakeDistribution,
-                    &SingleSignatures::new(
+                    &SingleSignature::new(
                         "party3",
                         fake_keys::single_signature()[2].try_into().unwrap(),
                         vec![3],
@@ -245,7 +245,7 @@ mod tests {
                 .await
                 .unwrap();
             assert_eq!(
-                vec![SingleSignatures::new(
+                vec![SingleSignature::new(
                     "party3",
                     fake_keys::single_signature()[2].try_into().unwrap(),
                     vec![3],

mithril-aggregator/src/database/repository/single_signature_repository.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use mithril_common::entities::SingleSignatures;
+use mithril_common::entities::SingleSignature;
 use mithril_common::StdResult;
 use mithril_persistence::sqlite::{ConnectionExtensions, SqliteConnection};
 
@@ -21,10 +21,10 @@ impl SingleSignatureRepository {
     /// Create a new Single Signature in database
     pub async fn create_single_signature(
         &self,
-        single_signature: &SingleSignatures,
+        single_signature: &SingleSignature,
         open_message: &OpenMessageRecord,
     ) -> StdResult<SingleSignatureRecord> {
-        let single_signature = SingleSignatureRecord::try_from_single_signatures(
+        let single_signature = SingleSignatureRecord::try_from_single_signature(
             single_signature,
             &open_message.open_message_id,
             open_message.epoch.offset_to_signer_retrieval_epoch()?,

mithril-aggregator/src/entities/open_message.rs

@@ -1,7 +1,7 @@
 use chrono::{DateTime, Utc};
 
 use mithril_common::entities::{
-    Epoch, PartyId, ProtocolMessage, SignedEntityType, SingleSignatures,
+    Epoch, PartyId, ProtocolMessage, SignedEntityType, SingleSignature,
 };
 
 use crate::database::record::{OpenMessageRecord, OpenMessageWithSingleSignaturesRecord};
@@ -29,7 +29,7 @@ pub struct OpenMessage {
     pub is_expired: bool,
 
     /// associated single signatures
-    pub single_signatures: Vec<SingleSignatures>,
+    pub single_signatures: Vec<SingleSignature>,
 
     /// Message creation datetime
     pub created_at: DateTime<Utc>,
@@ -63,8 +63,8 @@ impl OpenMessage {
             is_certified: false,
             is_expired: false,
             single_signatures: vec![
-                fake_data::single_signatures(vec![1, 4, 5]),
-                fake_data::single_signatures(vec![2, 3, 8]),
+                fake_data::single_signature(vec![1, 4, 5]),
+                fake_data::single_signature(vec![2, 3, 8]),
             ],
             created_at: Utc::now(),
             expires_at: None,
@@ -156,15 +156,15 @@ mod test {
             is_expired: false,
             created_at,
             expires_at: None,
-            single_signatures: vec![fake_data::single_signatures(vec![1, 4, 5])],
+            single_signatures: vec![fake_data::single_signature(vec![1, 4, 5])],
         };
         let expected = OpenMessage {
             epoch: Epoch(1),
             signed_entity_type: SignedEntityType::dummy(),
             protocol_message: ProtocolMessage::default(),
             is_certified: false,
             is_expired: false,
-            single_signatures: vec![fake_data::single_signatures(vec![1, 4, 5])],
+            single_signatures: vec![fake_data::single_signature(vec![1, 4, 5])],
             created_at,
             expires_at: None,
         };

mithril-aggregator/src/http_server/routes/signatures_routes.rs

@@ -58,7 +58,7 @@ mod handlers {
         let signed_entity_type = message.signed_entity_type.clone();
         let signed_message = message.signed_message.clone();
 
-        let mut signatures = match FromRegisterSingleSignatureAdapter::try_adapt(message) {
+        let mut single_signature = match FromRegisterSingleSignatureAdapter::try_adapt(message) {
             Ok(signature) => signature,
             Err(err) => {
                 warn!(logger,"register_signatures::payload decoding error"; "error" => ?err);
@@ -72,12 +72,12 @@ mod handlers {
 
         unwrap_to_internal_server_error!(
             single_signer_authenticator
-                .authenticate(&mut signatures, &signed_message)
+                .authenticate(&mut single_signature, &signed_message)
                 .await,
             logger => "single_signer_authenticator::error"
         );
 
-        if !signatures.is_authenticated() {
+        if !single_signature.is_authenticated() {
             debug!(logger, "register_signatures::unauthenticated_signature");
             return Ok(reply::bad_request(
                 "Could not authenticate signature".to_string(),
@@ -86,7 +86,7 @@ mod handlers {
         }
 
         match certifier_service
-            .register_single_signature(&signed_entity_type, &signatures)
+            .register_single_signature(&signed_entity_type, &single_signature)
             .await
         {
             Err(err) => match err.downcast_ref::<CertifierServiceError>() {

mithril-aggregator/src/message_adapters/from_register_signature.rs

@@ -1,19 +1,19 @@
 use anyhow::Context;
 use mithril_common::{
-    entities::{SingleSignatureAuthenticationStatus, SingleSignatures},
+    entities::{SingleSignature, SingleSignatureAuthenticationStatus},
     messages::{RegisterSignatureMessage, TryFromMessageAdapter},
     StdResult,
 };
 
 pub struct FromRegisterSingleSignatureAdapter;
 
-impl TryFromMessageAdapter<RegisterSignatureMessage, SingleSignatures>
+impl TryFromMessageAdapter<RegisterSignatureMessage, SingleSignature>
     for FromRegisterSingleSignatureAdapter
 {
     fn try_adapt(
         register_single_signature_message: RegisterSignatureMessage,
-    ) -> StdResult<SingleSignatures> {
-        let signatures = SingleSignatures {
+    ) -> StdResult<SingleSignature> {
+        let signature = SingleSignature {
             party_id: register_single_signature_message.party_id,
             signature: register_single_signature_message
                 .signature
@@ -25,7 +25,7 @@ impl TryFromMessageAdapter<RegisterSignatureMessage, SingleSignatures>
             authentication_status: SingleSignatureAuthenticationStatus::Unauthenticated,
         };
 
-        Ok(signatures)
+        Ok(signature)
     }
 }
 
@@ -34,14 +34,14 @@ mod tests {
     use super::*;
 
     #[test]
-    fn try_adapt_single_signatures_message_to_entity() {
+    fn try_adapt_single_signature_message_to_entity() {
         let message = RegisterSignatureMessage::dummy();
-        let signatures = FromRegisterSingleSignatureAdapter::try_adapt(message.clone()).unwrap();
+        let signature = FromRegisterSingleSignatureAdapter::try_adapt(message.clone()).unwrap();
 
-        assert_eq!(message.party_id, signatures.party_id);
+        assert_eq!(message.party_id, signature.party_id);
         assert_eq!(
             SingleSignatureAuthenticationStatus::Unauthenticated,
-            signatures.authentication_status
+            signature.authentication_status
         );
     }
 }