Add type conversions in crypto helper

Author: jpraynaud

mithril-aggregator/src/main.rs

@@ -5,7 +5,7 @@ use clap::Parser;
 use config::{Map, Source, Value, ValueKind};
 use mithril_aggregator::{
     AggregatorRuntime, Config, DependencyManager, MemoryBeaconStore, MultiSigner, MultiSignerImpl,
-    ProtocolPartyId, ProtocolStake, Server,
+    ProtocolStakeDistribution, Server,
 };
 use mithril_common::fake_data;
 use slog::{Drain, Level, Logger};
@@ -181,14 +181,9 @@ fn init_multi_signer() -> impl MultiSigner {
 
     // Update stake distribution
     let total_signers = 5;
-    let stakes = fake_data::signers_with_stakes(total_signers)
-        .iter()
-        .map(|signer| {
-            (
-                signer.party_id as ProtocolPartyId,
-                signer.stake as ProtocolStake,
-            )
-        })
+    let stakes: ProtocolStakeDistribution = fake_data::signers_with_stakes(total_signers)
+        .into_iter()
+        .map(|signer| signer.into())
         .collect::<_>();
     multi_signer
         .update_stake_distribution(&stakes)

mithril-common/src/crypto_helper/conversions.rs

@@ -0,0 +1,83 @@
+use super::super::entities;
+use super::types;
+
+impl From<types::ProtocolParameters> for entities::ProtocolParameters {
+    fn from(other: types::ProtocolParameters) -> Self {
+        entities::ProtocolParameters::new(other.k, other.m, other.phi_f as f32)
+    }
+}
+
+impl From<entities::ProtocolParameters> for types::ProtocolParameters {
+    fn from(other: entities::ProtocolParameters) -> Self {
+        types::ProtocolParameters {
+            k: other.k,
+            m: other.m,
+            phi_f: other.phi_f as f64,
+        }
+    }
+}
+
+impl From<entities::SignerWithStake> for entities::Signer {
+    fn from(other: entities::SignerWithStake) -> Self {
+        entities::Signer::new(other.party_id as types::ProtocolPartyId, "".to_string())
+    }
+}
+
+impl From<entities::SignerWithStake> for (types::ProtocolPartyId, types::ProtocolStake) {
+    fn from(other: entities::SignerWithStake) -> Self {
+        (
+            other.party_id as types::ProtocolPartyId,
+            other.stake as types::ProtocolStake,
+        )
+    }
+}
+
+impl From<(types::ProtocolPartyId, types::ProtocolStake)> for entities::SignerWithStake {
+    fn from(other: (types::ProtocolPartyId, types::ProtocolStake)) -> Self {
+        entities::SignerWithStake::new(other.0, "".to_string(), other.1)
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    #[test]
+    fn test_protocol_parameters_from_into() {
+        let protocol_parameters_expected = types::ProtocolParameters {
+            k: 100,
+            m: 1000,
+            phi_f: 1.0,
+        };
+        let protocol_initializer_entities_expected = entities::ProtocolParameters::new(
+            protocol_parameters_expected.k,
+            protocol_parameters_expected.m,
+            protocol_parameters_expected.phi_f as f32,
+        );
+
+        let protocol_initializer_entities_into: entities::ProtocolParameters =
+            protocol_parameters_expected.into();
+        assert_eq!(
+            protocol_initializer_entities_expected,
+            protocol_initializer_entities_into
+        );
+
+        let protocol_initializer_from: types::ProtocolParameters =
+            protocol_initializer_entities_expected.into();
+        assert_eq!(protocol_parameters_expected, protocol_initializer_from);
+    }
+
+    #[test]
+    fn test_stake_distribution_from_into() {
+        let stake_expected = (1 as types::ProtocolPartyId, 100 as types::ProtocolStake);
+        let signer_with_stake_expected = entities::SignerWithStake::new(1, "".to_string(), 100);
+        ();
+
+        let signer_with_stake_expected_into: (types::ProtocolPartyId, types::ProtocolStake) =
+            signer_with_stake_expected.clone().into();
+        assert_eq!(stake_expected, signer_with_stake_expected_into);
+
+        let stake_expected_from = stake_expected.into();
+        assert_eq!(signer_with_stake_expected, stake_expected_from);
+    }
+}

mithril-common/src/crypto_helper/mod.rs

@@ -1,4 +1,5 @@
 mod codec;
+mod conversions;
 pub mod tests_setup;
 mod types;
 

mithril-common/src/crypto_helper/types.rs

@@ -1,11 +1,9 @@
 use mithril::key_reg::KeyReg;
 use mithril::stm::{
-    Index, PartyId, Stake, StmAggrSig, StmClerk, StmInitializer, StmParameters, StmSig, StmSigner,
-    StmVerificationKeyPoP,
+    Index, PartyId, Stake, StmAggrSig, StmAggrVerificationKey, StmClerk, StmInitializer,
+    StmParameters, StmSig, StmSigner, StmVerificationKeyPoP,
 };
 
-use super::super::entities;
-
 pub type Bytes = Vec<u8>;
 
 // Protocol types alias
@@ -22,49 +20,4 @@ pub type ProtocolKeyRegistration = KeyReg;
 pub type ProtocolSingleSignature = StmSig<D>;
 pub type ProtocolMultiSignature = StmAggrSig<D>;
 pub type ProtocolSignerVerificationKey = StmVerificationKeyPoP;
-
-impl From<ProtocolParameters> for entities::ProtocolParameters {
-    fn from(other: ProtocolParameters) -> Self {
-        entities::ProtocolParameters::new(other.k, other.m, other.phi_f as f32)
-    }
-}
-
-impl From<entities::ProtocolParameters> for ProtocolParameters {
-    fn from(other: entities::ProtocolParameters) -> Self {
-        ProtocolParameters {
-            k: other.k,
-            m: other.m,
-            phi_f: other.phi_f as f64,
-        }
-    }
-}
-
-#[cfg(test)]
-pub mod tests {
-    use super::*;
-
-    #[test]
-    fn test_protocol_parameters_from_into() {
-        let protocol_parameters_expected = ProtocolParameters {
-            k: 100,
-            m: 1000,
-            phi_f: 1.0,
-        };
-        let protocol_initializer_entities_expected = entities::ProtocolParameters::new(
-            protocol_parameters_expected.k,
-            protocol_parameters_expected.m,
-            protocol_parameters_expected.phi_f as f32,
-        );
-
-        let protocol_initializer_entities_into: entities::ProtocolParameters =
-            protocol_parameters_expected.into();
-        assert_eq!(
-            protocol_initializer_entities_expected,
-            protocol_initializer_entities_into
-        );
-
-        let protocol_initializer_from: ProtocolParameters =
-            protocol_initializer_entities_expected.into();
-        assert_eq!(protocol_parameters_expected, protocol_initializer_from);
-    }
-}
+pub type ProtocolAggregateVerificationKey = StmAggrVerificationKey<D>;