rename: aggregate signature

Author: curiecrypt

mithril-stm/benches/size_benches.rs

@@ -4,8 +4,8 @@ use blake2::{
     Blake2b, Digest,
 };
 use mithril_stm::{
-    CoreVerifier, Initializer, KeyRegistration, Parameters, Signer, SingleSignature,
-    SingleSignatureWithRegisteredParty, Stake, StmClerk, StmVerificationKey,
+    BasicVerifier, Clerk, Initializer, KeyRegistration, Parameters, Signer, SingleSignature,
+    SingleSignatureWithRegisteredParty, Stake, StmVerificationKey,
 };
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
@@ -48,7 +48,7 @@ where
         .par_iter()
         .filter_map(|p| p.sign(&msg))
         .collect::<Vec<SingleSignature>>();
-    let clerk = StmClerk::from_signer(&ps[0]);
+    let clerk = Clerk::from_signer(&ps[0]);
 
     // Aggregate with random parties
     let aggr = clerk.aggregate(&sigs, &msg).unwrap();
@@ -85,7 +85,7 @@ where
         public_signers.push((initializer.verification_key().vk, initializer.stake));
     }
 
-    let core_verifier = CoreVerifier::setup(&public_signers);
+    let core_verifier = BasicVerifier::setup(&public_signers);
 
     let signers: Vec<Signer<H>> = initializers
         .into_iter()
@@ -107,7 +107,7 @@ where
         })
         .collect::<Vec<SingleSignatureWithRegisteredParty>>();
 
-    let dedup_sigs = CoreVerifier::dedup_sigs_for_indices(
+    let dedup_sigs = BasicVerifier::dedup_sigs_for_indices(
         &core_verifier.total_stake,
         &params,
         &msg,

mithril-stm/benches/stm.rs

@@ -2,8 +2,8 @@ use blake2::digest::{Digest, FixedOutput};
 use blake2::{digest::consts::U32, Blake2b};
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use mithril_stm::{
-    CoreVerifier, Initializer, KeyRegistration, Parameters, Signer, Stake, StmAggrSig, StmClerk,
-    StmVerificationKey,
+    AggregateSignature, BasicVerifier, Clerk, Initializer, KeyRegistration, Parameters, Signer,
+    Stake, StmVerificationKey,
 };
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
@@ -67,7 +67,7 @@ where
         .filter_map(|p| p.sign(&msg))
         .collect::<Vec<_>>();
 
-    let clerk = StmClerk::from_signer(&signers[0]);
+    let clerk = Clerk::from_signer(&signers[0]);
 
     group.bench_function(BenchmarkId::new("Aggregation", &param_string), |b| {
         b.iter(|| clerk.aggregate(&sigs, &msg))
@@ -130,7 +130,7 @@ fn batch_benches<H>(
                 .filter_map(|p| p.sign(&msg))
                 .collect::<Vec<_>>();
 
-            let clerk = StmClerk::from_signer(&signers[0]);
+            let clerk = Clerk::from_signer(&signers[0]);
             let msig = clerk.aggregate(&sigs, &msg).unwrap();
 
             batch_avks.push(clerk.compute_avk());
@@ -139,8 +139,13 @@ fn batch_benches<H>(
 
         group.bench_function(BenchmarkId::new("Batch Verification", batch_string), |b| {
             b.iter(|| {
-                StmAggrSig::batch_verify(&batch_stms, &batch_msgs, &batch_avks, &batch_params)
-                    .is_ok()
+                AggregateSignature::batch_verify(
+                    &batch_stms,
+                    &batch_msgs,
+                    &batch_avks,
+                    &batch_params,
+                )
+                .is_ok()
             })
         });
     }
@@ -173,7 +178,7 @@ where
         public_signers.push((initializer.verification_key().vk, initializer.stake));
     }
 
-    let core_verifier = CoreVerifier::setup(&public_signers);
+    let core_verifier = BasicVerifier::setup(&public_signers);
 
     let signers: Vec<Signer<H>> = initializers
         .into_iter()

mithril-stm/examples/key_registration.rs

@@ -3,7 +3,7 @@
 //! run presented in `tests/integration.rs`, we explicitly treat each party individually.
 use blake2::{digest::consts::U32, Blake2b};
 use mithril_stm::{
-    ClosedKeyRegistration, Initializer, KeyRegistration, Parameters, Stake, StmClerk,
+    Clerk, ClosedKeyRegistration, Initializer, KeyRegistration, Parameters, Stake,
     StmVerificationKeyPoP,
 };
 
@@ -110,7 +110,7 @@ fn main() {
     let incomplete_sigs_3 = vec![party_0_sigs, party_1_sigs, party_2_sigs, party_3_sigs];
 
     let closed_registration = local_reg(&stakes, &parties_pks);
-    let clerk = StmClerk::from_registration(&params, &closed_registration);
+    let clerk = Clerk::from_registration(&params, &closed_registration);
 
     // Now we aggregate the signatures
     let msig_1 = match clerk.aggregate(&complete_sigs_1, &msg) {

mithril-stm/src/aggregate_signature/aggregate_key.rs

@@ -11,12 +11,12 @@ use crate::{ClosedKeyRegistration, Stake};
     serialize = "MerkleBatchPath<D>: Serialize",
     deserialize = "MerkleBatchPath<D>: Deserialize<'de>"
 ))]
-pub struct StmAggrVerificationKey<D: Clone + Digest + FixedOutput> {
+pub struct AggregateVerificationKey<D: Clone + Digest + FixedOutput> {
     mt_commitment: MerkleTreeBatchCommitment<D>,
     total_stake: Stake,
 }
 
-impl<D: Digest + Clone + FixedOutput> StmAggrVerificationKey<D> {
+impl<D: Digest + Clone + FixedOutput> AggregateVerificationKey<D> {
     pub fn get_mt_commitment(&self) -> MerkleTreeBatchCommitment<D> {
         self.mt_commitment.clone()
     }
@@ -26,16 +26,16 @@ impl<D: Digest + Clone + FixedOutput> StmAggrVerificationKey<D> {
     }
 }
 
-impl<D: Digest + Clone + FixedOutput> PartialEq for StmAggrVerificationKey<D> {
+impl<D: Digest + Clone + FixedOutput> PartialEq for AggregateVerificationKey<D> {
     fn eq(&self, other: &Self) -> bool {
         self.mt_commitment == other.mt_commitment && self.total_stake == other.total_stake
     }
 }
 
-impl<D: Digest + Clone + FixedOutput> Eq for StmAggrVerificationKey<D> {}
+impl<D: Digest + Clone + FixedOutput> Eq for AggregateVerificationKey<D> {}
 
 impl<D: Clone + Digest + FixedOutput> From<&ClosedKeyRegistration<D>>
-    for StmAggrVerificationKey<D>
+    for AggregateVerificationKey<D>
 {
     fn from(reg: &ClosedKeyRegistration<D>) -> Self {
         Self {

mithril-stm/src/aggregate_signature/clerk.rs

@@ -1,21 +1,21 @@
 use blake2::digest::{Digest, FixedOutput};
 
 use crate::{
-    AggregationError, ClosedKeyRegistration, CoreVerifier, Index, Parameters, Signer,
-    SingleSignature, SingleSignatureWithRegisteredParty, Stake, StmAggrSig, StmAggrVerificationKey,
-    StmVerificationKey,
+    AggregateSignature, AggregateVerificationKey, AggregationError, BasicVerifier,
+    ClosedKeyRegistration, Index, Parameters, Signer, SingleSignature,
+    SingleSignatureWithRegisteredParty, Stake, StmVerificationKey,
 };
 
 /// `StmClerk` can verify and aggregate `StmSig`s and verify `StmMultiSig`s.
 /// Clerks can only be generated with the registration closed.
 /// This avoids that a Merkle Tree is computed before all parties have registered.
 #[derive(Debug, Clone)]
-pub struct StmClerk<D: Clone + Digest> {
+pub struct Clerk<D: Clone + Digest> {
     pub(crate) closed_reg: ClosedKeyRegistration<D>,
     pub(crate) params: Parameters,
 }
 
-impl<D: Digest + Clone + FixedOutput> StmClerk<D> {
+impl<D: Digest + Clone + FixedOutput> Clerk<D> {
     /// Create a new `Clerk` from a closed registration instance.
     pub fn from_registration(params: &Parameters, closed_reg: &ClosedKeyRegistration<D>) -> Self {
         Self {
@@ -48,7 +48,7 @@ impl<D: Digest + Clone + FixedOutput> StmClerk<D> {
         &self,
         sigs: &[SingleSignature],
         msg: &[u8],
-    ) -> Result<StmAggrSig<D>, AggregationError> {
+    ) -> Result<AggregateSignature<D>, AggregationError> {
         let sig_reg_list = sigs
             .iter()
             .map(|sig| SingleSignatureWithRegisteredParty {
@@ -57,9 +57,9 @@ impl<D: Digest + Clone + FixedOutput> StmClerk<D> {
             })
             .collect::<Vec<SingleSignatureWithRegisteredParty>>();
 
-        let avk = StmAggrVerificationKey::from(&self.closed_reg);
+        let avk = AggregateVerificationKey::from(&self.closed_reg);
         let msgp = avk.get_mt_commitment().concat_with_msg(msg);
-        let mut unique_sigs = CoreVerifier::dedup_sigs_for_indices(
+        let mut unique_sigs = BasicVerifier::dedup_sigs_for_indices(
             &self.closed_reg.total_stake,
             &self.params,
             &msgp,
@@ -75,15 +75,15 @@ impl<D: Digest + Clone + FixedOutput> StmClerk<D> {
 
         let batch_proof = self.closed_reg.merkle_tree.get_batched_path(mt_index_list);
 
-        Ok(StmAggrSig {
+        Ok(AggregateSignature {
             signatures: unique_sigs,
             batch_proof,
         })
     }
 
     /// Compute the `StmAggrVerificationKey` related to the used registration.
-    pub fn compute_avk(&self) -> StmAggrVerificationKey<D> {
-        StmAggrVerificationKey::from(&self.closed_reg)
+    pub fn compute_avk(&self) -> AggregateVerificationKey<D> {
+        AggregateVerificationKey::from(&self.closed_reg)
     }
 
     /// Get the (VK, stake) of a party given its index.

mithril-stm/src/aggregate_signature/core_verifier.rs

@@ -9,14 +9,14 @@ use crate::{
 };
 
 /// Full node verifier including the list of eligible signers and the total stake of the system.
-pub struct CoreVerifier {
+pub struct BasicVerifier {
     /// List of registered parties.
     pub eligible_parties: Vec<RegisteredParty>,
     /// Total stake of registered parties.
     pub total_stake: Stake,
 }
 
-impl CoreVerifier {
+impl BasicVerifier {
     /// Setup a core verifier for given list of signers.
     ///     * Collect the unique signers in a hash set,
     ///     * Calculate the total stake of the eligible signers,
@@ -35,7 +35,7 @@ impl CoreVerifier {
 
         let mut eligible_parties: Vec<_> = unique_parties.into_iter().collect();
         eligible_parties.sort_unstable();
-        CoreVerifier {
+        BasicVerifier {
             eligible_parties,
             total_stake,
         }