rename types, review suggestions, final corrections

Author: curiecrypt

mithril-stm/benches/size_benches.rs

@@ -5,7 +5,7 @@ use blake2::{
 };
 use mithril_stm::{
     BasicVerifier, Clerk, Initializer, KeyRegistration, Parameters, Signer, SingleSignature,
-    SingleSignatureWithRegisteredParty, Stake, StmVerificationKey,
+    SingleSignatureWithRegisteredParty, Stake, VerificationKey,
 };
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
@@ -70,7 +70,7 @@ where
     let mut msg = [0u8; 16];
     rng.fill_bytes(&mut msg);
 
-    let mut public_signers: Vec<(StmVerificationKey, Stake)> = Vec::with_capacity(nparties);
+    let mut public_signers: Vec<(VerificationKey, Stake)> = Vec::with_capacity(nparties);
     let mut initializers: Vec<Initializer> = Vec::with_capacity(nparties);
 
     let parties = (0..nparties)

mithril-stm/benches/stm.rs

@@ -3,7 +3,7 @@ use blake2::{digest::consts::U32, Blake2b};
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use mithril_stm::{
     AggregateSignature, BasicVerifier, Clerk, Initializer, KeyRegistration, Parameters, Signer,
-    Stake, StmVerificationKey,
+    Stake, VerificationKey,
 };
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
@@ -151,7 +151,7 @@ fn batch_benches<H>(
     }
 }
 
-fn core_verifier_benches<H>(c: &mut Criterion, nr_parties: usize, params: Parameters)
+fn basic_verifier_benches<H>(c: &mut Criterion, nr_parties: usize, params: Parameters)
 where
     H: Clone + Debug + Digest + Send + Sync + FixedOutput + Default,
 {
@@ -160,7 +160,7 @@ where
     let mut msg = [0u8; 16];
     rng.fill_bytes(&mut msg);
 
-    let mut public_signers: Vec<(StmVerificationKey, Stake)> = Vec::with_capacity(nr_parties);
+    let mut public_signers: Vec<(VerificationKey, Stake)> = Vec::with_capacity(nr_parties);
     let mut initializers: Vec<Initializer> = Vec::with_capacity(nr_parties);
 
     let param_string = format!(
@@ -229,7 +229,7 @@ fn stm_benches_blake_300(c: &mut Criterion) {
 }
 
 fn core_verifier_benches_blake_300(c: &mut Criterion) {
-    core_verifier_benches::<Blake2b<U32>>(
+    basic_verifier_benches::<Blake2b<U32>>(
         c,
         300,
         Parameters {
@@ -268,7 +268,7 @@ fn stm_benches_blake_2000(c: &mut Criterion) {
 }
 
 fn core_verifier_benches_blake_2000(c: &mut Criterion) {
-    core_verifier_benches::<Blake2b<U32>>(
+    basic_verifier_benches::<Blake2b<U32>>(
         c,
         2000,
         Parameters {

mithril-stm/examples/key_registration.rs

@@ -4,7 +4,7 @@
 use blake2::{digest::consts::U32, Blake2b};
 use mithril_stm::{
     Clerk, ClosedKeyRegistration, Initializer, KeyRegistration, Parameters, Stake,
-    StmVerificationKeyPoP,
+    VerificationKeyProofOfPossession,
 };
 
 use rand_chacha::ChaCha20Rng;
@@ -44,7 +44,7 @@ fn main() {
     let party_3_init = Initializer::setup(params, stakes[3], &mut rng);
 
     // The public keys are broadcast. All participants will have the same keys.
-    let parties_pks: Vec<StmVerificationKeyPoP> = vec![
+    let parties_pks: Vec<VerificationKeyProofOfPossession> = vec![
         party_0_init.verification_key(),
         party_1_init.verification_key(),
         party_2_init.verification_key(),
@@ -133,7 +133,7 @@ fn main() {
     assert!(msig_3.is_err());
 }
 
-fn local_reg(ids: &[u64], pks: &[StmVerificationKeyPoP]) -> ClosedKeyRegistration<H> {
+fn local_reg(ids: &[u64], pks: &[VerificationKeyProofOfPossession]) -> ClosedKeyRegistration<H> {
     let mut local_keyreg = KeyRegistration::init();
     // data, such as the public key, stake and id.
     for (&pk, id) in pks.iter().zip(ids.iter()) {

mithril-stm/src/aggregate_signature/core_verifier.rs renamed to mithril-stm/src/aggregate_signature/basic_verifier.rs

@@ -1,7 +1,7 @@
 use std::collections::{BTreeMap, HashMap, HashSet};
 
 use crate::bls_multi_signature::{BlsSignature, BlsVerificationKey};
-use crate::key_reg::RegisteredParty;
+use crate::key_registration::RegisteredParty;
 use crate::merkle_tree::MerkleTreeLeaf;
 use crate::{
     AggregationError, CoreVerifierError, Index, Parameters, SingleSignature,
@@ -17,7 +17,7 @@ pub struct BasicVerifier {
 }
 
 impl BasicVerifier {
-    /// Setup a core verifier for given list of signers.
+    /// 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.
@@ -164,7 +164,7 @@ impl BasicVerifier {
         Err(AggregationError::NotEnoughSignatures(count, params.k))
     }
 
-    /// Collect and return `Vec<Signature>, Vec<VerificationKey>` which will be used
+    /// Collect and return `Vec<BlsSignature>, Vec<BlsVerificationKey>` which will be used
     /// by the aggregate verification.
     pub(crate) fn collect_sigs_vks(
         sig_reg_list: &[SingleSignatureWithRegisteredParty],

mithril-stm/src/aggregate_signature/clerk.rs

@@ -3,10 +3,10 @@ use blake2::digest::{Digest, FixedOutput};
 use crate::{
     AggregateSignature, AggregateVerificationKey, AggregationError, BasicVerifier,
     ClosedKeyRegistration, Index, Parameters, Signer, SingleSignature,
-    SingleSignatureWithRegisteredParty, Stake, StmVerificationKey,
+    SingleSignatureWithRegisteredParty, Stake, VerificationKey,
 };
 
-/// `StmClerk` can verify and aggregate `StmSig`s and verify `StmMultiSig`s.
+/// `Clerk` can verify and aggregate `SingleSignature`s and verify `AggregateSignature`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)]
@@ -43,7 +43,7 @@ impl<D: Digest + Clone + FixedOutput> Clerk<D> {
     /// This function first deduplicates the repeated signatures, and if there are enough signatures, it collects the merkle tree indexes of unique signatures.
     /// The list of merkle tree indexes is used to create a batch proof, to prove that all signatures are from eligible signers.
     ///
-    /// It returns an instance of `StmAggrSig`.
+    /// It returns an instance of `AggregateSignature`.
     pub fn aggregate(
         &self,
         sigs: &[SingleSignature],
@@ -87,7 +87,7 @@ impl<D: Digest + Clone + FixedOutput> Clerk<D> {
     }
 
     /// Get the (VK, stake) of a party given its index.
-    pub fn get_reg_party(&self, party_index: &Index) -> Option<(StmVerificationKey, Stake)> {
+    pub fn get_reg_party(&self, party_index: &Index) -> Option<(VerificationKey, Stake)> {
         self.closed_reg
             .reg_parties
             .get(*party_index as usize)

mithril-stm/src/aggregate_signature/mod.rs

@@ -1,11 +1,11 @@
 mod aggregate_key;
+mod basic_verifier;
 mod clerk;
-mod core_verifier;
 mod signature;
 
 pub use aggregate_key::*;
+pub use basic_verifier::*;
 pub use clerk::*;
-pub use core_verifier::*;
 pub use signature::*;
 
 #[cfg(test)]
@@ -481,7 +481,7 @@ mod tests {
     }
 
     // ---------------------------------------------------------------------
-    // Core verifier
+    // Basic verifier
     // ---------------------------------------------------------------------
     fn setup_equal_core_parties(
         params: Parameters,

mithril-stm/src/aggregate_signature/signature.rs

@@ -3,14 +3,14 @@ use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 
 use crate::bls_multi_signature::{BlsSignature, BlsVerificationKey};
-use crate::key_reg::RegisteredParty;
+use crate::key_registration::RegisteredParty;
 use crate::merkle_tree::MerkleBatchPath;
 use crate::{
     AggregateVerificationKey, BasicVerifier, Parameters, SingleSignatureWithRegisteredParty,
     StmAggregateSignatureError,
 };
 
-/// `StmMultiSig` uses the "concatenation" proving system (as described in Section 4.3 of the original paper.)
+/// `AggregateSignature` uses the "concatenation" proving system (as described in Section 4.3 of the original paper.)
 /// This means that the aggregated signature contains a vector with all individual signatures.
 /// BatchPath is also a part of the aggregate signature which covers path for all signatures.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -27,7 +27,7 @@ pub struct AggregateSignature<D: Clone + Digest + FixedOutput> {
 impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
     /// Verify all checks from signatures, except for the signature verification itself.
     ///
-    /// Indices and quorum are checked by `CoreVerifier::preliminary_verify` with `msgp`.
+    /// Indices and quorum are checked by `BasicVerifier::preliminary_verify` with `msgp`.
     /// It collects leaves from signatures and checks the batch proof.
     /// After batch proof is checked, it collects and returns the signatures and
     /// verification keys to be used by aggregate verification.
@@ -157,7 +157,7 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
         out
     }
 
-    ///Extract a `StmAggrSig` from a byte slice.
+    ///Extract a `AggregateSignature` from a byte slice.
     pub fn from_bytes(
         bytes: &[u8],
     ) -> Result<AggregateSignature<D>, StmAggregateSignatureError<D>> {

mithril-stm/src/bls_multi_signature/mod.rs

@@ -96,7 +96,7 @@ mod tests {
 
     use crate::bls_multi_signature::helper::unsafe_helpers::{p1_affine_to_sig, p2_affine_to_vk};
     use crate::error::{MultiSignatureError, RegisterError};
-    use crate::key_reg::KeyRegistration;
+    use crate::key_registration::KeyRegistration;
 
     use super::*;
 
@@ -156,7 +156,7 @@ mod tests {
 
             let p2 = blst_p2::default();
             let vk_infinity = BlsVerificationKey(p2_affine_to_vk(&p2));
-            let vkpop_infinity = BlsVerificationKeyProofOfPossesion { vk: vk_infinity, pop };
+            let vkpop_infinity = BlsVerificationKeyProofOfPossession { vk: vk_infinity, pop };
 
             let result = vkpop_infinity.check();
             assert_eq!(result, Err(MultiSignatureError::VerificationKeyInfinity(Box::new(vkpop_infinity.vk))));
@@ -171,11 +171,11 @@ mod tests {
             let pop = BlsProofOfPossession::from(&sk);
             let p2 = blst_p2::default();
             let vk_infinity = BlsVerificationKey(p2_affine_to_vk(&p2));
-            let vkpop_infinity = BlsVerificationKeyProofOfPossesion { vk: vk_infinity, pop };
+            let vkpop_infinity = BlsVerificationKeyProofOfPossession { vk: vk_infinity, pop };
 
             for _ in 0..num_sigs {
                 let sk = BlsSigningKey::generate(&mut rng);
-                let vkpop = BlsVerificationKeyProofOfPossesion::from(&sk);
+                let vkpop = BlsVerificationKeyProofOfPossession::from(&sk);
                 let _ = kr.register(1, vkpop);
             }
 
@@ -221,9 +221,9 @@ mod tests {
             let vk_bytes = vk.to_bytes();
             let vk2 = BlsVerificationKey::from_bytes(&vk_bytes).unwrap();
             assert_eq!(vk, vk2);
-            let vkpop = BlsVerificationKeyProofOfPossesion::from(&sk);
+            let vkpop = BlsVerificationKeyProofOfPossession::from(&sk);
             let vkpop_bytes = vkpop.to_bytes();
-            let vkpop2: BlsVerificationKeyProofOfPossesion = BlsVerificationKeyProofOfPossesion::from_bytes(&vkpop_bytes).unwrap();
+            let vkpop2: BlsVerificationKeyProofOfPossession = BlsVerificationKeyProofOfPossession::from_bytes(&vkpop_bytes).unwrap();
             assert_eq!(vkpop, vkpop2);
 
             // Now we test serde
@@ -232,7 +232,7 @@ mod tests {
             let (decoded,_) = bincode::serde::decode_from_slice::<BlsVerificationKey,_>(&encoded, bincode::config::legacy()).unwrap();
             assert_eq!(vk, decoded);
             let encoded = bincode::serde::encode_to_vec(vkpop, bincode::config::legacy()).unwrap();
-            let (decoded,_) = bincode::serde::decode_from_slice::<BlsVerificationKeyProofOfPossesion,_>(&encoded, bincode::config::legacy()).unwrap();
+            let (decoded,_) = bincode::serde::decode_from_slice::<BlsVerificationKeyProofOfPossession,_>(&encoded, bincode::config::legacy()).unwrap();
             assert_eq!(vkpop, decoded);
         }
 

mithril-stm/src/bls_multi_signature/verification_key.rs

@@ -124,14 +124,14 @@ impl From<&BlsSigningKey> for BlsVerificationKey {
 
 /// MultiSig public key, contains the verification key and the proof of possession.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct BlsVerificationKeyProofOfPossesion {
+pub struct BlsVerificationKeyProofOfPossession {
     /// The verification key.
     pub vk: BlsVerificationKey,
     /// Proof of Possession.
     pub pop: BlsProofOfPossession,
 }
 
-impl BlsVerificationKeyProofOfPossesion {
+impl BlsVerificationKeyProofOfPossession {
     /// if `e(k1,g2) = e(H_G1("PoP" || mvk),mvk)` and `e(g1,mvk) = e(k2,g2)`
     /// are both true, return 1. The first part is a signature verification
     /// of message "PoP", while the second we need to compute the pairing
@@ -170,7 +170,7 @@ impl BlsVerificationKeyProofOfPossesion {
         vkpop_bytes
     }
 
-    /// Deserialize a byte string to a `PublicKeyPoP`.
+    /// Deserialize a byte string to a `BlsVerificationKeyProofOfPossession`.
     pub fn from_bytes(bytes: &[u8]) -> Result<Self, MultiSignatureError> {
         let mvk = BlsVerificationKey::from_bytes(
             bytes
@@ -188,8 +188,8 @@ impl BlsVerificationKeyProofOfPossesion {
     }
 }
 
-impl From<&BlsSigningKey> for BlsVerificationKeyProofOfPossesion {
-    /// Convert a secret key into a `VerificationKeyPoP` by simply converting to a
+impl From<&BlsSigningKey> for BlsVerificationKeyProofOfPossession {
+    /// Convert a secret key into a `BlsVerificationKeyProofOfPossession` by simply converting to a
     /// `MspMvk` and `MspPoP`.
     fn from(sk: &BlsSigningKey) -> Self {
         Self {

mithril-stm/src/error.rs

@@ -3,7 +3,7 @@ use blake2::digest::{Digest, FixedOutput};
 use blst::BLST_ERROR;
 
 use crate::bls_multi_signature::{
-    BlsSignature, BlsVerificationKey, BlsVerificationKeyProofOfPossesion,
+    BlsSignature, BlsVerificationKey, BlsVerificationKeyProofOfPossession,
 };
 use crate::merkle_tree::{MerkleBatchPath, MerklePath};
 
@@ -24,7 +24,7 @@ pub enum MultiSignatureError {
 
     /// Incorrect proof of possession
     #[error("Key with invalid PoP")]
-    KeyInvalid(Box<BlsVerificationKeyProofOfPossesion>),
+    KeyInvalid(Box<BlsVerificationKeyProofOfPossession>),
 
     /// At least one signature in the batch is invalid
     #[error("One signature in the batch is invalid")]
@@ -251,7 +251,7 @@ pub enum RegisterError {
 
     /// The supplied key is not valid
     #[error("The verification of correctness of the supplied key is invalid.")]
-    KeyInvalid(Box<BlsVerificationKeyProofOfPossesion>),
+    KeyInvalid(Box<BlsVerificationKeyProofOfPossession>),
 
     /// Serialization error
     #[error("Serialization error")]