feature: Add a subcommand generate_keypair on eracommand

Author: sfauvel

mithril-aggregator/src/commands/era_command.rs

@@ -40,6 +40,9 @@ pub enum EraSubCommand {
 
     /// Era tx datum generate command.
     GenerateTxDatum(GenerateTxDatumEraSubCommand),
+
+    /// Era keypair generation command.
+    GenerateKeypair(GenerateKeypairEraSubCommand),
 }
 
 impl EraSubCommand {
@@ -51,6 +54,7 @@ impl EraSubCommand {
         match self {
             Self::List(cmd) => cmd.execute(root_logger, config_builder).await,
             Self::GenerateTxDatum(cmd) => cmd.execute(root_logger, config_builder).await,
+            Self::GenerateKeypair(cmd) => cmd.execute(root_logger, config_builder).await,
         }
     }
 }
@@ -129,3 +133,30 @@ impl GenerateTxDatumEraSubCommand {
         Ok(())
     }
 }
+
+/// Era keypair generation command.
+#[derive(Parser, Debug, Clone)]
+pub struct GenerateKeypairEraSubCommand {
+    /// Target path for the generated keypair
+    #[clap(long)]
+    target_path: PathBuf,
+}
+
+impl GenerateKeypairEraSubCommand {
+    pub async fn execute(
+        &self,
+        root_logger: Logger,
+        _config_builder: ConfigBuilder<DefaultState>,
+    ) -> StdResult<()> {
+        debug!(root_logger, "GENERATE KEYPAIR ERA command");
+        println!(
+            "Era generate keypair to {}",
+            self.target_path.to_string_lossy()
+        );
+
+        EraTools::create_and_save_era_keypair(&self.target_path)
+            .with_context(|| "era-tools: keypair generation error")?;
+
+        Ok(())
+    }
+}

mithril-aggregator/src/tools/era.rs

@@ -1,3 +1,5 @@
+use std::path::{Path, PathBuf};
+
 use anyhow::anyhow;
 use mithril_common::{
     chain_observer::{TxDatumBuilder, TxDatumFieldValue},
@@ -56,16 +58,41 @@ impl EraTools {
             .build()?;
         Ok(tx_datum.0)
     }
+
+    /// Export the era keypair to a folder and returns the paths to the files (secret key, verification_key)
+    pub fn create_and_save_era_keypair(keypair_path: &Path) -> StdResult<(PathBuf, PathBuf)> {
+        let era_signer = EraMarkersSigner::create_non_deterministic_signer();
+        let era_secret_key_path = keypair_path.join("era.sk");
+        era_signer
+            .secret_key()
+            .write_json_hex_to_file(&era_secret_key_path)?;
+        let era_verification_key_path = keypair_path.join("era.vk");
+        era_signer
+            .verification_key()
+            .write_json_hex_to_file(&era_verification_key_path)?;
+
+        Ok((era_secret_key_path, era_verification_key_path))
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    use mithril_common::{
+        crypto_helper::{EraMarkersVerifierSecretKey, EraMarkersVerifierVerificationKey},
+        test_utils::TempDir,
+    };
+    use std::fs::read_to_string;
+
     use super::*;
 
     fn build_tools() -> EraTools {
         EraTools {}
     }
 
+    fn get_temp_dir(dir_name: &str) -> PathBuf {
+        TempDir::create("era", dir_name)
+    }
+
     #[test]
     fn get_supported_eras_list() {
         let era_tools = build_tools();
@@ -92,4 +119,25 @@ mod tests {
             .generate_tx_datum(Epoch(3), Some(Epoch(2)), &era_markers_signer)
             .expect_err("generate_tx_datum should have failed");
     }
+
+    #[test]
+    fn test_create_and_save_era_keypair() {
+        let temp_dir = get_temp_dir("test_create_and_save_era_keypair");
+        let (era_secret_key_path, era_verification_key_path) =
+            EraTools::create_and_save_era_keypair(&temp_dir)
+                .expect("Failed to create and save era keypair");
+        let era_secret_key = EraMarkersVerifierSecretKey::from_json_hex(
+            &read_to_string(&era_secret_key_path).expect("Failed to read era secret key file"),
+        )
+        .expect("Failed to parse era secret key");
+        let era_verification_key = EraMarkersVerifierVerificationKey::from_json_hex(
+            &read_to_string(&era_verification_key_path)
+                .expect("Failed to read era verification key file"),
+        )
+        .expect("Failed to parse era verification key");
+        let era_verifier = EraMarkersSigner::from_secret_key(era_secret_key).create_verifier();
+
+        let expected_era_verification_key = era_verifier.to_verification_key();
+        assert_eq!(expected_era_verification_key, era_verification_key);
+    }
 }

mithril-common/src/crypto_helper/era.rs

@@ -54,6 +54,16 @@ impl EraMarkersSigner {
         Self::create_test_signer(rng)
     }
 
+    /// Get the [EraMarkersVerifierSecretKey]
+    pub fn secret_key(&self) -> EraMarkersVerifierSecretKey {
+        self.secret_key.clone()
+    }
+
+    /// Get the [EraMarkersVerifierVerificationKey]
+    pub fn verification_key(&self) -> EraMarkersVerifierVerificationKey {
+        self.secret_key.verifying_key().into()
+    }
+
     /// [EraMarkersSigner] from [EraMarkersVerifierSecretKey]
     pub fn from_secret_key(secret_key: EraMarkersVerifierSecretKey) -> Self {
         Self { secret_key }