MembershipDigest - benches and common not working

Author: curiecrypt

mithril-stm/README.md

@@ -69,10 +69,10 @@ use rayon::prelude::*;
 
 use mithril_stm::{
     AggregateSignatureType, AggregationError, Clerk, Initializer, KeyRegistration, Parameters,
-    Signer, SingleSignature,
+    Signer, SingleSignature, CustomMembershipDigest
 };
 
-type H = Blake2b<U32>;
+type H = CustomMembershipDigest;
 
 let nparties = 32;
 let mut rng = ChaCha20Rng::from_seed([0u8; 32]);

mithril-stm/examples/key_registration.rs

@@ -6,11 +6,19 @@ use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
 
 use mithril_stm::{
-    AggregateSignatureType, Clerk, ClosedKeyRegistration, Initializer, KeyRegistration, Parameters,
-    Stake, VerificationKeyProofOfPossession,
+    AggregateSignatureType, Clerk, ClosedKeyRegistration, Initializer, KeyRegistration,
+    MembershipDigest, Parameters, Stake, VerificationKeyProofOfPossession,
 };
 
-type H = Blake2b<U32>;
+#[derive(Clone, Debug)]
+pub struct CustomMembershipDigest {}
+impl MembershipDigest for CustomMembershipDigest {
+    type ConcatenationHash = Blake2b<U32>;
+    #[cfg(feature = "future_snark")]
+    type SnarkHash = Blake2b<U32>;
+}
+
+type H = CustomMembershipDigest;
 
 fn main() {
     let nparties = 4;

mithril-stm/src/lib.rs

@@ -15,11 +15,11 @@
 //!
 //! use mithril_stm::{
 //!    AggregateSignatureType, AggregationError, Clerk, Initializer, KeyRegistration, Parameters,
-//!    Signer, SingleSignature,
+//!    Signer, SingleSignature, CustomMembershipDigest
 //! };
 //!
 //! let nparties = 4; // Use a small number of parties for this example
-//! type D = Blake2b<U32>; // Setting the hash function for convenience
+//! type D = CustomMembershipDigest; // Setting the hash function for convenience
 //!
 //! let mut rng = ChaCha20Rng::from_seed([0u8; 32]); // create and initialize rng
 //! let mut msg = [0u8; 16]; // setting an arbitrary message
@@ -116,6 +116,7 @@ mod proof_system;
 mod protocol;
 mod signature_scheme;
 
+pub use membership_commitment::{CustomMembershipDigest, MembershipDigest};
 pub use protocol::*;
 
 #[cfg(feature = "benchmark-internals")]

mithril-stm/src/membership_commitment/mod.rs

@@ -1,3 +1,23 @@
 mod merkle_tree;
 
 pub use merkle_tree::*;
+
+use blake2::{Blake2b, digest::consts::U32};
+use digest::{Digest, FixedOutput};
+use std::fmt::Debug;
+
+pub trait MembershipDigest: Send + Sync {
+    type ConcatenationHash: Digest + FixedOutput + Clone + Debug;
+    #[cfg(feature = "future_snark")]
+    type SnarkHash: Digest + FixedOutput + Clone;
+}
+
+/// Only for tests
+#[derive(Clone, Debug)]
+pub struct CustomMembershipDigest {}
+
+impl MembershipDigest for CustomMembershipDigest {
+    type ConcatenationHash = Blake2b<U32>;
+    #[cfg(feature = "future_snark")]
+    type SnarkHash = Blake2b<U32>;
+}

mithril-stm/src/proof_system/concatenation.rs

@@ -1,11 +1,10 @@
 use anyhow::Context;
-use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 
 use crate::{
     AggregateSignatureError, AggregateVerificationKey, BasicVerifier, Clerk, Parameters,
     RegisteredParty, SingleSignature, SingleSignatureWithRegisteredParty, StmResult,
-    membership_commitment::MerkleBatchPath,
+    membership_commitment::{MembershipDigest, MerkleBatchPath},
     signature_scheme::{BlsSignature, BlsVerificationKey},
 };
 
@@ -14,16 +13,16 @@ use crate::{
 /// BatchPath is also a part of the aggregate signature which covers path for all signatures.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(bound(
-    serialize = "MerkleBatchPath<D>: Serialize",
-    deserialize = "MerkleBatchPath<D>: Deserialize<'de>"
+    serialize = "MerkleBatchPath<D::ConcatenationHash>: Serialize",
+    deserialize = "MerkleBatchPath<D::ConcatenationHash>: Deserialize<'de>"
 ))]
-pub struct ConcatenationProof<D: Clone + Digest + FixedOutput> {
+pub struct ConcatenationProof<D: MembershipDigest> {
     pub(crate) signatures: Vec<SingleSignatureWithRegisteredParty>,
     /// The list of unique merkle tree nodes that covers path for all signatures.
-    pub batch_proof: MerkleBatchPath<D>,
+    pub batch_proof: MerkleBatchPath<D::ConcatenationHash>,
 }
 
-impl<D: Clone + Digest + FixedOutput + Send + Sync> ConcatenationProof<D> {
+impl<D: MembershipDigest> ConcatenationProof<D> {
     /// Aggregate a set of signatures for their corresponding indices.
     ///
     /// This function first deduplicates the repeated signatures, and if there are enough signatures, it collects the merkle tree indexes of unique signatures.

mithril-stm/src/protocol/aggregate_signature/aggregate_key.rs

@@ -1,33 +1,34 @@
-use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 
 use crate::{
     ClosedKeyRegistration, Stake,
-    membership_commitment::{MerkleBatchPath, MerkleTreeBatchCommitment},
+    membership_commitment::{MembershipDigest, MerkleBatchPath, MerkleTreeBatchCommitment},
 };
 
 /// Stm aggregate key (batch compatible), which contains the merkle tree commitment and the total stake of the system.
 /// Batch Compat Merkle tree commitment includes the number of leaves in the tree in order to obtain batch path.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(bound(
-    serialize = "MerkleBatchPath<D>: Serialize",
-    deserialize = "MerkleBatchPath<D>: Deserialize<'de>"
+    serialize = "MerkleBatchPath<D::ConcatenationHash>: Serialize",
+    deserialize = "MerkleBatchPath<D::ConcatenationHash>: Deserialize<'de>"
 ))]
-pub struct AggregateVerificationKey<D: Clone + Digest + FixedOutput> {
-    mt_commitment: MerkleTreeBatchCommitment<D>,
+pub struct AggregateVerificationKey<D: MembershipDigest> {
+    mt_commitment: MerkleTreeBatchCommitment<D::ConcatenationHash>,
     total_stake: Stake,
 }
 
-impl<D: Digest + Clone + FixedOutput> AggregateVerificationKey<D> {
-    pub(crate) fn get_merkle_tree_batch_commitment(&self) -> MerkleTreeBatchCommitment<D> {
+impl<D: MembershipDigest> AggregateVerificationKey<D> {
+    pub(crate) fn get_merkle_tree_batch_commitment(
+        &self,
+    ) -> MerkleTreeBatchCommitment<D::ConcatenationHash> {
         self.mt_commitment.clone()
     }
 
     #[deprecated(
         since = "0.5.0",
         note = "Use `get_merkle_tree_batch_commitment` instead"
     )]
-    pub fn get_mt_commitment(&self) -> MerkleTreeBatchCommitment<D> {
+    pub fn get_mt_commitment(&self) -> MerkleTreeBatchCommitment<D::ConcatenationHash> {
         Self::get_merkle_tree_batch_commitment(self)
     }
 
@@ -36,17 +37,15 @@ impl<D: Digest + Clone + FixedOutput> AggregateVerificationKey<D> {
     }
 }
 
-impl<D: Digest + Clone + FixedOutput> PartialEq for AggregateVerificationKey<D> {
+impl<D: MembershipDigest> 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 AggregateVerificationKey<D> {}
+impl<D: MembershipDigest> Eq for AggregateVerificationKey<D> {}
 
-impl<D: Clone + Digest + FixedOutput> From<&ClosedKeyRegistration<D>>
-    for AggregateVerificationKey<D>
-{
+impl<D: MembershipDigest> From<&ClosedKeyRegistration<D>> for AggregateVerificationKey<D> {
     fn from(reg: &ClosedKeyRegistration<D>) -> Self {
         Self {
             mt_commitment: reg.merkle_tree.to_merkle_tree_batch_commitment(),

mithril-stm/src/protocol/aggregate_signature/clerk.rs

@@ -1,5 +1,4 @@
 use anyhow::Context;
-use blake2::digest::{Digest, FixedOutput};
 
 #[cfg(feature = "future_proof_system")]
 use anyhow::anyhow;
@@ -10,19 +9,19 @@ use crate::AggregationError;
 use super::{AggregateSignature, AggregateSignatureType, AggregateVerificationKey};
 use crate::{
     ClosedKeyRegistration, Index, Parameters, Signer, SingleSignature, Stake, StmResult,
-    VerificationKey, proof_system::ConcatenationProof,
+    VerificationKey, membership_commitment::MembershipDigest, proof_system::ConcatenationProof,
 };
 
 /// `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)]
-pub struct Clerk<D: Clone + Digest> {
+pub struct Clerk<D: MembershipDigest> {
     pub(crate) closed_reg: ClosedKeyRegistration<D>,
     pub(crate) params: Parameters,
 }
 
-impl<D: Digest + Clone + FixedOutput + Send + Sync> Clerk<D> {
+impl<D: MembershipDigest + Clone> Clerk<D> {
     /// Create a new `Clerk` from a closed registration instance.
     pub fn new_clerk_from_closed_key_registration(
         params: &Parameters,

mithril-stm/src/protocol/aggregate_signature/mod.rs

@@ -10,7 +10,6 @@ pub use signature::*;
 
 #[cfg(test)]
 mod tests {
-    use blake2::{Blake2b, digest::consts::U32};
     use proptest::{
         collection::{hash_map, vec},
         prelude::*,
@@ -24,11 +23,12 @@ mod tests {
     use crate::{
         AggregationError, Initializer, KeyRegistration, Parameters, Signer, SingleSignature,
         SingleSignatureWithRegisteredParty, Stake, StmResult,
-        membership_commitment::MerkleBatchPath, signature_scheme::BlsVerificationKey,
+        membership_commitment::{CustomMembershipDigest, MerkleBatchPath},
+        signature_scheme::BlsVerificationKey,
     };
 
     type Sig = AggregateSignature<D>;
-    type D = Blake2b<U32>;
+    type D = CustomMembershipDigest;
 
     fn setup_equal_parties(params: Parameters, nparties: usize) -> Vec<Signer<D>> {
         let stake = vec![1; nparties];

mithril-stm/src/protocol/aggregate_signature/signature.rs

@@ -1,13 +1,13 @@
 use std::{collections::HashMap, fmt::Display, hash::Hash, str::FromStr};
 
 use anyhow::anyhow;
-use blake2::digest::{Digest, FixedOutput};
 use serde::{Deserialize, Serialize};
 
 use super::AggregateVerificationKey;
 use crate::{
     AggregateSignatureError, Parameters, StmError, StmResult,
-    membership_commitment::MerkleBatchPath, proof_system::ConcatenationProof,
+    membership_commitment::{MembershipDigest, MerkleBatchPath},
+    proof_system::ConcatenationProof,
 };
 
 /// The type of STM aggregate signature.
@@ -46,9 +46,7 @@ impl AggregateSignatureType {
     }
 }
 
-impl<D: Clone + Digest + FixedOutput + Send + Sync> From<&AggregateSignature<D>>
-    for AggregateSignatureType
-{
+impl<D: MembershipDigest> From<&AggregateSignature<D>> for AggregateSignatureType {
     fn from(aggr_sig: &AggregateSignature<D>) -> Self {
         match aggr_sig {
             AggregateSignature::Concatenation(_) => AggregateSignatureType::Concatenation,
@@ -84,10 +82,10 @@ impl Display for AggregateSignatureType {
 /// An STM aggregate signature.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(bound(
-    serialize = "MerkleBatchPath<D>: Serialize",
-    deserialize = "MerkleBatchPath<D>: Deserialize<'de>"
+    serialize = "MerkleBatchPath<D::ConcatenationHash>: Serialize",
+    deserialize = "MerkleBatchPath<D::ConcatenationHash>: Deserialize<'de>"
 ))]
-pub enum AggregateSignature<D: Clone + Digest + FixedOutput + Send + Sync> {
+pub enum AggregateSignature<D: MembershipDigest> {
     /// A future proof system.
     #[cfg(feature = "future_proof_system")]
     Future,
@@ -100,7 +98,7 @@ pub enum AggregateSignature<D: Clone + Digest + FixedOutput + Send + Sync> {
     Concatenation(ConcatenationProof<D>),
 }
 
-impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
+impl<D: MembershipDigest + Clone> AggregateSignature<D> {
     /// Verify an aggregate signature
     pub fn verify(
         &self,
@@ -218,17 +216,17 @@ mod tests {
     }
 
     mod aggregate_signature_golden_concatenation {
-        use blake2::{Blake2b, digest::consts::U32};
         use rand_chacha::ChaCha20Rng;
         use rand_core::SeedableRng;
 
         use super::{AggregateSignature, AggregateSignatureType};
         use crate::{
             Clerk, ClosedKeyRegistration, KeyRegistration, Parameters, Signer,
+            membership_commitment::CustomMembershipDigest,
             signature_scheme::{BlsSigningKey, BlsVerificationKeyProofOfPossession},
         };
 
-        type D = Blake2b<U32>;
+        type D = CustomMembershipDigest;
 
         const GOLDEN_JSON: &str = r#"
         {

mithril-stm/src/protocol/key_registration.rs

@@ -5,11 +5,10 @@ use std::{
 };
 
 use anyhow::anyhow;
-use blake2::digest::{Digest, FixedOutput};
 
 use crate::{
     RegisterError, Stake, StmResult,
-    membership_commitment::{MerkleTree, MerkleTreeLeaf},
+    membership_commitment::{MembershipDigest, MerkleTree, MerkleTreeLeaf},
     signature_scheme::{BlsVerificationKey, BlsVerificationKeyProofOfPossession},
 };
 
@@ -51,7 +50,7 @@ impl KeyRegistration {
     /// This function disables `KeyReg::register`, consumes the instance of `self`, and returns a `ClosedKeyRegistration`.
     pub fn close<D>(self) -> ClosedKeyRegistration<D>
     where
-        D: Digest + FixedOutput,
+        D: MembershipDigest,
     {
         let mut total_stake: Stake = 0;
         let mut reg_parties = self
@@ -79,23 +78,22 @@ impl KeyRegistration {
 /// Structure generated out of a closed registration containing the registered parties, total stake, and the merkle tree.
 /// One can only get a global `avk` out of a closed key registration.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct ClosedKeyRegistration<D: Digest> {
+pub struct ClosedKeyRegistration<D: MembershipDigest> {
     /// Ordered list of registered parties.
     pub reg_parties: Vec<RegisteredParty>,
     /// Total stake of the registered parties.
     pub total_stake: Stake,
     /// Unique public key out of the key registration instance.
-    pub merkle_tree: Arc<MerkleTree<D>>,
+    pub merkle_tree: Arc<MerkleTree<D::ConcatenationHash>>,
 }
 
 #[cfg(test)]
 mod tests {
-    use blake2::{Blake2b, digest::consts::U32};
     use proptest::{collection::vec, prelude::*};
     use rand_chacha::ChaCha20Rng;
     use rand_core::SeedableRng;
 
-    use crate::signature_scheme::BlsSigningKey;
+    use crate::{membership_commitment::CustomMembershipDigest, signature_scheme::BlsSigningKey};
 
     use super::*;
 
@@ -148,7 +146,7 @@ mod tests {
                 }
             }
             if !kr.keys.is_empty() {
-                let closed = kr.close::<Blake2b<U32>>();
+                let closed = kr.close::<CustomMembershipDigest>();
                 let retrieved_keys = closed.reg_parties.iter().map(|r| (r.0, r.1)).collect::<HashMap<_,_>>();
                 assert!(retrieved_keys == keys);
             }