feat: implement artifact builder for 'CardanoTransactions'

Author: jpraynaud

mithril-aggregator/src/artifact_builder/cardano_transactions.rs

@@ -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/mod.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/dependency_injection/builder.rs

@@ -45,7 +45,8 @@ use mithril_common::{
 
 use crate::{
     artifact_builder::{
-        CardanoImmutableFilesFullArtifactBuilder, MithrilStakeDistributionArtifactBuilder,
+        CardanoImmutableFilesFullArtifactBuilder, CardanoTransactionsArtifactBuilder,
+        MithrilStakeDistributionArtifactBuilder,
     },
     configuration::ExecutionEnvironment,
     database::provider::{
@@ -977,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/services/signed_entity.rs

@@ -10,8 +10,8 @@ use std::sync::Arc;
 
 use mithril_common::{
     entities::{
-        Beacon, Certificate, Epoch, MithrilStakeDistribution, SignedEntity, SignedEntityType,
-        SignedEntityTypeDiscriminants, Snapshot,
+        Beacon, CardanoTransactionsCommitment, Certificate, Epoch, MithrilStakeDistribution,
+        SignedEntity, SignedEntityType, SignedEntityTypeDiscriminants, Snapshot,
     },
     signable_builder::Artifact,
     StdResult,
@@ -68,6 +68,8 @@ pub struct MithrilSignedEntityService {
     mithril_stake_distribution_artifact_builder:
         Arc<dyn ArtifactBuilder<Epoch, MithrilStakeDistribution>>,
     cardano_immutable_files_full_artifact_builder: Arc<dyn ArtifactBuilder<Beacon, Snapshot>>,
+    cardano_transactions_artifact_builder:
+        Arc<dyn ArtifactBuilder<Beacon, CardanoTransactionsCommitment>>,
 }
 
 impl MithrilSignedEntityService {
@@ -78,11 +80,15 @@ impl MithrilSignedEntityService {
             dyn ArtifactBuilder<Epoch, MithrilStakeDistribution>,
         >,
         cardano_immutable_files_full_artifact_builder: Arc<dyn ArtifactBuilder<Beacon, Snapshot>>,
+        cardano_transactions_artifact_builder: Arc<
+            dyn ArtifactBuilder<Beacon, CardanoTransactionsCommitment>,
+        >,
     ) -> Self {
         Self {
             signed_entity_storer,
             mithril_stake_distribution_artifact_builder,
             cardano_immutable_files_full_artifact_builder,
+            cardano_transactions_artifact_builder,
         }
     }
 
@@ -114,7 +120,16 @@ impl MithrilSignedEntityService {
                     })?,
             ))),
             SignedEntityType::CardanoStakeDistribution(_) => todo!(),
-            SignedEntityType::CardanoTransactions(_) => Ok(None),
+            SignedEntityType::CardanoTransactions(beacon) => Ok(Some(Arc::new(
+                self.cardano_transactions_artifact_builder
+                    .compute_artifact(beacon.clone(), certificate)
+                    .await
+                    .with_context(|| {
+                        format!(
+                            "Signed Entity Service can not compute artifact for entity type: '{signed_entity_type}'"
+                        )
+                    })?,
+            ))),
         }
     }
 }
@@ -302,11 +317,14 @@ mod tests {
 
         let mock_cardano_immutable_files_full_artifact_builder =
             MockArtifactBuilder::<Beacon, Snapshot>::new();
+        let mock_cardano_transactions_artifact_builder =
+            MockArtifactBuilder::<Beacon, CardanoTransactionsCommitment>::new();
 
         let artifact_builder_service = MithrilSignedEntityService::new(
             Arc::new(mock_signed_entity_storer),
             Arc::new(mock_mithril_stake_distribution_artifact_builder),
             Arc::new(mock_cardano_immutable_files_full_artifact_builder),
+            Arc::new(mock_cardano_transactions_artifact_builder),
         );
         let certificate = fake_data::certificate("hash".to_string());
 
@@ -355,11 +373,14 @@ mod tests {
             .expect_compute_artifact()
             .times(1)
             .return_once(move |_, _| Ok(snapshot_expected_clone));
+        let mock_cardano_transactions_artifact_builder =
+            MockArtifactBuilder::<Beacon, CardanoTransactionsCommitment>::new();
 
         let artifact_builder_service = MithrilSignedEntityService::new(
             Arc::new(mock_signed_entity_storer),
             Arc::new(mock_mithril_stake_distribution_artifact_builder),
             Arc::new(mock_cardano_immutable_files_full_artifact_builder),
+            Arc::new(mock_cardano_transactions_artifact_builder),
         );
         let certificate = fake_data::certificate("hash".to_string());
 
@@ -392,11 +413,14 @@ mod tests {
             MockArtifactBuilder::<Epoch, MithrilStakeDistribution>::new();
         let mock_cardano_immutable_files_full_artifact_builder =
             MockArtifactBuilder::<Beacon, Snapshot>::new();
+        let mock_cardano_transactions_artifact_builder =
+            MockArtifactBuilder::<Beacon, CardanoTransactionsCommitment>::new();
 
         let artifact_builder_service = MithrilSignedEntityService::new(
             Arc::new(mock_signed_entity_storer),
             Arc::new(mock_mithril_stake_distribution_artifact_builder),
             Arc::new(mock_cardano_immutable_files_full_artifact_builder),
+            Arc::new(mock_cardano_transactions_artifact_builder),
         );
 
         let certificate = fake_data::certificate("hash".to_string());

mithril-common/src/entities/cardano_transactions_commitment.rs

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+
+use crate::signable_builder::Artifact;
+
+/// Commitment of a set of Cardano transactions
+#[derive(Clone, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct CardanoTransactionsCommitment {
+    merkle_root: String,
+}
+
+impl CardanoTransactionsCommitment {
+    /// Creates a new [CardanoTransactionsCommitment]
+    pub fn new(merkle_root: String) -> Self {
+        Self { merkle_root }
+    }
+}
+
+#[typetag::serde]
+impl Artifact for CardanoTransactionsCommitment {
+    fn get_id(&self) -> String {
+        self.merkle_root.clone()
+    }
+}

mithril-common/src/entities/mod.rs

@@ -2,6 +2,7 @@
 
 mod beacon;
 mod cardano_network;
+mod cardano_transactions_commitment;
 mod certificate;
 mod certificate_metadata;
 mod certificate_pending;
@@ -20,6 +21,7 @@ mod type_alias;
 
 pub use beacon::{Beacon, BeaconComparison, BeaconComparisonError};
 pub use cardano_network::CardanoNetwork;
+pub use cardano_transactions_commitment::CardanoTransactionsCommitment;
 pub use certificate::{Certificate, CertificateSignature};
 pub use certificate_metadata::{CertificateMetadata, StakeDistributionParty};
 pub use certificate_pending::CertificatePending;

mithril-common/src/entities/signed_entity.rs

@@ -1,6 +1,6 @@
 #[cfg(feature = "test_tools")]
 use super::{Beacon, Epoch};
-use super::{MithrilStakeDistribution, SignedEntityType, Snapshot};
+use super::{CardanoTransactionsCommitment, MithrilStakeDistribution, SignedEntityType, Snapshot};
 use crate::signable_builder::Artifact;
 #[cfg(feature = "test_tools")]
 use crate::test_utils::fake_data;
@@ -61,3 +61,20 @@ impl SignedEntity<MithrilStakeDistribution> {
         }
     }
 }
+
+impl SignedEntity<CardanoTransactionsCommitment> {
+    cfg_test_tools! {
+        /// Create a dummy [SignedEntity] for [CardanoTransactionsCommitment] entity
+        pub fn dummy() -> Self {
+            SignedEntity {
+                signed_entity_id: "snapshot-id-123".to_string(),
+                signed_entity_type: SignedEntityType::CardanoTransactions(Beacon::default()),
+                certificate_id: "certificate-hash-123".to_string(),
+                artifact: CardanoTransactionsCommitment::new("mkroot123".to_string()),
+                created_at: DateTime::parse_from_rfc3339("2023-01-19T13:43:05.618857482Z")
+                    .unwrap()
+                    .with_timezone(&Utc),
+            }
+        }
+    }
+}