Some minor remarks

Author: iquerejeta

mithril-core/benches/size_benches.rs

@@ -65,9 +65,6 @@ fn main() {
     println!("+-------------------+");
     println!("|   Size of proofs  |");
     println!("+-------------------+");
-    println!("|-------------------|");
-    println!("|   Trivial proofs  |");
-    println!("+-------------------+");
     println!("| Results obtained by using the parameters suggested in paper.");
     println!("+-------------------+");
 

mithril-core/src/error.rs

@@ -155,10 +155,10 @@ impl From<MultiSignatureError> for StmSignatureError {
 impl<D: Digest + FixedOutput> From<MultiSignatureError> for StmAggregateSignatureError<D> {
     fn from(e: MultiSignatureError) -> Self {
         match e {
-            MultiSignatureError::SerializationError => Self::SerializationError,
-            MultiSignatureError::KeyInvalid(e) => Self::IvkInvalid(e.vk),
-            MultiSignatureError::SignatureInvalid(_e) => unreachable!(),
             MultiSignatureError::AggregateSignatureInvalid => Self::AggregateSignatureInvalid,
+            MultiSignatureError::SerializationError => unreachable!(),
+            MultiSignatureError::KeyInvalid(_) => unreachable!(),
+            MultiSignatureError::SignatureInvalid(_e) => unreachable!(),
         }
     }
 }

mithril-core/src/merkle_tree.rs

@@ -173,7 +173,7 @@ impl<D: Digest + FixedOutput> BatchPath<D> {
     }
 
     /// Try to convert a byte string into a `BatchPath`.
-    // todo: We should not panic if the size of the slice is invalid (I believe `bytes[offset + i * 8..offset + (i + 1) * 8]` will panic if bytes is not large enough. 
+    // todo: We should not panic if the size of the slice is invalid (I believe `bytes[offset + i * 8..offset + (i + 1) * 8]` will panic if bytes is not large enough.
     pub fn from_bytes(bytes: &[u8]) -> Result<Self, MerkleTreeError<D>> {
         let mut u64_bytes = [0u8; 8];
         u64_bytes.copy_from_slice(&bytes[..8]);

mithril-core/src/stm.rs

@@ -359,9 +359,8 @@ 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`.
-    /// 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`.
+    /// If it wins at least one lottery, it stores the signer's merkle tree index. The proof of membership
+    /// will be handled by the aggregator.
     pub fn sign(&self, msg: &[u8]) -> Option<StmSig> {
         let msgp = self
             .closed_reg
@@ -457,6 +456,8 @@ impl<D: Digest + Clone + FixedOutput> StmClerk<D> {
     /// 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 defaut 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(
         &self,
         msg: &[u8],
@@ -1102,7 +1103,6 @@ mod tests {
 
     #[derive(Debug)]
     struct ProofTest {
-        n: usize,
         msig: Result<Sig, AggregationError>,
         clerk: StmClerk<D>,
         msg: [u8; 16],
@@ -1124,12 +1124,7 @@ mod tests {
                 let sigs = find_signatures(&msg, &ps, &all_ps);
 
                 let msig = clerk.aggregate(&sigs, &msg);
-                ProofTest {
-                    n,
-                    msig,
-                    clerk,
-                    msg,
-                }
+                ProofTest { msig, clerk, msg }
             })
         })
     }