feat(common): add support for aggregate signature type in multi signer aggregation

Author: jpraynaud

mithril-common/src/certificate_chain/certificate_verifier.rs

@@ -422,6 +422,8 @@ mod tests {
     use async_trait::async_trait;
     use tokio::sync::Mutex;
 
+    use mithril_stm::AggregateSignatureType;
+
     use crate::test::{
         TestLogger,
         builder::{CertificateChainBuilder, CertificateChainBuilderContext, MithrilFixtureBuilder},
@@ -487,7 +489,11 @@ mod tests {
         let clerk = ProtocolClerk::new_clerk_from_signer(first_signer);
         let aggregate_verification_key = clerk.compute_aggregate_verification_key().into();
         let multi_signature = clerk
-            .aggregate_signatures(&single_signatures, &message_hash)
+            .aggregate_signatures_with_type(
+                &single_signatures,
+                &message_hash,
+                AggregateSignatureType::default(),
+            )
             .unwrap()
             .into();
 
@@ -780,7 +786,11 @@ mod tests {
             let clerk =
                 ProtocolClerk::new_clerk_from_signer(&fixture.signers_fixture()[0].protocol_signer);
             let modified_multi_signature = clerk
-                .aggregate_signatures(&single_signatures, signed_message.as_bytes())
+                .aggregate_signatures_with_type(
+                    &single_signatures,
+                    signed_message.as_bytes(),
+                    AggregateSignatureType::default(),
+                )
                 .unwrap();
             modified_certificate.signature = CertificateSignature::MultiSignature(
                 modified_certificate.signed_entity_type(),
@@ -1080,7 +1090,11 @@ mod tests {
                 &fixture.signers_fixture()[0].protocol_closed_key_registration,
             );
             let forged_multi_signature = forged_clerk
-                .aggregate_signatures(&forged_single_signatures, signed_message.as_bytes())
+                .aggregate_signatures_with_type(
+                    &forged_single_signatures,
+                    signed_message.as_bytes(),
+                    AggregateSignatureType::default(),
+                )
                 .unwrap();
             forged_certificate.signature = CertificateSignature::MultiSignature(
                 forged_certificate.signed_entity_type(),

mithril-common/src/protocol/multi_signer.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context, anyhow};
-use mithril_stm::Parameters;
+use mithril_stm::{AggregateSignatureType, Parameters};
 
 use crate::{
     StdResult,
@@ -30,14 +30,19 @@ impl MultiSigner {
         &self,
         single_signatures: &[SingleSignature],
         message: &T,
+        aggregate_signature_type: AggregateSignatureType,
     ) -> Result<ProtocolMultiSignature, ProtocolAggregationError> {
         let protocol_signatures: Vec<_> = single_signatures
             .iter()
             .map(|single_signature| single_signature.to_protocol_signature())
             .collect();
 
         self.protocol_clerk
-            .aggregate_signatures(&protocol_signatures, message.to_message().as_bytes())
+            .aggregate_signatures_with_type(
+                &protocol_signatures,
+                message.to_message().as_bytes(),
+                aggregate_signature_type,
+            )
             .map(|multi_sig| multi_sig.into())
     }
 
@@ -117,9 +122,11 @@ mod test {
         let multi_signer = build_multi_signer(&fixture);
         let message = ProtocolMessage::default();
 
-        let error = multi_signer.aggregate_single_signatures(&[], &message).expect_err(
-            "Multi-signature should not be created with an empty single signatures list",
-        );
+        let error = multi_signer
+            .aggregate_single_signatures(&[], &message, AggregateSignatureType::default())
+            .expect_err(
+                "Multi-signature should not be created with an empty single signatures list",
+            );
 
         assert!(
             matches!(error, ProtocolAggregationError::NotEnoughSignatures(_, _)),
@@ -139,7 +146,7 @@ mod test {
             .collect();
 
         multi_signer
-            .aggregate_single_signatures(&signatures, &message)
+            .aggregate_single_signatures(&signatures, &message, AggregateSignatureType::default())
             .expect("Multi-signature should be created");
     }
 
@@ -160,7 +167,7 @@ mod test {
         signatures[4].signature = fake_keys::single_signature()[3].try_into().unwrap();
 
         multi_signer
-            .aggregate_single_signatures(&signatures, &message)
+            .aggregate_single_signatures(&signatures, &message, AggregateSignatureType::default())
             .expect("Multi-signature should be created even with one invalid signature");
     }
 

mithril-common/src/test/builder/certificate_chain_builder.rs

@@ -4,6 +4,8 @@ use std::iter::repeat_n;
 use std::ops::{Deref, DerefMut};
 use std::sync::Arc;
 
+use mithril_stm::AggregateSignatureType;
+
 use crate::{
     certificate_chain::CertificateGenesisProducer,
     crypto_helper::{
@@ -236,6 +238,7 @@ pub struct CertificateChainBuilder<'a> {
     genesis_certificate_processor: &'a GenesisCertificateProcessorFunc,
     standard_certificate_processor: &'a StandardCertificateProcessorFunc,
     certificate_chaining_method: CertificateChainingMethod,
+    aggregate_signature_type: AggregateSignatureType,
 }
 
 impl<'a> CertificateChainBuilder<'a> {
@@ -254,6 +257,7 @@ impl<'a> CertificateChainBuilder<'a> {
             genesis_certificate_processor: &|certificate, _, _| certificate,
             standard_certificate_processor: &|certificate, _| certificate,
             certificate_chaining_method: Default::default(),
+            aggregate_signature_type: Default::default(),
         }
     }
 
@@ -318,6 +322,16 @@ impl<'a> CertificateChainBuilder<'a> {
         self
     }
 
+    /// Set the aggregate signature type to use when building the certificate chain.
+    pub fn with_aggregate_signature_type(
+        mut self,
+        aggregate_signature_type: AggregateSignatureType,
+    ) -> Self {
+        self.aggregate_signature_type = aggregate_signature_type;
+
+        self
+    }
+
     /// Build the certificate chain.
     pub fn build(self) -> CertificateChainFixture {
         let (genesis_signer, genesis_verifier) = CertificateChainBuilder::setup_genesis();
@@ -509,7 +523,11 @@ impl<'a> CertificateChainBuilder<'a> {
             .collect::<Vec<_>>();
         let clerk = CertificateChainBuilder::compute_clerk_for_signers(&fixture.signers_fixture());
         let multi_signature = clerk
-            .aggregate_signatures(&single_signatures, certificate.signed_message.as_bytes())
+            .aggregate_signatures_with_type(
+                &single_signatures,
+                certificate.signed_message.as_bytes(),
+                self.aggregate_signature_type,
+            )
             .unwrap();
         certificate.signature = CertificateSignature::MultiSignature(
             SignedEntityType::CardanoDatabase(CardanoDbBeacon::new(