size_benches runs with paper parameters

Author: curiecrypt

mithril-common/src/crypto_helper/cardano/key_certification.rs

@@ -13,6 +13,7 @@ use mithril::key_reg::{ClosedKeyReg, KeyReg};
 use mithril::stm::{Stake, StmInitializer, StmParameters, StmSigner, StmVerificationKeyPoP};
 use mithril::RegisterError;
 
+use blake2::digest::FixedOutput;
 use blake2::{digest::consts::U32, Blake2b, Digest};
 use kes_summed_ed25519::kes::{Sum6Kes, Sum6KesSig};
 use kes_summed_ed25519::traits::{KesSig, KesSk};
@@ -255,7 +256,7 @@ impl KeyRegWrapper {
 
     /// Finalize the key registration.
     /// This function disables `KeyReg::register`, consumes the instance of `self`, and returns a `ClosedKeyReg`.
-    pub fn close<D: Digest>(self) -> ClosedKeyReg<D> {
+    pub fn close<D: Digest + FixedOutput>(self) -> ClosedKeyReg<D> {
         self.stm_key_reg.close()
     }
 }

mithril-core/benches/size_benches.rs

@@ -7,10 +7,10 @@ use mithril::key_reg::KeyReg;
 use mithril::stm::{StmClerk, StmInitializer, StmParameters, StmSig, StmSigner};
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
-use rayon::prelude::{IntoParallelIterator, IntoParallelRefIterator};
 use rayon::iter::ParallelIterator;
+use rayon::prelude::{IntoParallelIterator, IntoParallelRefIterator};
 
-fn size<H>(k: u64, nparties: usize, hash_name: &str)
+fn size<H>(k: u64, m: u64, nparties: usize, hash_name: &str)
 where
     H: Digest + Clone + Sync + Send + Default + FixedOutput,
 {
@@ -30,8 +30,8 @@ where
     let params = StmParameters {
         k,
         // m equal to one, to get an upper bound were a signer can only submit a single signature
-        m: 1,
-        phi_f: 1.0,
+        m,
+        phi_f: 0.2,
     };
 
     let mut key_reg = KeyReg::init();
@@ -43,7 +43,6 @@ where
 
     let closed_reg = key_reg.close::<H>();
 
-
     let ps = ps
         .into_par_iter()
         .map(|p| p.new_signer(closed_reg.clone()).unwrap())
@@ -62,7 +61,7 @@ where
     let sig = sigs[0].clone();
 
     println!(
-        "k = {} | nr parties = {}; single signature {} bytes | aggregate signature {} bytes",
+        "k = {} | nr parties = {}; total size of single signatures {} bytes | aggregate signature {} bytes",
         k,
         nparties,
         sig.to_bytes().len() * k as usize,
@@ -83,9 +82,9 @@ fn main() {
     println!("| This gives and upper bound of the size\n| as it assumes that at most one signature\n| is provided by each participant.");
     println!("+-------------------+");
 
-    let params: [(u64, usize); 2] = [(25, 300), (250, 2000)];
-    for (k, nparties) in params {
-        size::<Blake2b<U64>>(k, nparties, "Blake2b 512");
-        size::<Blake2b<U32>>(k, nparties, "Blake2b 256");
+    let params: [(u64, u64, usize); 2] = [(445, 2728, 3000), (554, 3597, 3000)];
+    for (k, m, nparties) in params {
+        size::<Blake2b<U64>>(k, m, nparties, "Blake2b 512");
+        size::<Blake2b<U32>>(k, m, nparties, "Blake2b 256");
     }
 }

mithril-core/src/stm.rs

@@ -221,7 +221,7 @@ pub struct StmAggrVerificationKey<D: Clone + Digest + FixedOutput> {
 
 /// `StmMultiSig` 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 added as `Option` for batch compatibility.
+/// BatchPath is also a part of the aggregate signature which covers path for all signatures.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(bound(
     serialize = "BatchPath<D>: Serialize",
@@ -363,13 +363,10 @@ impl<D: Clone + Digest + FixedOutput> StmSigner<D> {
     /// Once the signature is produced, this function checks whether any index in `[0,..,self.params.m]`
     /// wins the lottery by evaluating the dense mapping.
     /// It records all the winning indexes in `Self.indexes`.
-    /// The difference between `sign` and `sign` is that if it wins at least one lottery,
+    /// If it wins at least one lottery,
     /// it does not produce a list of indexes of merkle path for its corresponding `(VerificationKey, Stake)`.
     /// Instead it stores the signer's merkle tree index and the merkle path production will be handled in `StmClerk`.
-    pub fn sign(&self, msg: &[u8]) -> Option<StmSig<D>>
-    where
-        D: Default,
-    {
+    pub fn sign(&self, msg: &[u8]) -> Option<StmSig<D>> {
         let msgp = self
             .closed_reg
             .merkle_tree
@@ -611,7 +608,7 @@ impl<D: Clone + Digest + FixedOutput> StmSig<D> {
     /// Extract a batch compatible `StmSig` from a byte slice.
     pub fn from_bytes(bytes: &[u8]) -> Result<StmSig<D>, StmSignatureError<D>>
     where
-        D: Default + FixedOutput,
+        D: Default,
     {
         let mut u64_bytes = [0u8; 8];
 
@@ -772,7 +769,7 @@ impl<D: Clone + Digest + FixedOutput> StmAggrSig<D> {
         out
     }
 
-    ///Extract a `StmMultiSig` from a byte slice.
+    ///Extract a `StmAggrSig` from a byte slice.
     pub fn from_bytes(bytes: &[u8]) -> Result<StmAggrSig<D>, StmSignatureError<D>>
     where
         D: Default,