feat: aggregator and signer get Mithril era from Cardano chain

Author: jpraynaud

mithril-test-lab/mithril-end-to-end/src/assertions/exec.rs

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use crate::{Aggregator, Devnet};
 use mithril_common::entities::ProtocolParameters;
 use mithril_common::StdResult;
@@ -16,6 +18,23 @@ pub async fn bootstrap_genesis_certificate(aggregator: &mut Aggregator) -> StdRe
     Ok(())
 }
 
+pub async fn register_era_marker(aggregator: &mut Aggregator, devnet: &Devnet) -> StdResult<()> {
+    info!("Register era marker");
+
+    info!("> generating era marker tx datum...");
+    let tx_datum_file_path = devnet
+        .artifacts_dir
+        .join(PathBuf::from("era-tx-datum.txt".to_string()));
+    aggregator
+        .era_generate_tx_datum(&tx_datum_file_path)
+        .await?;
+
+    info!("> writing era marker on the Cardano chain...");
+    devnet.write_era_marker(&tx_datum_file_path).await?;
+
+    Ok(())
+}
+
 pub async fn delegate_stakes_to_pools(devnet: &Devnet, delegation_round: u16) -> StdResult<()> {
     info!("Delegate stakes to the cardano pools");
 

mithril-test-lab/mithril-end-to-end/src/devnet/runner.rs

@@ -2,14 +2,15 @@ use anyhow::{anyhow, Context};
 use mithril_common::entities::PartyId;
 use mithril_common::StdResult;
 use slog_scope::info;
-use std::fs;
-use std::path::PathBuf;
+use std::fs::{self, File};
+use std::io::Read;
+use std::path::{Path, PathBuf};
 use std::process::Stdio;
 use tokio::process::Command;
 
 #[derive(Debug, Clone, Default)]
 pub struct Devnet {
-    artifacts_dir: PathBuf,
+    pub artifacts_dir: PathBuf,
     number_of_bft_nodes: u8,
     number_of_pool_nodes: u8,
 }
@@ -147,6 +148,22 @@ impl Devnet {
         }
     }
 
+    pub fn mithril_era_marker_address_path(&self) -> PathBuf {
+        self.artifacts_dir
+            .join("addresses")
+            .join("mithril-era.addr")
+    }
+
+    pub fn mithril_era_marker_address(&self) -> StdResult<String> {
+        let mut mithril_era_marker_address_file =
+            File::open(self.mithril_era_marker_address_path())?;
+        let mut mithril_era_marker_address_buffer = Vec::new();
+        mithril_era_marker_address_file.read_to_end(&mut mithril_era_marker_address_buffer)?;
+
+        String::from_utf8(mithril_era_marker_address_buffer)
+            .with_context(|| "Failed to read mithril era marker address file")
+    }
+
     pub fn cardano_cli_path(&self) -> PathBuf {
         self.artifacts_dir.join("cardano-cli")
     }
@@ -252,6 +269,32 @@ impl Devnet {
             None => Err(anyhow!("Delegating stakes terminated by signal")),
         }
     }
+
+    pub async fn write_era_marker(&self, target_path: &Path) -> StdResult<()> {
+        let run_script = "era-mithril.sh";
+        let run_script_path = self.artifacts_dir.join(run_script);
+        let mut run_command = Command::new(&run_script_path);
+        run_command
+            .current_dir(&self.artifacts_dir)
+            .kill_on_drop(true);
+        run_command.env("DATUM_FILE", target_path.to_str().unwrap());
+
+        info!("Writing era marker on chain"; "script" => &run_script_path.display());
+
+        let status = run_command
+            .spawn()
+            .with_context(|| "Failed to write era marker on chain")?
+            .wait()
+            .await
+            .with_context(|| "Error while writin era marker on chain")?;
+        match status.code() {
+            Some(0) => Ok(()),
+            Some(code) => Err(anyhow!(
+                "Write era marker on chain exited with status code: {code}"
+            )),
+            None => Err(anyhow!("Write era marker on chain terminated by signal")),
+        }
+    }
 }
 
 #[cfg(test)]

mithril-test-lab/mithril-end-to-end/src/mithril/aggregator.rs

@@ -1,6 +1,9 @@
 use crate::devnet::BftNode;
 use crate::utils::MithrilCommand;
-use crate::DEVNET_MAGIC_ID;
+use crate::{
+    DEVNET_MAGIC_ID, ERA_MARKERS_SECRET_KEY, ERA_MARKERS_VERIFICATION_KEY, GENESIS_SECRET_KEY,
+    GENESIS_VERIFICATION_KEY,
+};
 use anyhow::{anyhow, Context};
 use mithril_common::{entities, StdResult};
 use std::collections::HashMap;
@@ -16,6 +19,7 @@ pub struct AggregatorConfig<'a> {
     pub work_dir: &'a Path,
     pub bin_dir: &'a Path,
     pub mithril_era: &'a str,
+    pub mithril_era_marker_address: &'a str,
     pub signed_entity_types: &'a [String],
     pub chain_observer_type: &'a str,
 }
@@ -33,8 +37,8 @@ impl Aggregator {
         let magic_id = DEVNET_MAGIC_ID.to_string();
         let server_port_parameter = aggregator_config.server_port.to_string();
         let era_reader_adapter_params = format!(
-            r#"{{"markers": [{{"name": "{}", "epoch": 0}}]}}"#,
-            aggregator_config.mithril_era
+            r#"{{"address": "{}", "verification_key": "{}"}}"#,
+            aggregator_config.mithril_era_marker_address, ERA_MARKERS_VERIFICATION_KEY
         );
         let signed_entity_types = aggregator_config.signed_entity_types.join(",");
         let env = HashMap::from([
@@ -52,10 +56,13 @@ impl Aggregator {
                 aggregator_config.bft_node.socket_path.to_str().unwrap(),
             ),
             ("STORE_RETENTION_LIMIT", "10"),
-            ("CARDANO_CLI_PATH", aggregator_config.cardano_cli_path.to_str().unwrap()),
-            ("GENESIS_VERIFICATION_KEY", "5b33322c3235332c3138362c3230312c3137372c31312c3131372c3133352c3138372c3136372c3138312c3138382c32322c35392c3230362c3130352c3233312c3135302c3231352c33302c37382c3231322c37362c31362c3235322c3138302c37322c3133342c3133372c3234372c3136312c36385d"),
-            ("GENESIS_SECRET_KEY", "5b3131382c3138342c3232342c3137332c3136302c3234312c36312c3134342c36342c39332c3130362c3232392c38332c3133342c3138392c34302c3138392c3231302c32352c3138342c3136302c3134312c3233372c32362c3136382c35342c3233392c3230342c3133392c3131392c31332c3139395d"),
-            ("ERA_READER_ADAPTER_TYPE", "dummy"),
+            (
+                "CARDANO_CLI_PATH",
+                aggregator_config.cardano_cli_path.to_str().unwrap(),
+            ),
+            ("GENESIS_VERIFICATION_KEY", GENESIS_VERIFICATION_KEY),
+            ("GENESIS_SECRET_KEY", GENESIS_SECRET_KEY),
+            ("ERA_READER_ADAPTER_TYPE", "cardano-chain"),
             ("ERA_READER_ADAPTER_PARAMS", &era_reader_adapter_params),
             ("SIGNED_ENTITY_TYPES", &signed_entity_types),
             ("CARDANO_NODE_VERSION", "8.7.3"),
@@ -137,6 +144,40 @@ impl Aggregator {
         Ok(())
     }
 
+    // TODO: This works only for the current epoch, and needs to be fixed
+    pub async fn era_generate_tx_datum(&mut self, target_path: &Path) -> StdResult<()> {
+        let exit_status = self
+            .command
+            .start(&[
+                "era".to_string(),
+                "generate-tx-datum".to_string(),
+                "--current-era-epoch".to_string(),
+                "0".to_string(),
+                "--era-markers-secret-key".to_string(),
+                ERA_MARKERS_SECRET_KEY.to_string(),
+                "--target-path".to_string(),
+                target_path.to_str().unwrap().to_string(),
+            ])?
+            .wait()
+            .await
+            .with_context(|| "`mithril-aggregator era generate-tx-datum` crashed")?;
+
+        if exit_status.success() {
+            Ok(())
+        } else {
+            Err(match exit_status.code() {
+                Some(c) => {
+                    anyhow!("`mithril-aggregator era generate-tx-datum` exited with code: {c}")
+                }
+                None => {
+                    anyhow!(
+                        "`mithril-aggregator era generate-tx-datum` was terminated with a signal"
+                    )
+                }
+            })
+        }
+    }
+
     pub fn set_protocol_parameters(&mut self, protocol_parameters: &entities::ProtocolParameters) {
         self.command.set_env_var(
             "PROTOCOL_PARAMETERS__K",

mithril-test-lab/mithril-end-to-end/src/mithril/infrastructure.rs

@@ -1,5 +1,5 @@
 use crate::{
-    Aggregator, AggregatorConfig, Client, Devnet, RelayAggregator, RelaySigner, Signer,
+    assertions, Aggregator, AggregatorConfig, Client, Devnet, RelayAggregator, RelaySigner, Signer,
     DEVNET_MAGIC_ID,
 };
 use anyhow::anyhow;
@@ -13,6 +13,8 @@ use std::borrow::BorrowMut;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use super::signer::SignerConfig;
+
 pub struct MithrilInfrastructureConfig {
     pub server_port: u64,
     pub devnet: Devnet,
@@ -52,6 +54,7 @@ impl MithrilInfrastructure {
             work_dir: &config.work_dir,
             bin_dir: &config.bin_dir,
             mithril_era: &config.mithril_era,
+            mithril_era_marker_address: &config.devnet.mithril_era_marker_address()?,
             signed_entity_types: &config.signed_entity_types,
             chain_observer_type,
         })?;
@@ -60,6 +63,7 @@ impl MithrilInfrastructure {
             m: 100,
             phi_f: 0.95,
         });
+        assertions::register_era_marker(&mut aggregator, &config.devnet).await?;
         aggregator.serve()?;
 
         let mut relay_aggregators: Vec<RelayAggregator> = vec![];
@@ -104,15 +108,16 @@ impl MithrilInfrastructure {
             } else {
                 aggregator.endpoint()
             };
-            let mut signer = Signer::new(
+            let mut signer = Signer::new(&SignerConfig {
                 aggregator_endpoint,
                 pool_node,
-                &config.devnet.cardano_cli_path(),
-                &config.work_dir,
-                &config.bin_dir,
-                &config.mithril_era,
+                cardano_cli_path: &config.devnet.cardano_cli_path(),
+                work_dir: &config.work_dir,
+                bin_dir: &config.bin_dir,
+                mithril_era: &config.mithril_era,
+                mithril_era_marker_address: &config.devnet.mithril_era_marker_address()?,
                 enable_certification,
-            )?;
+            })?;
             signer.start()?;
 
             signers.push(signer);

mithril-test-lab/mithril-end-to-end/src/mithril/mod.rs

@@ -13,3 +13,8 @@ pub use relay_signer::RelaySigner;
 pub use signer::Signer;
 
 pub const DEVNET_MAGIC_ID: mithril_common::MagicId = 42;
+
+pub const GENESIS_VERIFICATION_KEY: &str = "5b33322c3235332c3138362c3230312c3137372c31312c3131372c3133352c3138372c3136372c3138312c3138382c32322c35392c3230362c3130352c3233312c3135302c3231352c33302c37382c3231322c37362c31362c3235322c3138302c37322c3133342c3133372c3234372c3136312c36385d";
+pub const GENESIS_SECRET_KEY: &str = "5b3131382c3138342c3232342c3137332c3136302c3234312c36312c3134342c36342c39332c3130362c3232392c38332c3133342c3138392c34302c3138392c3231302c32352c3138342c3136302c3134312c3233372c32362c3136382c35342c3233392c3230342c3133392c3131392c31332c3139395d";
+pub const ERA_MARKERS_VERIFICATION_KEY: &str = "5b33322c3235332c3138362c3230312c3137372c31312c3131372c3133352c3138372c3136372c3138312c3138382c32322c35392c3230362c3130352c3233312c3135302c3231352c33302c37382c3231322c37362c31362c3235322c3138302c37322c3133342c3133372c3234372c3136312c36385d";
+pub const ERA_MARKERS_SECRET_KEY: &str = "5b3131382c3138342c3232342c3137332c3136302c3234312c36312c3134342c36342c39332c3130362c3232392c38332c3133342c3138392c34302c3138392c3231302c32352c3138342c3136302c3134312c3233372c32362c3136382c35342c3233392c3230342c3133392c3131392c31332c3139395d";

mithril-test-lab/mithril-end-to-end/src/mithril/signer.rs

@@ -1,12 +1,24 @@
 use crate::devnet::PoolNode;
 use crate::utils::MithrilCommand;
-use crate::DEVNET_MAGIC_ID;
+use crate::{DEVNET_MAGIC_ID, ERA_MARKERS_VERIFICATION_KEY};
 use mithril_common::entities::PartyId;
 use mithril_common::StdResult;
 use std::collections::HashMap;
 use std::path::Path;
 use tokio::process::Child;
 
+#[derive(Debug)]
+pub struct SignerConfig<'a> {
+    pub aggregator_endpoint: String,
+    pub pool_node: &'a PoolNode,
+    pub cardano_cli_path: &'a Path,
+    pub work_dir: &'a Path,
+    pub bin_dir: &'a Path,
+    pub mithril_era: &'a str,
+    pub mithril_era_marker_address: &'a str,
+    pub enable_certification: bool,
+}
+
 #[derive(Debug)]
 pub struct Signer {
     party_id: PartyId,
@@ -15,50 +27,64 @@ pub struct Signer {
 }
 
 impl Signer {
-    pub fn new(
-        aggregator_endpoint: String,
-        pool_node: &PoolNode,
-        cardano_cli_path: &Path,
-        work_dir: &Path,
-        bin_dir: &Path,
-        mithril_era: &str,
-        enable_certification: bool,
-    ) -> StdResult<Self> {
-        let party_id = pool_node.party_id()?;
+    pub fn new(signer_config: &SignerConfig) -> StdResult<Self> {
+        let party_id = signer_config.pool_node.party_id()?;
         let magic_id = DEVNET_MAGIC_ID.to_string();
         let data_stores_path = format!("./stores/signer-{party_id}");
-        let era_reader_adapater_params =
-            format!(r#"{{"markers": [{{"name": "{mithril_era}", "epoch": 0}}]}}"#);
+        let era_reader_adapter_params = format!(
+            r#"{{"address": "{}", "verification_key": "{}"}}"#,
+            signer_config.mithril_era_marker_address, ERA_MARKERS_VERIFICATION_KEY
+        );
         let mut env = HashMap::from([
             ("NETWORK", "devnet"),
             ("RUN_INTERVAL", "100"),
-            ("AGGREGATOR_ENDPOINT", &aggregator_endpoint),
-            ("DB_DIRECTORY", pool_node.db_path.to_str().unwrap()),
+            ("AGGREGATOR_ENDPOINT", &signer_config.aggregator_endpoint),
+            (
+                "DB_DIRECTORY",
+                signer_config.pool_node.db_path.to_str().unwrap(),
+            ),
             ("DATA_STORES_DIRECTORY", &data_stores_path),
             ("NETWORK_MAGIC", &magic_id),
             (
                 "CARDANO_NODE_SOCKET_PATH",
-                pool_node.socket_path.to_str().unwrap(),
+                signer_config.pool_node.socket_path.to_str().unwrap(),
+            ),
+            (
+                "CARDANO_CLI_PATH",
+                signer_config.cardano_cli_path.to_str().unwrap(),
             ),
-            ("CARDANO_CLI_PATH", cardano_cli_path.to_str().unwrap()),
-            ("ERA_READER_ADAPTER_TYPE", "dummy"),
-            ("ERA_READER_ADAPTER_PARAMS", &era_reader_adapater_params),
+            ("ERA_READER_ADAPTER_TYPE", "cardano-chain"),
+            ("ERA_READER_ADAPTER_PARAMS", &era_reader_adapter_params),
         ]);
-        if enable_certification {
+        if signer_config.enable_certification {
             env.insert(
                 "KES_SECRET_KEY_PATH",
-                pool_node.kes_secret_key_path.to_str().unwrap(),
+                signer_config
+                    .pool_node
+                    .kes_secret_key_path
+                    .to_str()
+                    .unwrap(),
             );
             env.insert(
                 "OPERATIONAL_CERTIFICATE_PATH",
-                pool_node.operational_certificate_path.to_str().unwrap(),
+                signer_config
+                    .pool_node
+                    .operational_certificate_path
+                    .to_str()
+                    .unwrap(),
             );
         } else {
             env.insert("PARTY_ID", &party_id);
         }
         let args = vec!["-vvv"];
 
-        let mut command = MithrilCommand::new("mithril-signer", work_dir, bin_dir, env, &args)?;
+        let mut command = MithrilCommand::new(
+            "mithril-signer",
+            signer_config.work_dir,
+            signer_config.bin_dir,
+            env,
+            &args,
+        )?;
         command.set_log_name(format!("mithril-signer-{party_id}").as_str());
 
         Ok(Self {

mithril-test-lab/mithril-end-to-end/src/stress_test/aggregator_helpers.rs

@@ -25,6 +25,7 @@ pub async fn bootstrap_aggregator(
         work_dir: &args.work_dir,
         bin_dir: &args.bin_dir,
         mithril_era: &args.mithril_era,
+        mithril_era_marker_address: "",
         signed_entity_types: &signed_entity_types,
         chain_observer_type,
     })