Make aggregator services & cardano transaction artifact builder use ChainPoint

Note: not compiling, we still need to update the
`CardanoTransactionsSnapshot`.

Author: Alenar

mithril-aggregator/src/artifact_builder/cardano_transactions.rs

@@ -1,19 +1,19 @@
 use std::sync::Arc;
 
-use async_trait::async_trait;
-
-use crate::services::ProverService;
-
-use super::ArtifactBuilder;
 use anyhow::{anyhow, Context};
+use async_trait::async_trait;
 use mithril_common::{
     entities::{
-        CardanoDbBeacon, CardanoTransactionsSnapshot, Certificate, ProtocolMessagePartKey,
+        CardanoTransactionsSnapshot, Certificate, ChainPoint, ProtocolMessagePartKey,
         SignedEntityType,
     },
     StdResult,
 };
 
+use crate::services::ProverService;
+
+use super::ArtifactBuilder;
+
 /// A [CardanoTransactionsArtifact] builder
 pub struct CardanoTransactionsArtifactBuilder {
     prover_service: Arc<dyn ProverService>,
@@ -27,12 +27,12 @@ impl CardanoTransactionsArtifactBuilder {
 }
 
 #[async_trait]
-impl ArtifactBuilder<CardanoDbBeacon, CardanoTransactionsSnapshot>
+impl ArtifactBuilder<ChainPoint, CardanoTransactionsSnapshot>
     for CardanoTransactionsArtifactBuilder
 {
     async fn compute_artifact(
         &self,
-        beacon: CardanoDbBeacon,
+        beacon: ChainPoint,
         certificate: &Certificate,
     ) -> StdResult<CardanoTransactionsSnapshot> {
         let merkle_root = certificate
@@ -44,15 +44,16 @@ impl ArtifactBuilder<CardanoDbBeacon, CardanoTransactionsSnapshot>
             .with_context(|| {
                 format!(
                     "Can not compute CardanoTransactionsCommitment artifact for signed_entity: {:?}",
-                    SignedEntityType::CardanoTransactions(beacon.clone())
+                    SignedEntityType::CardanoTransactions(certificate.epoch, beacon.clone())
                 )
             })?;
         self.prover_service.compute_cache(&beacon).await?;
 
-        Ok(CardanoTransactionsSnapshot::new(
-            merkle_root.to_string(),
-            beacon,
-        ))
+        todo!("vvvvv - update the artifact");
+        // Ok(CardanoTransactionsSnapshot::new(
+        //     merkle_root.to_string(),
+        //     beacon,
+        // ))
     }
 }
 
@@ -77,7 +78,7 @@ mod tests {
             certificate
         };
 
-        let beacon = certificate.as_cardano_db_beacon();
+        let beacon = ChainPoint::dummy();
         let mut mock_prover = MockProverService::new();
         mock_prover.expect_compute_cache().returning(|_| Ok(()));
         let cardano_transaction_artifact_builder =
@@ -86,8 +87,9 @@ mod tests {
             .compute_artifact(beacon.clone(), &certificate)
             .await
             .unwrap();
-        let artifact_expected = CardanoTransactionsSnapshot::new("merkleroot".to_string(), beacon);
-        assert_eq!(artifact_expected, artifact);
+        todo!("vvvvv - update the artifact");
+        // let artifact_expected = CardanoTransactionsSnapshot::new("merkleroot".to_string(), beacon);
+        // assert_eq!(artifact_expected, artifact);
     }
 
     #[tokio::test]
@@ -104,7 +106,7 @@ mod tests {
         let cardano_transaction_artifact_builder =
             CardanoTransactionsArtifactBuilder::new(Arc::new(mock_prover));
         cardano_transaction_artifact_builder
-            .compute_artifact(CardanoDbBeacon::default(), &certificate)
+            .compute_artifact(ChainPoint::dummy(), &certificate)
             .await
             .expect_err("The artifact building must fail since there is no CardanoTransactionsMerkleRoot part in its message.");
     }

mithril-aggregator/src/services/prover.rs

@@ -10,7 +10,7 @@ use std::{
 use mithril_common::{
     crypto_helper::{MKMap, MKMapNode, MKTree},
     entities::{
-        BlockRange, CardanoDbBeacon, CardanoTransaction, CardanoTransactionsSetProof,
+        BlockRange, CardanoDbBeacon, CardanoTransaction, CardanoTransactionsSetProof, ChainPoint,
         TransactionHash,
     },
     resource_pool::ResourcePool,
@@ -25,12 +25,12 @@ pub trait ProverService: Sync + Send {
     /// Compute the cryptographic proofs for the given transactions
     async fn compute_transactions_proofs(
         &self,
-        up_to: &CardanoDbBeacon,
+        up_to: &ChainPoint,
         transaction_hashes: &[TransactionHash],
     ) -> StdResult<Vec<CardanoTransactionsSetProof>>;
 
     /// Compute the cache
-    async fn compute_cache(&self, up_to: &CardanoDbBeacon) -> StdResult<()>;
+    async fn compute_cache(&self, up_to: &ChainPoint) -> StdResult<()>;
 }
 
 /// Transactions retriever
@@ -118,7 +118,7 @@ impl MithrilProverService {
 impl ProverService for MithrilProverService {
     async fn compute_transactions_proofs(
         &self,
-        _up_to: &CardanoDbBeacon,
+        _up_to: &ChainPoint,
         transaction_hashes: &[TransactionHash],
     ) -> StdResult<Vec<CardanoTransactionsSetProof>> {
         // 1 - Compute the set of block ranges with transactions to prove
@@ -164,15 +164,15 @@ impl ProverService for MithrilProverService {
         }
     }
 
-    async fn compute_cache(&self, up_to: &CardanoDbBeacon) -> StdResult<()> {
+    async fn compute_cache(&self, up_to: &ChainPoint) -> StdResult<()> {
         let pool_size = self.mk_map_pool.size();
         info!(
             self.logger,
             "Prover starts computing the Merkle map pool resource of size {pool_size}"
         );
         let mk_map_cache = self
             .block_range_root_retriever
-            .compute_merkle_map_from_block_range_roots(up_to.immutable_file_number)
+            .compute_merkle_map_from_block_range_roots(up_to)
             .await?;
         let discriminant_new = self.mk_map_pool.discriminant()? + 1;
         self.mk_map_pool.set_discriminant(discriminant_new)?;
@@ -201,7 +201,7 @@ impl ProverService for MithrilProverService {
 mod tests {
     use anyhow::anyhow;
     use mithril_common::crypto_helper::{MKMap, MKMapNode, MKTreeNode};
-    use mithril_common::entities::{CardanoTransaction, ImmutableFileNumber};
+    use mithril_common::entities::CardanoTransaction;
     use mithril_common::test_utils::CardanoTransactionsBuilder;
     use mockall::mock;
     use mockall::predicate::eq;
@@ -215,12 +215,12 @@ mod tests {
         impl BlockRangeRootRetriever for BlockRangeRootRetrieverImpl {
             async fn retrieve_block_range_roots(
                 &self,
-                up_to_beacon: ImmutableFileNumber,
+                up_to_beacon: &ChainPoint,
             ) -> StdResult<Box<dyn Iterator<Item = (BlockRange, MKTreeNode)>>>;
 
             async fn compute_merkle_map_from_block_range_roots(
                 &self,
-                up_to_beacon: ImmutableFileNumber,
+                up_to_beacon: &ChainPoint,
             ) -> StdResult<MKMap<BlockRange, MKMapNode<BlockRange>>>;
         }
     }
@@ -296,21 +296,21 @@ mod tests {
             .unwrap()
         }
 
-        pub fn compute_beacon_from_transactions(
-            transactions: &[CardanoTransaction],
-        ) -> CardanoDbBeacon {
-            CardanoDbBeacon {
-                immutable_file_number: transactions.last().unwrap().immutable_file_number,
-                ..CardanoDbBeacon::default()
-            }
+        pub fn compute_beacon_from_transactions(transactions: &[CardanoTransaction]) -> ChainPoint {
+            let max_transaction = transactions.iter().max_by_key(|t| t.block_number).unwrap();
+            ChainPoint::new(
+                max_transaction.slot_number,
+                max_transaction.block_number,
+                max_transaction.block_hash.clone(),
+            )
         }
 
         pub struct TestData {
             pub transaction_hashes_to_prove: Vec<TransactionHash>,
             pub block_ranges_map: BTreeMap<BlockRange, Vec<CardanoTransaction>>,
             pub block_ranges_to_prove: Vec<BlockRange>,
             pub all_transactions_in_block_ranges_to_prove: Vec<CardanoTransaction>,
-            pub beacon: CardanoDbBeacon,
+            pub beacon: ChainPoint,
         }
 
         pub fn build_test_data(

mithril-aggregator/src/services/signed_entity.rs

@@ -10,8 +10,9 @@ use std::sync::Arc;
 
 use mithril_common::{
     entities::{
-        CardanoDbBeacon, CardanoTransactionsSnapshot, Certificate, Epoch, MithrilStakeDistribution,
-        SignedEntity, SignedEntityType, SignedEntityTypeDiscriminants, Snapshot,
+        CardanoDbBeacon, CardanoTransactionsSnapshot, Certificate, ChainPoint, Epoch,
+        MithrilStakeDistribution, SignedEntity, SignedEntityType, SignedEntityTypeDiscriminants,
+        Snapshot,
     },
     signable_builder::Artifact,
     StdResult,
@@ -75,7 +76,7 @@ pub struct MithrilSignedEntityService {
     cardano_immutable_files_full_artifact_builder:
         Arc<dyn ArtifactBuilder<CardanoDbBeacon, Snapshot>>,
     cardano_transactions_artifact_builder:
-        Arc<dyn ArtifactBuilder<CardanoDbBeacon, CardanoTransactionsSnapshot>>,
+        Arc<dyn ArtifactBuilder<ChainPoint, CardanoTransactionsSnapshot>>,
 }
 
 impl MithrilSignedEntityService {
@@ -89,7 +90,7 @@ impl MithrilSignedEntityService {
             dyn ArtifactBuilder<CardanoDbBeacon, Snapshot>,
         >,
         cardano_transactions_artifact_builder: Arc<
-            dyn ArtifactBuilder<CardanoDbBeacon, CardanoTransactionsSnapshot>,
+            dyn ArtifactBuilder<ChainPoint, CardanoTransactionsSnapshot>,
         >,
     ) -> Self {
         Self {
@@ -128,13 +129,13 @@ impl MithrilSignedEntityService {
                     })?,
             )),
             SignedEntityType::CardanoStakeDistribution(_) => todo!(),
-            SignedEntityType::CardanoTransactions(beacon) => Ok(Arc::new(
+            SignedEntityType::CardanoTransactions(epoch, chain_point) => Ok(Arc::new(
                 self.cardano_transactions_artifact_builder
-                    .compute_artifact(beacon.clone(), certificate)
+                    .compute_artifact(chain_point.clone(), certificate)
                     .await
                     .with_context(|| {
                         format!(
-                            "Signed Entity Service can not compute artifact for entity type: '{signed_entity_type}'"
+                            "Signed Entity Service can not compute artifact for entity type: '{chain_point}'"
                         )
                     })?,
             )),
@@ -337,7 +338,7 @@ mod tests {
         mock_cardano_immutable_files_full_artifact_builder:
             MockArtifactBuilder<CardanoDbBeacon, Snapshot>,
         mock_cardano_transactions_artifact_builder:
-            MockArtifactBuilder<CardanoDbBeacon, CardanoTransactionsSnapshot>,
+            MockArtifactBuilder<ChainPoint, CardanoTransactionsSnapshot>,
     }
 
     impl MockDependencyInjector {
@@ -353,7 +354,7 @@ mod tests {
                     Snapshot,
                 >::new(),
                 mock_cardano_transactions_artifact_builder: MockArtifactBuilder::<
-                    CardanoDbBeacon,
+                    ChainPoint,
                     CardanoTransactionsSnapshot,
                 >::new(),
             }
@@ -443,6 +444,7 @@ mod tests {
     async fn build_cardano_transactions_snapshot_artifact_when_given_cardano_transactions_type() {
         let mut mock_container = MockDependencyInjector::new();
 
+        // vvvvv - when updating to chain point make sure that the same beacon is used in the expected
         let expected =
             CardanoTransactionsSnapshot::new("merkle_root".to_string(), CardanoDbBeacon::default());
 
@@ -460,7 +462,8 @@ mod tests {
         let artifact_builder_service = mock_container.build_artifact_builder_service();
 
         let certificate = fake_data::certificate("hash".to_string());
-        let signed_entity_type = SignedEntityType::CardanoTransactions(CardanoDbBeacon::default());
+        let signed_entity_type =
+            SignedEntityType::CardanoTransactions(Epoch(1), ChainPoint::dummy());
         let artifact = artifact_builder_service
             .compute_artifact(signed_entity_type.clone(), &certificate)
             .await
@@ -472,7 +475,7 @@ mod tests {
     #[tokio::test]
     async fn should_store_the_artifact_when_creating_artifact_for_cardano_transactions() {
         generic_test_that_the_artifact_is_stored(
-            SignedEntityType::CardanoTransactions(CardanoDbBeacon::default()),
+            SignedEntityType::CardanoTransactions(Epoch(1), ChainPoint::dummy()),
             CardanoTransactionsSnapshot::new("merkle_root".to_string(), CardanoDbBeacon::default()),
             &|mock_injector| &mut mock_injector.mock_cardano_transactions_artifact_builder,
         )

mithril-aggregator/tests/test_extensions/aggregator_observer.rs

@@ -95,9 +95,9 @@ impl AggregatorObserver {
             SignedEntityTypeDiscriminants::CardanoImmutableFilesFull => {
                 Ok(SignedEntityType::CardanoImmutableFilesFull(beacon))
             }
-            SignedEntityTypeDiscriminants::CardanoTransactions => {
-                Ok(SignedEntityType::CardanoTransactions(beacon))
-            }
+            SignedEntityTypeDiscriminants::CardanoTransactions => Ok(
+                SignedEntityType::CardanoTransactions(time_point.epoch, time_point.chain_point),
+            ),
         }
     }
 }