solving compilation problems

Author: iquerejeta

mithril-client/src/verifier.rs

@@ -93,12 +93,21 @@ impl Verifier for VerifierImpl {
     ) -> Result<(), ProtocolError> {
         debug!("Verify multi signature for {:?}", message);
         let clerk = self.create_clerk(signers_with_stakes, protocol_parameters);
-        let multi_signature: ProtocolMultiSignature =
-            key_decode_hex(multi_signature).map_err(ProtocolError::VerifyMultiSignatureError)?;
-        clerk
+
+        // todo: these two declarations are patches. Probably better ways to do this.
+        let avk = clerk
             .as_ref()
             .unwrap()
-            .verify_msig(&multi_signature, message)
+            .compute_avk();
+        let protocol_parameters = ProtocolParameters {
+            k: protocol_parameters.k,
+            m: protocol_parameters.m,
+            phi_f: protocol_parameters.phi_f as f64,
+        };
+        let multi_signature: ProtocolMultiSignature =
+            key_decode_hex(multi_signature).map_err(ProtocolError::VerifyMultiSignatureError)?;
+        multi_signature
+            .verify(message, &avk, &protocol_parameters)
             .map_err(|e| ProtocolError::VerifyMultiSignatureError(e.to_string()))
     }
 }

mithril-core/src/dense_mapping.rs

@@ -110,10 +110,10 @@ pub(crate) fn ev_lt_phi(phi_f: f64, ev: [u8; 64], stake: Stake, total_stake: Sta
 
 #[cfg(test)]
 mod tests {
-    use proptest::prelude::*;
+    use super::*;
     use num_bigint::{BigInt, Sign};
     use num_rational::Ratio;
-    use super::*;
+    use proptest::prelude::*;
     // Implementation of `ev_lt_phi` without approximation. We only get the precision of f64 here.
     fn simple_ev_lt_phi(phi_f: f64, ev: [u8; 64], stake: Stake, total_stake: Stake) -> bool {
         let ev_max = BigInt::from(2u8).pow(512);

mithril-core/src/stm.rs

@@ -144,6 +144,12 @@ pub type PartyId = u64;
 pub type Index = u64;
 
 /// Used to set protocol parameters.
+// todo: this is the criteria to consider parameters valid:
+// Let A = max assumed adversarial stake
+// Let a = A / max_stake
+// Let p = φ(a)  // f needs tuning, something close to 0.2 is reasonable
+// Then, we're secure if SUM[from i=k to i=m] Binomial(i successes, m experiments, p chance of success) <= 2^-100 or thereabouts.
+// The latter turns to 1 - BinomialCDF(k-1,m,p)
 #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
 #[repr(C)]
 pub struct StmParameters {

mithril-signer/src/single_signer.rs

@@ -4,7 +4,7 @@ use thiserror::Error;
 
 use mithril_common::crypto_helper::{
     key_decode_hex, key_encode_hex, Bytes, ProtocolInitializer, ProtocolKeyRegistration,
-    ProtocolParameters, ProtocolPartyId, ProtocolSingleSignature, ProtocolSigner, ProtocolSignerSecretKey, ProtocolStake,
+    ProtocolParameters, ProtocolPartyId, ProtocolSigner, ProtocolSignerSecretKey, ProtocolStake,
 };
 use mithril_common::entities::{self, SignerWithStake, SingleSignature};
 
@@ -207,6 +207,12 @@ mod tests {
         assert!(!sign_result.as_ref().unwrap().is_empty());
         for sig in sign_result.unwrap() {
             let decoded_sig: ProtocolSingleSignature = key_decode_hex(&sig.signature).unwrap();
+            // todo: patch
+            let protocol_parameters = ProtocolParameters {
+                k: protocol_parameters.k,
+                m: protocol_parameters.m,
+                phi_f: protocol_parameters.phi_f as f64,
+            };
             assert!(decoded_sig.verify(&protocol_parameters, &avk, message).is_ok());
             assert_eq!(
                 decoded_sig.pk,