refactor(stm): make prop tests work on concatenation proof

Instead of aggregate signature as tests are proof specific.

Author: jpraynaud

mithril-stm/src/aggregate_signature/mod.rs

@@ -12,6 +12,7 @@ pub use signature::*;
 
 #[cfg(test)]
 mod tests {
+    use core::panic;
     use std::collections::{HashMap, HashSet};
 
     use blake2::{Blake2b, digest::consts::U32};
@@ -461,28 +462,36 @@ mod tests {
         #[test]
         fn test_invalid_proof_index_unique(tc in arb_proof_setup(10)) {
             with_proof_mod(tc, |aggr, clerk, _msg| {
-                for sig_reg in aggr.signatures().iter_mut() {
-                    for index in sig_reg.sig.indexes.iter_mut() {
-                       *index %= clerk.params.k - 1
+                if let AggregateSignature::Concatenation(concatenation_proof) = aggr {
+                    for sig_reg in concatenation_proof.signatures.iter_mut() {
+                        for index in sig_reg.sig.indexes.iter_mut() {
+                        *index %= clerk.params.k - 1
+                        }
                     }
+                }else{
+                    panic!("Unexpected aggregate signature type");
                 }
             })
         }
         #[test]
         fn test_invalid_proof_path(tc in arb_proof_setup(10)) {
             with_proof_mod(tc, |aggr, _, _msg| {
-                let p = aggr.batch_proof().clone();
-                let mut index_list = p.indices.clone();
-                let values = p.values;
-                let batch_proof = {
-                    index_list[0] += 1;
-                    MerkleBatchPath {
-                        values,
-                        indices: index_list,
-                        hasher: Default::default()
-                    }
-                };
-                aggr.set_batch_proof(batch_proof);
+                if let AggregateSignature::Concatenation(concatenation_proof) = aggr {
+                   let p = concatenation_proof.batch_proof.clone();
+                    let mut index_list = p.indices.clone();
+                    let values = p.values;
+                    let batch_proof = {
+                        index_list[0] += 1;
+                        MerkleBatchPath {
+                            values,
+                            indices: index_list,
+                            hasher: Default::default()
+                        }
+                    };
+                    concatenation_proof.batch_proof = batch_proof;
+                }else{
+                    panic!("Unexpected aggregate signature type");
+                }
             })
         }
     }

mithril-stm/src/aggregate_signature/signature.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::error::StmAggregateSignatureError;
 use crate::merkle_tree::MerkleBatchPath;
-use crate::{AggregateVerificationKey, Parameters, SingleSignatureWithRegisteredParty};
+use crate::{AggregateVerificationKey, Parameters};
 
 use super::ConcatenationProof;
 
@@ -193,49 +193,6 @@ impl<D: Clone + Digest + FixedOutput + Send + Sync> AggregateSignature<D> {
             AggregateSignature::Future => None,
         }
     }
-
-    /// Extract the list of signatures.
-    // TODO: transfer this function to the concatenation proof ? Some proofs might not fully carry this information
-    pub fn signatures(&self) -> Vec<SingleSignatureWithRegisteredParty> {
-        match self {
-            AggregateSignature::Concatenation(concatenation_proof) => {
-                concatenation_proof.signatures.clone()
-            }
-            #[cfg(feature = "future_proof_system")]
-            AggregateSignature::Future(concatenation_proof) => {
-                concatenation_proof.signatures.clone()
-            }
-        }
-    }
-
-    /// Extract the list of unique merkle tree nodes that covers path for all signatures.
-    // TODO: transfer this function to the concatenation proof
-    pub fn batch_proof(&self) -> MerkleBatchPath<D> {
-        match self {
-            AggregateSignature::Concatenation(concatenation_proof) => {
-                concatenation_proof.batch_proof.clone()
-            }
-            #[cfg(feature = "future_proof_system")]
-            AggregateSignature::Future(concatenation_proof) => {
-                concatenation_proof.batch_proof.clone()
-            }
-        }
-    }
-
-    /// Extract the list of unique merkle tree nodes that covers path for all signatures. (test only)
-    // TODO: transfer this function to the concatenation proof
-    #[cfg(test)]
-    pub(crate) fn set_batch_proof(&mut self, batch_proof: MerkleBatchPath<D>) {
-        match self {
-            AggregateSignature::Concatenation(concatenation_proof) => {
-                concatenation_proof.batch_proof = batch_proof
-            }
-            #[cfg(feature = "future_proof_system")]
-            AggregateSignature::Future(concatenation_proof) => {
-                concatenation_proof.batch_proof = batch_proof
-            }
-        }
-    }
 }
 
 #[cfg(test)]