Merge pull request #1171 from input-output-hk/ensemble/668/protocol-key-for-era-keys

Protocol key for era keys

Author: Alenar

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-aggregator"
-version = "0.3.73"
+version = "0.3.74"
 description = "A Mithril Aggregator server"
 authors = { workspace = true }
 edition = { workspace = true }

mithril-aggregator/Cargo.toml

@@ -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-aggregator/src/commands/era_command.rs

@@ -1,7 +1,7 @@
 use anyhow::anyhow;
 use mithril_common::{
     chain_observer::{TxDatumBuilder, TxDatumFieldValue},
-    crypto_helper::{key_encode_hex, EraMarkersSigner},
+    crypto_helper::EraMarkersSigner,
     entities::Epoch,
     era::{adapters::EraMarkersPayloadCardanoChain, EraMarker, SupportedEra},
     StdResult,
@@ -52,11 +52,7 @@ impl EraTools {
         .sign(era_markers_signer)?;
 
         let tx_datum = TxDatumBuilder::new()
-            .add_field(TxDatumFieldValue::Bytes(
-                key_encode_hex(era_markers_payload).map_err(|e| {
-                    anyhow!(e).context("era markerspayload could not be hex encoded")
-                })?,
-            ))
+            .add_field(TxDatumFieldValue::Bytes(era_markers_payload.to_json_hex()?))
             .build()?;
         Ok(tx_datum.0)
     }

mithril-aggregator/src/tools/era.rs

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-common"
-version = "0.2.96"
+version = "0.2.97"
 authors = { workspace = true }
 edition = { workspace = true }
 documentation = { workspace = true }

mithril-common/Cargo.toml

@@ -4,14 +4,16 @@ 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;
+pub type EraMarkersVerifierSignature = ProtocolKey<ed25519_dalek::Signature>;
 
 #[derive(Error, Debug)]
 /// [EraMarkersSigner] and [EraMarkersVerifier] related errors.
@@ -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
@@ -79,7 +80,7 @@ impl EraMarkersSigner {
     pub fn sign(&self, message: &[u8]) -> EraMarkersVerifierSignature {
         let expanded_secret_key = self.create_expanded_secret_key();
         let verification_key = self.create_verification_key(&expanded_secret_key);
-        expanded_secret_key.sign(message, &verification_key)
+        expanded_secret_key.sign(message, &verification_key).into()
     }
 }
 
@@ -112,9 +113,26 @@ impl EraMarkersVerifier {
 
 #[cfg(test)]
 mod tests {
-    use super::super::codec::{key_decode_hex, key_encode_hex};
     use super::*;
 
+    const GOLDEN_ERA_MARKERS_VERIFICATION_KEY: &str =
+        "5b32332c32372c3131322c362c35372c38342c3138302c342c3135302c3233322c3233372c3132362c3131392c\
+        3231342c33352c35342c38312c3230382c3231372c39392c3137302c3233312c3133392c362c3132322c39342c3\
+        9322c3137322c32332c3130322c3135372c3136375d";
+    const GOLDEN_ERA_MARKERS_SECRET_KEY: &str =
+        "5b34332c3133322c3232312c3138382c3235332c3132372c3235352c38362c3136322c3133312c3233332c3131\
+        362c3134322c3233352c3131312c3133332c3134312c3138332c302c33392c3132302c3139372c39322c3133302\
+        c3233342c34362c3135372c32352c3133322c31352c3234312c3235345d";
+
+    #[test]
+    fn golden_master() {
+        EraMarkersVerifierVerificationKey::from_json_hex(GOLDEN_ERA_MARKERS_VERIFICATION_KEY)
+            .expect("Decoding golden verification key should not fail");
+
+        EraMarkersVerifierSecretKey::from_json_hex(GOLDEN_ERA_MARKERS_SECRET_KEY)
+            .expect("Decoding golden secret key should not fail");
+    }
+
     #[test]
     fn test_generate_test_deterministic_keypair() {
         let signer = EraMarkersSigner::create_deterministic_signer();
@@ -129,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()
         );
     }
 
@@ -144,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/crypto_helper/era.rs

@@ -33,9 +33,6 @@ pub type HexEncodedKeySlice<'a> = &'a str;
 /// Hex encoded Single Signature
 pub type HexEncodedSingleSignature = HexEncodedKey;
 
-/// Hex encoded Multi Signature
-pub type HexEncodedMultiSignature = HexEncodedKey;
-
 /// Hex encoded Aggregate Verification Key
 pub type HexEncodedAgregateVerificationKey = HexEncodedKey;
 
@@ -54,17 +51,8 @@ pub type HexEncodedGenesisSecretKey = HexEncodedKey;
 /// Hex encoded Genesis Verification Key
 pub type HexEncodedGenesisVerificationKey = HexEncodedKey;
 
-/// Hex encoded Genesis Signature
-pub type HexEncodedGenesisSignature = HexEncodedKey;
-
 /// Hex encoded Sha256 Digest
 pub type HexEncodedDigest = HexEncodedKey;
 
 /// Hex encoded Era Markers Secret Key
 pub type HexEncodedEraMarkersSecretKey = HexEncodedKey;
-
-/// Hex encoded Era Markers Verification Key
-pub type HexEncodedEraMarkersVerificationKey = HexEncodedKey;
-
-/// Hex encoded Era Markers Signature
-pub type HexEncodedEraMarkersSignature = HexEncodedKey;

mithril-common/src/entities/type_alias.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");
+    }
+}