Merge pull request #1437 from input-output-hk/ensemble/1434-cardano-transactions-signed-entity-type

Support `CardanoTransactions` signed entity type

Author: jpraynaud

Cargo.lock

@@ -442,7 +442,7 @@ Here is a list of the available parameters:
 | `chain_observer_type` | `--chain-observer-type` | - | `CHAIN_OBSERVER_TYPE` | Chain observer type that can be `cardano-cli`, `pallas` or `fake`. | `pallas` | - | - |
 | `era_reader_adapter_type` | `--era-reader-adapter-type` | - | `ERA_READER_ADAPTER_TYPE` | Era reader adapter type that can be `cardano-chain`, `file` or `bootstrap`. | `bootstrap` | - | - |
 | `era_reader_adapter_params` | `--era-reader-adapter-params` | - | `ERA_READER_ADAPTER_PARAMS` | Era reader adapter params that is an optional JSON encoded parameters structure that is expected depending on the `era_reader_adapter_type` parameter | - | - | - |
-| `signed_entity_types` | `--signed-entity-types` | - | `AGGREGATOR_SIGNED_ENTITY_TYPES` | Signed entity types parameters (discriminants names in an ordered comma separated list) | - | `MithrilStakeDistribution,CardanoImmutableFilesFull,CardanoStakeDistribution` | - |
+| `signed_entity_types` | `--signed-entity-types` | - | `SIGNED_ENTITY_TYPES` | Signed entity types parameters (discriminants names in an ordered comma separated list) | - | `MithrilStakeDistribution,CardanoImmutableFilesFull,CardanoStakeDistribution` | - |
 | `snapshot_compression_algorithm` | `--snapshot-compression-algorithm` | - | `SNAPSHOT_COMPRESSION_ALGORITHM` | Compression algorithm of the snapshot archive | `zstandard` | `gzip` or `zstandard` | - |
 | `zstandard_parameters` | - | - | `ZSTANDARD_PARAMETERS__LEVEL` and `ZSTANDARD_PARAMETERS__NUMBER_OF_WORKERS` | Zstandard specific parameters | - | `{ level: 9, number_of_workers: 4 }` | - |
 

docs/website/root/manual/developer-docs/nodes/mithril-aggregator.md

@@ -0,0 +1,90 @@
+use async_trait::async_trait;
+
+use super::ArtifactBuilder;
+use anyhow::{anyhow, Context};
+use mithril_common::{
+    entities::{
+        Beacon, CardanoTransactionsCommitment, Certificate, ProtocolMessagePartKey,
+        SignedEntityType,
+    },
+    StdResult,
+};
+
+/// A [CardanoTransactionsArtifact] builder
+pub struct CardanoTransactionsArtifactBuilder {}
+
+impl CardanoTransactionsArtifactBuilder {
+    /// CardanoTransactions artifact builder factory
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[async_trait]
+impl ArtifactBuilder<Beacon, CardanoTransactionsCommitment> for CardanoTransactionsArtifactBuilder {
+    async fn compute_artifact(
+        &self,
+        beacon: Beacon,
+        certificate: &Certificate,
+    ) -> StdResult<CardanoTransactionsCommitment> {
+        let merkle_root = certificate
+            .protocol_message
+            .get_message_part(&ProtocolMessagePartKey::CardanoTransactionsMerkleRoot)
+            .ok_or(anyhow!(
+                "Can not find CardanoTransactionsMerkleRoot protocol message part in certificate"
+            ))
+            .with_context(|| {
+                format!(
+                    "Can not compute CardanoTransactionsCommitment artifact for signed_entity: {:?}",
+                    SignedEntityType::CardanoTransactions(beacon)
+                )
+            })?;
+
+        Ok(CardanoTransactionsCommitment::new(merkle_root.to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use mithril_common::{entities::ProtocolMessage, test_utils::fake_data};
+
+    use super::*;
+
+    #[tokio::test]
+    async fn should_compute_valid_artifact_with_merkleroot() {
+        let certificate = {
+            let mut certificate = fake_data::certificate("certificate-123".to_string());
+            let mut message = ProtocolMessage::new();
+            message.set_message_part(
+                ProtocolMessagePartKey::CardanoTransactionsMerkleRoot,
+                "merkleroot".to_string(),
+            );
+            certificate.protocol_message = message;
+            certificate
+        };
+
+        let cardano_transaction_artifact_builder = CardanoTransactionsArtifactBuilder::new();
+        let artifact = cardano_transaction_artifact_builder
+            .compute_artifact(Beacon::default(), &certificate)
+            .await
+            .unwrap();
+        let artifact_expected = CardanoTransactionsCommitment::new("merkleroot".to_string());
+        assert_eq!(artifact_expected, artifact);
+    }
+
+    #[tokio::test]
+    async fn should_fail_to_compute_artifact_without_merkle_root() {
+        let certificate = {
+            let mut certificate = fake_data::certificate("certificate-123".to_string());
+            let message = ProtocolMessage::new();
+            certificate.protocol_message = message;
+            certificate
+        };
+
+        let cardano_transaction_artifact_builder = CardanoTransactionsArtifactBuilder::new();
+        cardano_transaction_artifact_builder
+            .compute_artifact(Beacon::default(), &certificate)
+            .await
+            .expect_err("The artifact building must fail since there is no CardanoTransactionsMerkleRoot part in its message.");
+    }
+}

mithril-aggregator/src/artifact_builder/cardano_transactions.rs

@@ -1,8 +1,10 @@
 //! The module used for building artifact
 mod cardano_immutable_files_full;
+mod cardano_transactions;
 mod interface;
 mod mithril_stake_distribution;
 
 pub use cardano_immutable_files_full::*;
+pub use cardano_transactions::*;
 pub use interface::*;
 pub use mithril_stake_distribution::*;

mithril-aggregator/src/artifact_builder/mod.rs

@@ -610,5 +610,14 @@ alter table open_message add column is_expired bool not null default false;
 alter table open_message add column expires_at text null;
         "#,
         ),
+        // Migration 21
+        // Add the `signed_entity_type` record for 'CardanoTransactions'
+        SqlMigration::new(
+            21,
+            r#"
+insert into signed_entity_type (signed_entity_type_id, name) 
+    values  (3, 'Cardano Transactions');
+"#,
+        ),
     ]
 }

mithril-aggregator/src/database/migration.rs

@@ -910,27 +910,21 @@ else json_group_array( \
         let repository = OpenMessageRepository::new(connection.clone());
         let beacon = Beacon::new("devnet".to_string(), 1, 1);
 
-        let signed_entity_type = SignedEntityType::MithrilStakeDistribution(beacon.epoch);
-        repository
-            .create_open_message(beacon.epoch, &signed_entity_type, &ProtocolMessage::new())
-            .await
-            .unwrap();
-        let open_message_result = repository
-            .get_open_message(&signed_entity_type)
-            .await
-            .unwrap();
-        assert!(open_message_result.is_some());
-
-        let signed_entity_type = SignedEntityType::CardanoImmutableFilesFull(beacon.clone());
-        repository
-            .create_open_message(beacon.epoch, &signed_entity_type, &ProtocolMessage::new())
-            .await
-            .unwrap();
-        let open_message_result = repository
-            .get_open_message(&signed_entity_type)
-            .await
-            .unwrap();
-        assert!(open_message_result.is_some());
+        for signed_entity_type in [
+            SignedEntityType::MithrilStakeDistribution(beacon.epoch),
+            SignedEntityType::CardanoImmutableFilesFull(beacon.clone()),
+            SignedEntityType::CardanoTransactions(beacon.clone()),
+        ] {
+            repository
+                .create_open_message(beacon.epoch, &signed_entity_type, &ProtocolMessage::new())
+                .await
+                .unwrap();
+            let open_message_result = repository
+                .get_open_message(&signed_entity_type)
+                .await
+                .unwrap();
+            assert!(open_message_result.is_some());
+        }
     }
 
     #[tokio::test]

mithril-aggregator/src/database/provider/open_message.rs

@@ -35,15 +35,18 @@ use mithril_common::{
     signable_builder::{
         CardanoImmutableFilesFullSignableBuilder, MithrilStakeDistributionSignableBuilder,
     },
-    signable_builder::{MithrilSignableBuilderService, SignableBuilderService},
+    signable_builder::{
+        CardanoTransactionsSignableBuilder, MithrilSignableBuilderService, SignableBuilderService,
+    },
     sqlite::SqliteConnection,
     store::adapter::{MemoryAdapter, SQLiteAdapter, StoreAdapter},
     BeaconProvider, BeaconProviderImpl,
 };
 
 use crate::{
     artifact_builder::{
-        CardanoImmutableFilesFullArtifactBuilder, MithrilStakeDistributionArtifactBuilder,
+        CardanoImmutableFilesFullArtifactBuilder, CardanoTransactionsArtifactBuilder,
+        MithrilStakeDistributionArtifactBuilder,
     },
     configuration::ExecutionEnvironment,
     database::provider::{
@@ -938,9 +941,11 @@ impl DependenciesBuilder {
             &self.configuration.db_directory,
             self.get_logger().await?,
         ));
+        let cardano_transactions_builder = Arc::new(CardanoTransactionsSignableBuilder::default());
         let signable_builder_service = Arc::new(MithrilSignableBuilderService::new(
             mithril_stake_distribution_builder,
             immutable_signable_builder,
+            cardano_transactions_builder,
         ));
 
         Ok(signable_builder_service)
@@ -973,10 +978,13 @@ impl DependenciesBuilder {
                 snapshot_uploader,
                 self.configuration.snapshot_compression_algorithm,
             ));
+        let cardano_transactions_artifact_builder =
+            Arc::new(CardanoTransactionsArtifactBuilder::new());
         let signed_entity_service = Arc::new(MithrilSignedEntityService::new(
             signed_entity_storer,
             mithril_stake_distribution_artifact_builder,
             cardano_immutable_files_full_artifact_builder,
+            cardano_transactions_artifact_builder,
         ));
 
         Ok(signed_entity_service)

mithril-aggregator/src/dependency_injection/builder.rs

@@ -397,6 +397,7 @@ impl CertifierService for MithrilCertifierService {
                 }
             }
             SignedEntityType::CardanoImmutableFilesFull(beacon) => beacon.clone(),
+            SignedEntityType::CardanoTransactions(beacon) => beacon.clone(),
         };
         let metadata = CertificateMetadata::new(
             protocol_version,