Convert EraMarkersVerifier VerifKey & SecretKey to ProtocolKey

Author: Alenar

mithril-aggregator/src/commands/era_command.rs

@@ -1,8 +1,8 @@
-use anyhow::anyhow;
+use anyhow::Context;
 use clap::{Parser, Subcommand};
 use config::{builder::DefaultState, ConfigBuilder};
 use mithril_common::{
-    crypto_helper::{key_decode_hex, EraMarkersSigner},
+    crypto_helper::{EraMarkersSigner, EraMarkersVerifierSecretKey},
     entities::{Epoch, HexEncodedEraMarkersSecretKey},
     StdResult,
 };
@@ -89,8 +89,9 @@ impl GenerateTxDatumEraSubCommand {
         debug!("GENERATETXDATUM ERA command");
         let era_tools = EraTools::new();
 
-        let era_markers_secret_key = key_decode_hex(&self.era_markers_secret_key)
-            .map_err(|e| anyhow!(e).context("json hex decode of era markers secret key failure"))?;
+        let era_markers_secret_key =
+            EraMarkersVerifierSecretKey::from_json_hex(&self.era_markers_secret_key)
+                .with_context(|| "json hex decode of era markers secret key failure")?;
         let era_markers_signer = EraMarkersSigner::from_secret_key(era_markers_secret_key);
         print!(
             "{}",

mithril-common/src/crypto_helper/era.rs

@@ -4,11 +4,13 @@ use rand_chacha_dalek_compat::ChaCha20Rng;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
+use super::ProtocolKey;
+
 /// Alias of [Ed25519:PublicKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.PublicKey.html).
-pub type EraMarkersVerifierVerificationKey = ed25519_dalek::PublicKey;
+pub type EraMarkersVerifierVerificationKey = ProtocolKey<ed25519_dalek::PublicKey>;
 
 /// Alias of [Ed25519:SecretKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.SecretKey.html).
-pub type EraMarkersVerifierSecretKey = ed25519_dalek::SecretKey;
+pub type EraMarkersVerifierSecretKey = ProtocolKey<ed25519_dalek::SecretKey>;
 
 /// Alias of [Ed25519:Signature](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.Signature.html).
 pub type EraMarkersVerifierSignature = ed25519_dalek::Signature;
@@ -21,7 +23,7 @@ pub enum EraMarkersVerifierError {
     SignatureVerification(#[from] SignatureError),
 }
 
-/// A cryptographic signer that is responsible for signing the EreMarkers
+/// A cryptographic signer that is responsible for signing the EraMarkers
 #[derive(Debug, Serialize, Deserialize)]
 pub struct EraMarkersSigner {
     pub(crate) secret_key: EraMarkersVerifierSecretKey,
@@ -33,8 +35,8 @@ impl EraMarkersSigner {
     where
         R: CryptoRng + RngCore,
     {
-        let secret_key = EraMarkersVerifierSecretKey::generate(&mut rng);
-        Self::from_secret_key(secret_key)
+        let secret_key = ed25519_dalek::SecretKey::generate(&mut rng);
+        Self::from_secret_key(secret_key.into())
     }
 
     /// EraMarkersSigner deterministic
@@ -56,16 +58,15 @@ impl EraMarkersSigner {
 
     /// Create a an expanded secret key
     fn create_expanded_secret_key(&self) -> ExpandedSecretKey {
-        ExpandedSecretKey::from(&self.secret_key)
+        ExpandedSecretKey::from(&*self.secret_key)
     }
 
     /// Create a EraMarkersVerifierVerificationKey
     fn create_verification_key(
         &self,
         expanded_secret_key: &ExpandedSecretKey,
     ) -> EraMarkersVerifierVerificationKey {
-        let verification_key: EraMarkersVerifierVerificationKey = expanded_secret_key.into();
-        verification_key
+        EraMarkersVerifierVerificationKey::new(expanded_secret_key.into())
     }
 
     /// Create a EraMarkersVerifier
@@ -112,25 +113,23 @@ impl EraMarkersVerifier {
 
 #[cfg(test)]
 mod tests {
-    use super::super::codec::{key_decode_hex, key_encode_hex};
     use super::*;
 
-    const GOLDEN_ERA_MARKER_VERIFICATION_KEY: &str =
+    const GOLDEN_ERA_MARKERS_VERIFICATION_KEY: &str =
         "5b32332c32372c3131322c362c35372c38342c3138302c342c3135302c3233322c3233372c3132362c3131392c\
         3231342c33352c35342c38312c3230382c3231372c39392c3137302c3233312c3133392c362c3132322c39342c3\
         9322c3137322c32332c3130322c3135372c3136375d";
-    const GOLDEN_ERA_MARKER_SECRET_KEY: &str =
+    const GOLDEN_ERA_MARKERS_SECRET_KEY: &str =
         "5b34332c3133322c3232312c3138382c3235332c3132372c3235352c38362c3136322c3133312c3233332c3131\
         362c3134322c3233352c3131312c3133332c3134312c3138332c302c33392c3132302c3139372c39322c3133302\
         c3233342c34362c3135372c32352c3133322c31352c3234312c3235345d";
 
     #[test]
     fn golden_master() {
-        let _: EraMarkersVerifierVerificationKey =
-            key_decode_hex(GOLDEN_ERA_MARKER_VERIFICATION_KEY)
-                .expect("Decoding golden verification key should not fail");
+        EraMarkersVerifierVerificationKey::from_json_hex(GOLDEN_ERA_MARKERS_VERIFICATION_KEY)
+            .expect("Decoding golden verification key should not fail");
 
-        let _: EraMarkersVerifierSecretKey = key_decode_hex(GOLDEN_ERA_MARKER_SECRET_KEY)
+        EraMarkersVerifierSecretKey::from_json_hex(GOLDEN_ERA_MARKERS_SECRET_KEY)
             .expect("Decoding golden secret key should not fail");
     }
 
@@ -148,11 +147,11 @@ mod tests {
 
         println!(
             "Deterministic Verification Key={}",
-            key_encode_hex(verifier.verification_key.as_bytes()).unwrap()
+            verifier.verification_key.to_json_hex().unwrap()
         );
         println!(
             "Deterministic Secret Key=={}",
-            key_encode_hex(signer.secret_key.as_bytes()).unwrap()
+            signer.secret_key.to_json_hex().unwrap()
         );
     }
 
@@ -163,25 +162,24 @@ mod tests {
 
         println!(
             "Non Deterministic Verification Key={}",
-            key_encode_hex(verifier.verification_key.as_bytes()).unwrap()
+            verifier.verification_key.to_json_hex().unwrap()
         );
         println!(
             "Non Deterministic Secret Key=={}",
-            key_encode_hex(signer.secret_key.as_bytes()).unwrap()
+            signer.secret_key.to_json_hex().unwrap()
         );
     }
 
     #[test]
     fn test_codec_keypair() {
         let signer = EraMarkersSigner::create_deterministic_signer();
         let verifier = signer.create_verifier();
-        let secret_key_encoded = key_encode_hex(signer.secret_key.as_bytes()).unwrap();
-        let verification_key_encoded =
-            key_encode_hex(verifier.verification_key.as_bytes()).unwrap();
+        let secret_key_encoded = signer.secret_key.to_json_hex().unwrap();
+        let verification_key_encoded = verifier.verification_key.to_json_hex().unwrap();
         let secret_key_decoded: EraMarkersVerifierSecretKey =
-            key_decode_hex(&secret_key_encoded).unwrap();
+            secret_key_encoded.try_into().unwrap();
         let verification_key_decoded: EraMarkersVerifierVerificationKey =
-            key_decode_hex(&verification_key_encoded).unwrap();
+            verification_key_encoded.try_into().unwrap();
         let signer_decoded = EraMarkersSigner::from_secret_key(secret_key_decoded);
         let verifier_decoded = EraMarkersVerifier::from_verification_key(verification_key_decoded);
 

mithril-common/src/era/adapters/builder.rs

@@ -4,15 +4,15 @@ use thiserror::Error;
 
 use crate::{
     chain_observer::{ChainAddress, ChainObserver},
-    crypto_helper::key_decode_hex,
-    entities::HexEncodedEraMarkersSignature,
+    crypto_helper::EraMarkersVerifierVerificationKey,
     era::{
         adapters::{
             EraReaderBootstrapAdapter, EraReaderCardanoChainAdapter, EraReaderDummyAdapter,
             EraReaderFileAdapter,
         },
         EraMarker, EraReaderAdapter,
     },
+    StdError,
 };
 
 /// Type of era reader adapaters available
@@ -43,7 +43,7 @@ pub enum AdapterBuilderError {
 
     /// Parameters decode error.
     #[error("era reader adapter parameters decode error: {0:?}")]
-    Decode(String),
+    Decode(StdError),
 }
 
 /// Era adapter builder
@@ -71,7 +71,7 @@ impl AdapterBuilder {
                 #[derive(Deserialize)]
                 struct CardanoChainAdapterConfig {
                     address: ChainAddress,
-                    verification_key: HexEncodedEraMarkersSignature,
+                    verification_key: EraMarkersVerifierVerificationKey,
                 }
 
                 let adapter_config: CardanoChainAdapterConfig = serde_json::from_str(
@@ -84,8 +84,7 @@ impl AdapterBuilder {
                 Ok(Arc::new(EraReaderCardanoChainAdapter::new(
                     adapter_config.address,
                     chain_observer,
-                    key_decode_hex(&adapter_config.verification_key)
-                        .map_err(AdapterBuilderError::Decode)?,
+                    adapter_config.verification_key,
                 )))
             }
             AdapterType::File => {
@@ -125,3 +124,25 @@ impl AdapterBuilder {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::chain_observer::MockChainObserver;
+
+    use super::*;
+
+    const GOLDEN_ADAPTER_PARAMS: &str = r#"{
+        "address":"addr_test1qrv5xfwh043mlc3vk5d97s4nmhxu7cmleyssvhx37gkfyejfe8d38v3vsfgetjafgrsdc49krug8wf04h5rmtengtejqlxrksk",
+        "verification_key":"5b35352c3232382c3134342c38372c3133382c3133362c34382c382c31342c3138372c38352c3134382c39372c3233322c3235352c3232392c33382c3234342c3234372c3230342c3139382c31332c33312c3232322c32352c3136342c35322c3130322c39312c3132302c3230382c3134375d"
+    }"#;
+
+    #[test]
+    fn golden_test_for_cardano_chain() {
+        AdapterBuilder::new(
+            &AdapterType::CardanoChain,
+            &Some(GOLDEN_ADAPTER_PARAMS.to_owned()),
+        )
+        .build(Arc::new(MockChainObserver::new()))
+        .expect("building an cardano chain era reader with golden params should not fail");
+    }
+}