Convert ProtocolAvk to a ProtocolKey & update usages

Author: Alenar

mithril-aggregator/src/multi_signer.rs

@@ -5,13 +5,13 @@ use thiserror::Error;
 
 use mithril_common::{
     crypto_helper::{
-        key_encode_hex, ProtocolAggregateVerificationKey, ProtocolAggregationError,
-        ProtocolMultiSignature, ProtocolParameters, ProtocolRegistrationError,
-        ProtocolStakeDistribution,
+        ProtocolAggregateVerificationKey, ProtocolAggregationError, ProtocolMultiSignature,
+        ProtocolParameters, ProtocolRegistrationError, ProtocolStakeDistribution,
     },
     entities::{self, Epoch, SignerWithStake, StakeDistribution},
     protocol::{MultiSigner as ProtocolMultiSigner, SignerBuilder},
     store::{StakeStorer, StoreError},
+    StdError,
 };
 
 use crate::{entities::OpenMessage, store::VerificationKeyStorer, ProtocolParametersStorer};
@@ -39,8 +39,8 @@ pub enum ProtocolError {
     ExistingSingleSignature(entities::PartyId),
 
     /// Codec error.
-    #[error("codec error: '{0}'")]
-    Codec(String),
+    #[error("codec error: '{0:?}'")]
+    Codec(StdError),
 
     /// Mithril STM library returned an error.
     #[error("core error: '{0}'")]
@@ -131,7 +131,7 @@ pub trait MultiSigner: Sync + Send {
         let avk = self
             .compute_aggregate_verification_key(&signers_with_stake, &protocol_parameters)
             .await?;
-        Ok(key_encode_hex(avk).map_err(ProtocolError::Codec)?)
+        Ok(avk.to_json_hex().map_err(ProtocolError::Codec)?)
     }
 
     /// Compute next stake distribution aggregate verification key
@@ -146,7 +146,7 @@ pub trait MultiSigner: Sync + Send {
         let next_avk = self
             .compute_aggregate_verification_key(&next_signers_with_stake, &protocol_parameters)
             .await?;
-        Ok(key_encode_hex(next_avk).map_err(ProtocolError::Codec)?)
+        Ok(next_avk.to_json_hex().map_err(ProtocolError::Codec)?)
     }
 
     /// Get signers

mithril-aggregator/src/tools/genesis.rs

@@ -5,8 +5,8 @@ use tokio::sync::RwLock;
 use mithril_common::{
     certificate_chain::{CertificateGenesisProducer, CertificateVerifier},
     crypto_helper::{
-        key_decode_hex, ProtocolAggregateVerificationKey, ProtocolGenesisSignature,
-        ProtocolGenesisSigner, ProtocolGenesisVerifier,
+        ProtocolAggregateVerificationKey, ProtocolGenesisSignature, ProtocolGenesisSigner,
+        ProtocolGenesisVerifier,
     },
     entities::{Beacon, ProtocolParameters},
     BeaconProvider, StdResult,
@@ -82,8 +82,8 @@ impl GenesisTools {
         let genesis_avk = multi_signer
             .compute_next_stake_distribution_aggregate_verification_key()
             .await?;
-        let genesis_avk: ProtocolAggregateVerificationKey = key_decode_hex(&genesis_avk)
-            .map_err(|e| anyhow!(e).context("Aggregate verification key decode error"))?;
+        let genesis_avk = ProtocolAggregateVerificationKey::from_json_hex(&genesis_avk)
+            .with_context(|| "Aggregate verification key decode error")?;
 
         Ok(Self::new(
             protocol_parameters,
@@ -211,7 +211,7 @@ mod tests {
         let fixture = MithrilFixtureBuilder::default().with_signers(5).build();
         let first_signer = fixture.signers_fixture()[0].clone().protocol_signer;
         let clerk = ProtocolClerk::from_signer(&first_signer);
-        clerk.compute_avk()
+        clerk.compute_avk().into()
     }
 
     fn build_tools(

mithril-client/src/services/mithril_stake_distribution.rs

@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Context};
+use anyhow::Context;
 use async_trait::async_trait;
 use std::{
     path::{Path, PathBuf},
@@ -9,8 +9,7 @@ use thiserror::Error;
 use mithril_common::{
     certificate_chain::CertificateVerifier,
     crypto_helper::{
-        key_encode_hex, ProtocolAggregateVerificationKey, ProtocolGenesisVerificationKey,
-        ProtocolGenesisVerifier,
+        ProtocolAggregateVerificationKey, ProtocolGenesisVerificationKey, ProtocolGenesisVerifier,
     },
     entities::{MithrilStakeDistribution, ProtocolMessagePartKey},
     messages::MithrilStakeDistributionListItemMessage,
@@ -156,12 +155,11 @@ impl MithrilStakeDistributionService for AppMithrilStakeDistributionService {
             )
             .await?;
 
-        let avk = key_encode_hex(
-            self.compute_avk_from_mithril_stake_distribution(&stake_distribution_entity.artifact)
-                .await?,
-        )
-        .map_err(|e| anyhow!(e))
-        .with_context(|| "Encoding avk error")?;
+        let avk = self
+            .compute_avk_from_mithril_stake_distribution(&stake_distribution_entity.artifact)
+            .await?
+            .to_json_hex()
+            .with_context(|| "Encoding avk error")?;
 
         let mut protocol_message = certificate.protocol_message.clone();
         protocol_message

mithril-common/src/certificate_chain/certificate_genesis.rs

@@ -7,21 +7,22 @@ use thiserror::Error;
 
 use crate::{
     crypto_helper::{
-        key_encode_hex, ProtocolAggregateVerificationKey, ProtocolGenesisSignature,
-        ProtocolGenesisSigner, PROTOCOL_VERSION,
+        ProtocolAggregateVerificationKey, ProtocolGenesisSignature, ProtocolGenesisSigner,
+        PROTOCOL_VERSION,
     },
     entities::{
         Beacon, Certificate, CertificateMetadata, CertificateSignature, ProtocolMessage,
         ProtocolMessagePartKey, ProtocolParameters,
     },
+    StdError,
 };
 
 /// [CertificateGenesisProducer] related errors.
 #[derive(Error, Debug)]
 pub enum CertificateGenesisProducerError {
     /// Error raised when a Codec error occurs
-    #[error("codec error: '{0}'")]
-    Codec(String),
+    #[error("codec error: '{0:?}'")]
+    Codec(StdError),
 
     /// Error raised when there is no genesis signer available
     #[error("missing genesis signer error")]
@@ -44,8 +45,9 @@ impl CertificateGenesisProducer {
     pub fn create_genesis_protocol_message(
         genesis_avk: &ProtocolAggregateVerificationKey,
     ) -> Result<ProtocolMessage, CertificateGenesisProducerError> {
-        let genesis_avk =
-            key_encode_hex(genesis_avk).map_err(CertificateGenesisProducerError::Codec)?;
+        let genesis_avk = genesis_avk
+            .to_json_hex()
+            .map_err(CertificateGenesisProducerError::Codec)?;
         let mut protocol_message = ProtocolMessage::new();
         protocol_message.set_message_part(
             ProtocolMessagePartKey::NextAggregateVerificationKey,
@@ -86,8 +88,9 @@ impl CertificateGenesisProducer {
         );
         let previous_hash = "".to_string();
         let genesis_protocol_message = Self::create_genesis_protocol_message(&genesis_avk)?;
-        let genesis_avk =
-            key_encode_hex(&genesis_avk).map_err(CertificateGenesisProducerError::Codec)?;
+        let genesis_avk = genesis_avk
+            .to_json_hex()
+            .map_err(CertificateGenesisProducerError::Codec)?;
         Ok(Certificate::new(
             previous_hash,
             beacon,

mithril-common/src/certificate_chain/certificate_verifier.rs

@@ -8,11 +8,13 @@ use thiserror::Error;
 
 use super::{CertificateRetriever, CertificateRetrieverError};
 use crate::crypto_helper::{
-    key_decode_hex, ProtocolGenesisError, ProtocolGenesisVerifier, ProtocolMultiSignature,
+    ProtocolAggregateVerificationKey, ProtocolGenesisError, ProtocolGenesisVerifier,
+    ProtocolMultiSignature,
 };
 use crate::entities::{
     Certificate, CertificateSignature, ProtocolMessage, ProtocolMessagePartKey, ProtocolParameters,
 };
+use crate::StdError;
 
 #[cfg(test)]
 use mockall::automock;
@@ -25,8 +27,8 @@ pub enum CertificateVerifierError {
     VerifyMultiSignature(String),
 
     /// Error raised when encoding or decoding of data to hex fails.
-    #[error("codec hex error: '{0}'")]
-    Codec(String),
+    #[error("codec hex error: '{0:?}'")]
+    Codec(StdError),
 
     /// Error raised when encoding or decoding of data to genesis type.
     #[error("codec genesis error: '{0}'")]
@@ -151,7 +153,8 @@ impl MithrilCertificateVerifier {
             message.encode_hex::<String>()
         );
         let aggregate_verification_key =
-            key_decode_hex(aggregate_verification_key).map_err(CertificateVerifierError::Codec)?;
+            ProtocolAggregateVerificationKey::from_json_hex(aggregate_verification_key)
+                .map_err(CertificateVerifierError::Codec)?;
 
         multi_signature
             .verify(
@@ -287,8 +290,7 @@ mod tests {
     use super::CertificateRetriever;
     use super::*;
 
-    use crate::crypto_helper::tests_setup::*;
-    use crate::crypto_helper::{key_encode_hex, ProtocolClerk};
+    use crate::crypto_helper::{tests_setup::*, ProtocolClerk};
     use crate::test_utils::MithrilFixtureBuilder;
 
     mock! {
@@ -321,7 +323,7 @@ mod tests {
 
         let first_signer = &signers[0].protocol_signer;
         let clerk = ProtocolClerk::from_signer(first_signer);
-        let aggregate_verification_key = clerk.compute_avk();
+        let aggregate_verification_key = clerk.compute_avk().into();
         let multi_signature = clerk
             .aggregate(&single_signatures, &message_hash)
             .unwrap()
@@ -334,7 +336,7 @@ mod tests {
                 .verify_multi_signature(
                     &message_tampered,
                     &multi_signature,
-                    &key_encode_hex(&aggregate_verification_key).unwrap(),
+                    &aggregate_verification_key.to_json_hex().unwrap(),
                     &fixture.protocol_parameters(),
                 )
                 .is_err(),
@@ -344,7 +346,7 @@ mod tests {
             .verify_multi_signature(
                 &message_hash,
                 &multi_signature,
-                &key_encode_hex(&aggregate_verification_key).unwrap(),
+                &aggregate_verification_key.to_json_hex().unwrap(),
                 &fixture.protocol_parameters(),
             )
             .expect("multi signature verification should have succeeded");

mithril-common/src/crypto_helper/tests_setup.rs

@@ -1,5 +1,5 @@
 //! Test data builders for Mithril STM types, for testing purpose.
-use super::{genesis::*, key_encode_hex, types::*, OpCert, SerDeShelleyFileFormat};
+use super::{genesis::*, types::*, OpCert, SerDeShelleyFileFormat};
 use crate::{
     certificate_chain::CertificateGenesisProducer,
     entities::{
@@ -11,9 +11,7 @@ use crate::{
 
 use rand_chacha::ChaCha20Rng;
 use rand_core::SeedableRng;
-use std::{cmp::min, fs, sync::Arc};
-
-use std::{collections::HashMap, path::PathBuf};
+use std::{cmp::min, collections::HashMap, fs, path::PathBuf, sync::Arc};
 
 /// Create or retrieve a temporary directory for storing cryptographic material for a signer, use this for tests only.
 pub fn setup_temp_directory_for_signer(
@@ -204,10 +202,10 @@ pub fn setup_certificate_chain(
     };
     let avk_for_signers = |signers: &[SignerFixture]| -> ProtocolAggregateVerificationKey {
         let clerk = clerk_for_signers(signers);
-        clerk.compute_avk()
+        clerk.compute_avk().into()
     };
     let avk_encode =
-        |avk: &ProtocolAggregateVerificationKey| -> String { key_encode_hex(avk).unwrap() };
+        |avk: &ProtocolAggregateVerificationKey| -> String { avk.to_json_hex().unwrap() };
     epochs.pop();
     let certificates = epochs
         .into_iter()

mithril-common/src/crypto_helper/types/alias.rs

@@ -5,7 +5,7 @@ use crate::crypto_helper::cardano::{
 
 use mithril_stm::{
     key_reg::ClosedKeyReg,
-    stm::{Index, Stake, StmAggrVerificationKey, StmClerk, StmParameters, StmSigner},
+    stm::{Index, Stake, StmClerk, StmParameters, StmSigner},
     AggregationError,
 };
 
@@ -47,9 +47,6 @@ pub type ProtocolKeyRegistration = KeyRegWrapper;
 /// Alias of a wrapper of [MithrilStm:ClosedKeyReg](struct@mithril_stm::key_reg::KeyReg).
 pub type ProtocolClosedKeyRegistration = ClosedKeyReg<D>;
 
-/// Alias of [MithrilStm:StmAggrVerificationKey](struct@mithril_stm::stm::StmAggrVerificationKey).
-pub type ProtocolAggregateVerificationKey = StmAggrVerificationKey<D>;
-
 // Error alias
 /// Alias of a wrapper of [MithrilCommon:ProtocolRegistrationErrorWrapper](enum@ProtocolRegistrationErrorWrapper).
 pub type ProtocolRegistrationError = ProtocolRegistrationErrorWrapper;

mithril-common/src/crypto_helper/types/wrappers.rs

@@ -1,7 +1,7 @@
 use anyhow::Context;
 use hex::{FromHex, ToHex};
 use kes_summed_ed25519::kes::Sum6KesSig;
-use mithril_stm::stm::{StmAggrSig, StmSig, StmVerificationKeyPoP};
+use mithril_stm::stm::{StmAggrSig, StmAggrVerificationKey, StmSig, StmVerificationKeyPoP};
 
 use crate::crypto_helper::{OpCert, ProtocolKey, ProtocolKeyCodec, D};
 use crate::StdResult;
@@ -32,6 +32,9 @@ pub type ProtocolGenesisVerificationKey = ProtocolKey<ed25519_dalek::PublicKey>;
 /// Alias of [Ed25519:SecretKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.SecretKey.html).
 pub type ProtocolGenesisSecretKey = ProtocolKey<ed25519_dalek::SecretKey>;
 
+/// Alias of [MithrilStm:StmAggrVerificationKey](struct@mithril_stm::stm::StmAggrVerificationKey).
+pub type ProtocolAggregateVerificationKey = ProtocolKey<StmAggrVerificationKey<D>>;
+
 impl ProtocolGenesisSignature {
     /// Create an instance from a bytes hex representation
     pub fn from_bytes_hex(hex_string: &str) -> StdResult<Self> {
@@ -76,6 +79,7 @@ impl ProtocolKeyCodec<ed25519_dalek::Signature> for ed25519_dalek::Signature {
 }
 
 impl_codec_and_type_conversions_for_protocol_key!(
-    json_hex_codec => StmVerificationKeyPoP, Sum6KesSig, StmSig, StmAggrSig<D>, OpCert, ed25519_dalek::PublicKey, ed25519_dalek::SecretKey
+    json_hex_codec => StmVerificationKeyPoP, Sum6KesSig, StmSig, StmAggrSig<D>, OpCert,
+        ed25519_dalek::PublicKey, ed25519_dalek::SecretKey, StmAggrVerificationKey<D>
 );
 impl_codec_and_type_conversions_for_protocol_key!(no_default_codec => ed25519_dalek::Signature);

mithril-common/src/protocol/multi_signer.rs

@@ -44,7 +44,7 @@ impl MultiSigner {
 
     /// Compute aggregate verification key from stake distribution
     pub fn compute_aggregate_verification_key(&self) -> ProtocolAggregateVerificationKey {
-        self.protocol_clerk.compute_avk()
+        self.protocol_clerk.compute_avk().into()
     }
 
     /// Verify a single signature

mithril-common/src/protocol/signer_builder.rs

@@ -4,11 +4,10 @@ use rand_core::{CryptoRng, RngCore, SeedableRng};
 use std::path::Path;
 use thiserror::Error;
 
-use crate::crypto_helper::ProtocolAggregateVerificationKey;
 use crate::{
     crypto_helper::{
-        ProtocolClerk, ProtocolClosedKeyRegistration, ProtocolInitializer, ProtocolKeyRegistration,
-        ProtocolStakeDistribution,
+        ProtocolAggregateVerificationKey, ProtocolClerk, ProtocolClosedKeyRegistration,
+        ProtocolInitializer, ProtocolKeyRegistration, ProtocolStakeDistribution,
     },
     entities::{PartyId, ProtocolParameters, SignerWithStake},
     protocol::MultiSigner,
@@ -84,7 +83,7 @@ impl SignerBuilder {
         let clerk =
             ProtocolClerk::from_registration(&stm_parameters, &self.closed_key_registration);
 
-        clerk.compute_avk()
+        clerk.compute_avk().into()
     }
 
     fn build_single_signer_with_rng<R: RngCore + CryptoRng>(