Merge pull request #756 from input-output-hk/jpraynaud/755-era-cli-command

Add era command in aggregator cli

Author: jpraynaud

.github/workflows/ci.yml

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

Cargo.lock

@@ -8,21 +8,23 @@ use tokio::{sync::RwLock, time::Duration};
 use mithril_common::{
     certificate_chain::MithrilCertificateVerifier,
     chain_observer::{CardanoCliRunner, ChainObserver},
-    crypto_helper::{key_decode_hex, ProtocolGenesisSigner, ProtocolGenesisVerifier},
+    crypto_helper::{
+        key_decode_hex, EraMarkersSigner, ProtocolGenesisSigner, ProtocolGenesisVerifier,
+    },
     database::{ApplicationNodeType, DatabaseVersionChecker},
     digesters::{
         cache::{ImmutableFileDigestCacheProvider, JsonImmutableFileDigestCacheProviderBuilder},
         CardanoImmutableDigester, ImmutableFileSystemObserver,
     },
-    entities::{Epoch, HexEncodedGenesisSecretKey},
+    entities::{Epoch, HexEncodedEraMarkersSecretKey, HexEncodedGenesisSecretKey},
     era::{EraChecker, EraReader},
     store::{adapter::SQLiteAdapter, StakeStore},
     BeaconProvider, BeaconProviderImpl,
 };
 
 use crate::{
     event_store::{self, TransmitterService},
-    tools::{GenesisTools, GenesisToolsDependency},
+    tools::{EraTools, GenesisTools, GenesisToolsDependency},
     AggregatorConfig, AggregatorRunner, AggregatorRuntime, CertificatePendingStore,
     CertificateStore, Configuration, DefaultConfiguration, DependencyManager, GenesisConfiguration,
     GzipSnapshotter, MithrilSignerRegisterer, MultiSignerImpl, ProtocolParametersStore,
@@ -228,6 +230,7 @@ impl MainOpts {
 #[derive(Debug, Clone, Subcommand)]
 pub enum MainCommand {
     Genesis(GenesisCommand),
+    Era(EraCommand),
     Serve(ServeCommand),
 }
 
@@ -238,6 +241,7 @@ impl MainCommand {
     ) -> Result<(), Box<dyn Error>> {
         match self {
             Self::Genesis(cmd) => cmd.execute(config_builder).await,
+            Self::Era(cmd) => cmd.execute(config_builder).await,
             Self::Serve(cmd) => cmd.execute(config_builder).await,
         }
     }
@@ -650,3 +654,109 @@ impl BootstrapGenesisSubCommand {
             .await
     }
 }
+
+/// Era tools
+#[derive(Parser, Debug, Clone)]
+pub struct EraCommand {
+    /// commands
+    #[clap(subcommand)]
+    pub era_subcommand: EraSubCommand,
+}
+
+impl EraCommand {
+    pub async fn execute(
+        &self,
+        config_builder: ConfigBuilder<DefaultState>,
+    ) -> Result<(), Box<dyn Error>> {
+        self.era_subcommand.execute(config_builder).await
+    }
+}
+
+/// Era tools commands.
+#[derive(Debug, Clone, Subcommand)]
+pub enum EraSubCommand {
+    /// Era list command.
+    List(ListEraSubCommand),
+
+    /// Era tx datum generate command.
+    GenerateTxDatum(GenerateTxDatumEraSubCommand),
+}
+
+impl EraSubCommand {
+    pub async fn execute(
+        &self,
+        config_builder: ConfigBuilder<DefaultState>,
+    ) -> Result<(), Box<dyn Error>> {
+        match self {
+            Self::List(cmd) => cmd.execute(config_builder).await,
+            Self::GenerateTxDatum(cmd) => cmd.execute(config_builder).await,
+        }
+    }
+}
+
+/// Era list command
+#[derive(Parser, Debug, Clone)]
+pub struct ListEraSubCommand {
+    /// Enable JSON output.
+    #[clap(long)]
+    json: bool,
+}
+
+impl ListEraSubCommand {
+    pub async fn execute(
+        &self,
+        _config_builder: ConfigBuilder<DefaultState>,
+    ) -> Result<(), Box<dyn Error>> {
+        debug!("LIST ERA command");
+        let era_tools = EraTools::new();
+        let eras = era_tools.get_supported_eras_list()?;
+
+        if self.json {
+            println!("{}", serde_json::to_string(&eras)?);
+        } else {
+            println!("Supported Eras:");
+            println!("{eras:#?}");
+        }
+
+        Ok(())
+    }
+}
+
+/// Era tx datum generate command
+#[derive(Parser, Debug, Clone)]
+pub struct GenerateTxDatumEraSubCommand {
+    /// Current Era epoch
+    #[clap(long, env = "CURRENT_ERA_EPOCH")]
+    current_era_epoch: u64,
+
+    /// Next Era epoch start, if exists
+    #[clap(long, env = "NEXT_ERA_EPOCH")]
+    next_era_epoch: Option<u64>,
+
+    /// Era Markers Secret Key
+    #[clap(long, env = "ERA_MARKERS_SECRET_KEY")]
+    era_markers_secret_key: HexEncodedEraMarkersSecretKey,
+}
+
+impl GenerateTxDatumEraSubCommand {
+    pub async fn execute(
+        &self,
+        _config_builder: ConfigBuilder<DefaultState>,
+    ) -> Result<(), Box<dyn Error>> {
+        debug!("GENERATETXDATUM ERA command");
+        let era_tools = EraTools::new();
+
+        let era_markers_secret_key = key_decode_hex(&self.era_markers_secret_key)?;
+        let era_markers_signer = EraMarkersSigner::from_secret_key(era_markers_secret_key);
+        print!(
+            "{}",
+            era_tools.generate_tx_datum(
+                Epoch(self.current_era_epoch),
+                self.next_era_epoch.map(Epoch),
+                &era_markers_signer
+            )?
+        );
+
+        Ok(())
+    }
+}

mithril-aggregator/Cargo.toml

@@ -0,0 +1,95 @@
+use std::error::Error;
+
+use mithril_common::{
+    chain_observer::{TxDatumBuilder, TxDatumFieldValue},
+    crypto_helper::{key_encode_hex, EraMarkersSigner},
+    entities::Epoch,
+    era::{adapters::EraMarkersPayloadCardanoChain, EraMarker, SupportedEra},
+};
+
+type EraToolsResult<R> = Result<R, Box<dyn Error>>;
+
+pub struct EraTools {}
+
+impl EraTools {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    /// Get list of supported eras
+    pub fn get_supported_eras_list(&self) -> EraToolsResult<Vec<SupportedEra>> {
+        Ok(SupportedEra::eras())
+    }
+
+    /// Generate TxDatum for eras with sanity check of epochs
+    pub fn generate_tx_datum(
+        &self,
+        current_era_epoch: Epoch,
+        maybe_next_era_epoch: Option<Epoch>,
+        era_markers_signer: &EraMarkersSigner,
+    ) -> EraToolsResult<String> {
+        if maybe_next_era_epoch.unwrap_or_default() >= current_era_epoch {
+            Err("next era epoch must be strictly greater than the current era epoch".to_string())?;
+        }
+
+        let mut era_markers = Vec::new();
+        for (index, era) in SupportedEra::eras().iter().enumerate() {
+            let era_marker = match index {
+                0 => EraMarker::new(&era.to_string(), Some(current_era_epoch)),
+                1 => EraMarker::new(&era.to_string(), maybe_next_era_epoch),
+                _ => Err("too many eras retrieved, can't generate tx datum".to_string())?,
+            };
+            era_markers.push(era_marker);
+        }
+        let era_markers_payload = EraMarkersPayloadCardanoChain {
+            markers: era_markers,
+            signature: None,
+        }
+        .sign(era_markers_signer)?;
+
+        let tx_datum = TxDatumBuilder::new()
+            .add_field(TxDatumFieldValue::Bytes(
+                key_encode_hex(era_markers_payload)
+                    .map_err(|e| format!("era markerspayload could not be hex encoded: {e}"))?,
+            ))
+            .build()?;
+
+        Ok(tx_datum.0)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn build_tools() -> EraTools {
+        EraTools {}
+    }
+
+    #[test]
+    fn get_supported_eras_list() {
+        let era_tools = build_tools();
+        let supported_eras_list = era_tools
+            .get_supported_eras_list()
+            .expect("get_supported_eras_list should not fail");
+        assert_eq!(supported_eras_list, SupportedEra::eras());
+    }
+
+    #[test]
+    fn generate_tx_datum_ok() {
+        let era_markers_signer = EraMarkersSigner::create_deterministic_signer();
+        let era_tools = build_tools();
+        let _ = era_tools
+            .generate_tx_datum(Epoch(1), None, &era_markers_signer)
+            .expect("generate_tx_datum should not fail");
+    }
+
+    #[test]
+    fn generate_tx_datum_wrong_epochs() {
+        let era_markers_signer = EraMarkersSigner::create_deterministic_signer();
+        let era_tools = build_tools();
+        let _ = era_tools
+            .generate_tx_datum(Epoch(1), Some(Epoch(2)), &era_markers_signer)
+            .expect_err("generate_tx_datum should have failed");
+    }
+}

mithril-aggregator/src/command_args.rs

@@ -1,8 +1,10 @@
 mod digest_helpers;
+mod era;
 mod genesis;
 mod remote_file_uploader;
 
 pub use digest_helpers::extract_digest_from_path;
+pub use era::EraTools;
 pub use genesis::{GenesisTools, GenesisToolsDependency};
 pub use remote_file_uploader::{GcpFileUploader, RemoteFileUploader};
 

mithril-aggregator/src/tools/era.rs

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-common"
-version = "0.2.16"
+version = "0.2.17"
 authors = { workspace = true }
 edition = { workspace = true }
 documentation = { workspace = true }
@@ -44,6 +44,8 @@ sha2 = "0.10.2"
 slog = { version = "2.7.0", features = ["max_level_trace", "release_max_level_debug"] }
 slog-scope = "4.4.0"
 sqlite = "0.28"
+strum = "0.24.1"
+strum_macros = "0.24.1"
 thiserror = "1.0.31"
 tokio = { version = "1.17.0", features = ["full"] }
 walkdir = "2"

mithril-aggregator/src/tools/mod.rs

@@ -587,7 +587,7 @@ pool1qz2vzszautc2c8mljnqre2857dpmheq7kgt6vav0s38tvvhxm6w   1.051e-6
         let observer = CardanoCliChainObserver::new(Box::new(TestCliRunner {}));
         let address = "addrtest_123456".to_string();
         let datums = observer.get_current_datums(&address).await.unwrap();
-        assert_eq!(vec![TxDatum("{\"constructor\":0,\"fields\":[{\"bytes\":\"5b0a20207b0a20202020226e616d65223a20227468616c6573222c0a202020202265706f6368223a203132330a20207d2c0a20207b0a20202020226e616d65223a20227079746861676f726173222c0a202020202265706f6368223a206e756c6c0a20207d0a5d0a\"}]}".to_string())], datums);
+        assert_eq!(vec![TxDatum(r#"{"constructor":0,"fields":[{"bytes":"5b0a20207b0a20202020226e616d65223a20227468616c6573222c0a202020202265706f6368223a203132330a20207d2c0a20207b0a20202020226e616d65223a20227079746861676f726173222c0a202020202265706f6368223a206e756c6c0a20207d0a5d0a"}]}"#.to_string())], datums);
     }
 
     #[tokio::test]

mithril-common/Cargo.toml

@@ -10,4 +10,6 @@ pub use cli_observer::{CardanoCliChainObserver, CardanoCliRunner};
 #[cfg(any(test, feature = "test_only"))]
 pub use fake_observer::FakeObserver;
 pub use interface::{ChainObserver, ChainObserverError};
-pub use model::{ChainAddress, TxDatum};
+pub use model::{
+    ChainAddress, TxDatum, TxDatumBuilder, TxDatumError, TxDatumFieldTypeName, TxDatumFieldValue,
+};