rename functions

Author: curiecrypt

mithril-stm/benches/size_benches.rs

@@ -30,26 +30,28 @@ where
 
     let mut key_reg = KeyRegistration::init();
     for stake in parties {
-        let p = Initializer::setup(params, stake, &mut rng);
-        key_reg.register(stake, p.verification_key()).unwrap();
+        let p = Initializer::new(params, stake, &mut rng);
+        key_reg
+            .register(stake, p.get_verification_key_proof_of_possession())
+            .unwrap();
         ps.push(p);
     }
 
     let closed_reg = key_reg.close::<H>();
 
     let ps = ps
         .into_par_iter()
-        .map(|p| p.new_signer(closed_reg.clone()).unwrap())
+        .map(|p| p.create_signer(closed_reg.clone()).unwrap())
         .collect::<Vec<Signer<H>>>();
 
     let sigs = ps
         .par_iter()
         .filter_map(|p| p.sign(&msg))
         .collect::<Vec<SingleSignature>>();
-    let clerk = Clerk::from_signer(&ps[0]);
+    let clerk = Clerk::new_clerk_from_signer(&ps[0]);
 
     // Aggregate with random parties
-    let aggr = clerk.aggregate(&sigs, &msg).unwrap();
+    let aggr = clerk.aggregate_signatures(&sigs, &msg).unwrap();
 
     println!(
         "k = {} | m = {} | nr parties = {}; {} bytes",
@@ -76,21 +78,24 @@ where
     let params = Parameters { k, m, phi_f: 0.2 };
 
     for stake in parties {
-        let initializer = Initializer::setup(params, stake, &mut rng);
+        let initializer = Initializer::new(params, stake, &mut rng);
         initializers.push(initializer.clone());
-        public_signers.push((initializer.verification_key().vk, initializer.stake));
+        public_signers.push((
+            initializer.get_verification_key_proof_of_possession().vk,
+            initializer.stake,
+        ));
     }
 
-    let core_verifier = BasicVerifier::setup(&public_signers);
+    let core_verifier = BasicVerifier::new(&public_signers);
 
     let signers: Vec<Signer<H>> = initializers
         .into_iter()
-        .filter_map(|s| s.new_core_signer(&core_verifier.eligible_parties))
+        .filter_map(|s| s.create_basic_signer(&core_verifier.eligible_parties))
         .collect();
 
     let mut signatures: Vec<SingleSignature> = Vec::with_capacity(nparties);
     for s in signers {
-        if let Some(sig) = s.core_sign(&msg, core_verifier.total_stake) {
+        if let Some(sig) = s.basic_sign(&msg, core_verifier.total_stake) {
             signatures.push(sig);
         }
     }
@@ -103,7 +108,7 @@ where
         })
         .collect::<Vec<SingleSignatureWithRegisteredParty>>();
 
-    let dedup_sigs = BasicVerifier::dedup_sigs_for_indices(
+    let dedup_sigs = BasicVerifier::select_valid_signatures_for_k_indices(
         &core_verifier.total_stake,
         &params,
         &msg,

mithril-stm/benches/stm.rs

@@ -35,7 +35,7 @@ where
 
     let mut initializers: Vec<Initializer> = Vec::with_capacity(nr_parties);
     for stake in stakes {
-        initializers.push(Initializer::setup(params, stake, &mut rng));
+        initializers.push(Initializer::new(params, stake, &mut rng));
     }
     let mut key_reg = KeyRegistration::init();
 
@@ -44,7 +44,9 @@ where
             // We need to initialise the key_reg at each iteration
             key_reg = KeyRegistration::init();
             for p in initializers.iter() {
-                key_reg.register(p.stake, p.verification_key()).unwrap();
+                key_reg
+                    .register(p.stake, p.get_verification_key_proof_of_possession())
+                    .unwrap();
             }
         })
     });
@@ -53,7 +55,7 @@ where
 
     let signers = initializers
         .into_par_iter()
-        .map(|p| p.new_signer(closed_reg.clone()).unwrap())
+        .map(|p| p.create_signer(closed_reg.clone()).unwrap())
         .collect::<Vec<Signer<H>>>();
 
     group.bench_function(BenchmarkId::new("Play all lotteries", &param_string), |b| {
@@ -64,10 +66,10 @@ where
 
     let sigs = signers.par_iter().filter_map(|p| p.sign(&msg)).collect::<Vec<_>>();
 
-    let clerk = Clerk::from_signer(&signers[0]);
+    let clerk = Clerk::new_clerk_from_signer(&signers[0]);
 
     group.bench_function(BenchmarkId::new("Aggregation", &param_string), |b| {
-        b.iter(|| clerk.aggregate(&sigs, &msg))
+        b.iter(|| clerk.aggregate_signatures(&sigs, &msg))
     });
 }
 
@@ -108,26 +110,28 @@ fn batch_benches<H>(
 
             let mut initializers: Vec<Initializer> = Vec::with_capacity(nr_parties);
             for stake in stakes {
-                initializers.push(Initializer::setup(params, stake, &mut rng));
+                initializers.push(Initializer::new(params, stake, &mut rng));
             }
             let mut key_reg = KeyRegistration::init();
             for p in initializers.iter() {
-                key_reg.register(p.stake, p.verification_key()).unwrap();
+                key_reg
+                    .register(p.stake, p.get_verification_key_proof_of_possession())
+                    .unwrap();
             }
 
             let closed_reg = key_reg.close();
 
             let signers = initializers
                 .into_par_iter()
-                .map(|p| p.new_signer(closed_reg.clone()).unwrap())
+                .map(|p| p.create_signer(closed_reg.clone()).unwrap())
                 .collect::<Vec<Signer<H>>>();
 
             let sigs = signers.par_iter().filter_map(|p| p.sign(&msg)).collect::<Vec<_>>();
 
-            let clerk = Clerk::from_signer(&signers[0]);
-            let msig = clerk.aggregate(&sigs, &msg).unwrap();
+            let clerk = Clerk::new_clerk_from_signer(&signers[0]);
+            let msig = clerk.aggregate_signatures(&sigs, &msg).unwrap();
 
-            batch_avks.push(clerk.compute_avk());
+            batch_avks.push(clerk.compute_aggregate_verification_key());
             batch_stms.push(msig);
         }
 
@@ -167,27 +171,30 @@ where
         .collect::<Vec<_>>();
 
     for stake in stakes {
-        let initializer = Initializer::setup(params, stake, &mut rng);
+        let initializer = Initializer::new(params, stake, &mut rng);
         initializers.push(initializer.clone());
-        public_signers.push((initializer.verification_key().vk, initializer.stake));
+        public_signers.push((
+            initializer.get_verification_key_proof_of_possession().vk,
+            initializer.stake,
+        ));
     }
 
-    let core_verifier = BasicVerifier::setup(&public_signers);
+    let core_verifier = BasicVerifier::new(&public_signers);
 
     let signers: Vec<Signer<H>> = initializers
         .into_iter()
-        .filter_map(|s| s.new_core_signer(&core_verifier.eligible_parties))
+        .filter_map(|s| s.create_basic_signer(&core_verifier.eligible_parties))
         .collect();
 
     group.bench_function(BenchmarkId::new("Play all lotteries", &param_string), |b| {
         b.iter(|| {
-            signers[0].core_sign(&msg, core_verifier.total_stake);
+            signers[0].basic_sign(&msg, core_verifier.total_stake);
         })
     });
 
     let signatures = signers
         .par_iter()
-        .filter_map(|p| p.core_sign(&msg, core_verifier.total_stake))
+        .filter_map(|p| p.basic_sign(&msg, core_verifier.total_stake))
         .collect::<Vec<_>>();
 
     group.bench_function(BenchmarkId::new("Core verification", &param_string), |b| {

mithril-stm/examples/key_registration.rs

@@ -38,17 +38,17 @@ fn main() {
         .collect::<Vec<_>>();
 
     // Each party generates their Stm keys
-    let party_0_init = Initializer::setup(params, stakes[0], &mut rng);
-    let party_1_init = Initializer::setup(params, stakes[1], &mut rng);
-    let party_2_init = Initializer::setup(params, stakes[2], &mut rng);
-    let party_3_init = Initializer::setup(params, stakes[3], &mut rng);
+    let party_0_init = Initializer::new(params, stakes[0], &mut rng);
+    let party_1_init = Initializer::new(params, stakes[1], &mut rng);
+    let party_2_init = Initializer::new(params, stakes[2], &mut rng);
+    let party_3_init = Initializer::new(params, stakes[3], &mut rng);
 
     // The public keys are broadcast. All participants will have the same keys.
     let parties_pks: Vec<VerificationKeyProofOfPossession> = vec![
-        party_0_init.verification_key(),
-        party_1_init.verification_key(),
-        party_2_init.verification_key(),
-        party_3_init.verification_key(),
+        party_0_init.get_verification_key_proof_of_possession(),
+        party_1_init.get_verification_key_proof_of_possession(),
+        party_2_init.get_verification_key_proof_of_possession(),
+        party_3_init.get_verification_key_proof_of_possession(),
     ];
 
     // Now, each party generates their own KeyReg instance, and registers all other participating
@@ -60,10 +60,10 @@ fn main() {
 
     // Now, with information of all participating parties (we can create the Merkle Tree), the
     // signers can be initialised.
-    let party_0 = party_0_init.new_signer(key_reg_0).unwrap();
-    let party_1 = party_1_init.new_signer(key_reg_1).unwrap();
-    let party_2 = party_2_init.new_signer(key_reg_2).unwrap();
-    let party_3 = party_3_init.new_signer(key_reg_3).unwrap();
+    let party_0 = party_0_init.create_signer(key_reg_0).unwrap();
+    let party_1 = party_1_init.create_signer(key_reg_1).unwrap();
+    let party_2 = party_2_init.create_signer(key_reg_2).unwrap();
+    let party_3 = party_3_init.create_signer(key_reg_3).unwrap();
 
     /////////////////////
     // operation phase //
@@ -110,26 +110,34 @@ 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 = Clerk::from_registration(&params, &closed_registration);
+    let clerk = Clerk::new_clerk_from_closed_key_registration(&params, &closed_registration);
 
     // Now we aggregate the signatures
-    let msig_1 = match clerk.aggregate(&complete_sigs_1, &msg) {
+    let msig_1 = match clerk.aggregate_signatures(&complete_sigs_1, &msg) {
         Ok(s) => s,
         Err(e) => {
             panic!("Aggregation failed: {e:?}")
         }
     };
-    assert!(msig_1.verify(&msg, &clerk.compute_avk(), &params).is_ok());
+    assert!(
+        msig_1
+            .verify(&msg, &clerk.compute_aggregate_verification_key(), &params)
+            .is_ok()
+    );
 
-    let msig_2 = match clerk.aggregate(&complete_sigs_2, &msg) {
+    let msig_2 = match clerk.aggregate_signatures(&complete_sigs_2, &msg) {
         Ok(s) => s,
         Err(e) => {
             panic!("Aggregation failed: {e:?}")
         }
     };
-    assert!(msig_2.verify(&msg, &clerk.compute_avk(), &params).is_ok());
+    assert!(
+        msig_2
+            .verify(&msg, &clerk.compute_aggregate_verification_key(), &params)
+            .is_ok()
+    );
 
-    let msig_3 = clerk.aggregate(&incomplete_sigs_3, &msg);
+    let msig_3 = clerk.aggregate_signatures(&incomplete_sigs_3, &msg);
     assert!(msig_3.is_err());
 }
 

mithril-stm/src/aggregate_signature/aggregate_key.rs

@@ -17,10 +17,18 @@ pub struct AggregateVerificationKey<D: Clone + Digest + FixedOutput> {
 }
 
 impl<D: Digest + Clone + FixedOutput> AggregateVerificationKey<D> {
-    pub fn get_mt_commitment(&self) -> MerkleTreeBatchCommitment<D> {
+    pub(crate) fn get_merkle_tree_batch_commitment(&self) -> MerkleTreeBatchCommitment<D> {
         self.mt_commitment.clone()
     }
 
+    #[deprecated(
+        since = "0.4.9",
+        note = "Use `get_merkle_tree_batch_commitment` instead"
+    )]
+    pub fn get_mt_commitment(&self) -> MerkleTreeBatchCommitment<D> {
+        Self::get_merkle_tree_batch_commitment(self)
+    }
+
     pub fn get_total_stake(&self) -> Stake {
         self.total_stake
     }
@@ -39,7 +47,7 @@ impl<D: Clone + Digest + FixedOutput> From<&ClosedKeyRegistration<D>>
 {
     fn from(reg: &ClosedKeyRegistration<D>) -> Self {
         Self {
-            mt_commitment: reg.merkle_tree.to_commitment_batch_compat(),
+            mt_commitment: reg.merkle_tree.to_merkle_tree_batch_commitment(),
             total_stake: reg.total_stake,
         }
     }

mithril-stm/src/aggregate_signature/basic_verifier.rs

@@ -21,7 +21,7 @@ impl BasicVerifier {
     ///     * Collect the unique signers in a hash set,
     ///     * Calculate the total stake of the eligible signers,
     ///     * Sort the eligible signers.
-    pub fn setup(public_signers: &[(BlsVerificationKey, Stake)]) -> Self {
+    pub fn new(public_signers: &[(BlsVerificationKey, Stake)]) -> Self {
         let mut total_stake: Stake = 0;
         let mut unique_parties = HashSet::new();
         for signer in public_signers.iter() {
@@ -41,6 +41,15 @@ impl BasicVerifier {
         }
     }
 
+    /// Setup a basic verifier for given list of signers.
+    ///     * Collect the unique signers in a hash set,
+    ///     * Calculate the total stake of the eligible signers,
+    ///     * Sort the eligible signers.
+    #[deprecated(since = "0.4.9", note = "Use `new` instead")]
+    pub fn setup(public_signers: &[(BlsVerificationKey, Stake)]) -> Self {
+        Self::new(public_signers)
+    }
+
     /// Preliminary verification that checks whether indices are unique and the quorum is achieved.
     pub(crate) fn preliminary_verify(
         total_stake: &Stake,
@@ -79,7 +88,7 @@ impl BasicVerifier {
     /// If there is no sufficient signatures, then the function fails.
     // todo: We need to agree on a criteria to dedup (by default we use a BTreeMap that guarantees keys order)
     // todo: not good, because it only removes index if there is a conflict (see benches)
-    pub fn dedup_sigs_for_indices(
+    pub fn select_valid_signatures_for_k_indices(
         total_stake: &Stake,
         params: &Parameters,
         msg: &[u8],
@@ -93,7 +102,7 @@ impl BasicVerifier {
         for sig_reg in sigs.iter() {
             if sig_reg
                 .sig
-                .verify_core(
+                .basic_verify(
                     params,
                     &sig_reg.reg_party.0,
                     &sig_reg.reg_party.1,
@@ -160,13 +169,33 @@ impl BasicVerifier {
                 }
             }
         }
-
         Err(AggregationError::NotEnoughSignatures(count, params.k))
     }
 
+    /// Given a slice of `sig_reg_list`, this function returns a new list of `sig_reg_list` with only valid indices.
+    /// In case of conflict (having several signatures for the same index)
+    /// it selects the smallest signature (i.e. takes the signature with the smallest scalar).
+    /// The function selects at least `self.k` indexes.
+    ///  # Error
+    /// If there is no sufficient signatures, then the function fails.
+    // todo: We need to agree on a criteria to dedup (by default we use a BTreeMap that guarantees keys order)
+    // todo: not good, because it only removes index if there is a conflict (see benches)
+    #[deprecated(
+        since = "0.4.9",
+        note = "Use `select_valid_signatures_for_k_indices` instead"
+    )]
+    pub fn dedup_sigs_for_indices(
+        total_stake: &Stake,
+        params: &Parameters,
+        msg: &[u8],
+        sigs: &[SingleSignatureWithRegisteredParty],
+    ) -> Result<Vec<SingleSignatureWithRegisteredParty>, AggregationError> {
+        Self::select_valid_signatures_for_k_indices(total_stake, params, msg, sigs)
+    }
+
     /// Collect and return `Vec<BlsSignature>, Vec<BlsVerificationKey>` which will be used
     /// by the aggregate verification.
-    pub(crate) fn collect_sigs_vks(
+    pub(crate) fn collect_signatures_verification_keys(
         sig_reg_list: &[SingleSignatureWithRegisteredParty],
     ) -> (Vec<BlsSignature>, Vec<BlsVerificationKey>) {
         let sigs = sig_reg_list
@@ -198,12 +227,16 @@ impl BasicVerifier {
             })
             .collect::<Vec<SingleSignatureWithRegisteredParty>>();
 
-        let unique_sigs =
-            Self::dedup_sigs_for_indices(&self.total_stake, parameters, msg, &sig_reg_list)?;
+        let unique_sigs = Self::select_valid_signatures_for_k_indices(
+            &self.total_stake,
+            parameters,
+            msg,
+            &sig_reg_list,
+        )?;
 
         Self::preliminary_verify(&self.total_stake, &unique_sigs, parameters, msg)?;
 
-        let (sigs, vks) = Self::collect_sigs_vks(&unique_sigs);
+        let (sigs, vks) = Self::collect_signatures_verification_keys(&unique_sigs);
 
         BlsSignature::verify_aggregate(msg.to_vec().as_slice(), &vks, &sigs)?;