Simplify CardanoTransaction signed entity type to Epoch,BlockNumber

Instead of `Epoch,ChainPoint`.

This is because we use this value as the upper bound of the blocks to
import and can't known easily the associated block hash and slot number
needed to constitute a ChainPoint (and we only need them for the lower
bound to allow Pallas to known the starting point).

Author: Alenar

internal/mithril-persistence/src/database/hydrator.rs

@@ -3,8 +3,7 @@
 use serde::Deserialize;
 
 use mithril_common::entities::{
-    BlockNumber, CardanoDbBeacon, ChainPoint, Epoch, SignedEntityType,
-    SignedEntityTypeDiscriminants, SlotNumber,
+    BlockNumber, CardanoDbBeacon, Epoch, SignedEntityType, SignedEntityTypeDiscriminants,
 };
 
 use crate::sqlite::HydrationError;
@@ -75,9 +74,7 @@ impl Hydrator {
                 #[derive(Deserialize)]
                 struct CardanoTransactionsBeacon {
                     epoch: Epoch,
-                    slot_number: SlotNumber,
                     block_number: BlockNumber,
-                    block_hash: String,
                 }
 
                 let beacon: CardanoTransactionsBeacon =
@@ -86,10 +83,7 @@ impl Hydrator {
                         "Invalid Beacon JSON in open_message.beacon: '{beacon_str}'. Error: {e}"
                     ))
                     })?;
-                SignedEntityType::CardanoTransactions(
-                    beacon.epoch,
-                    ChainPoint::new(beacon.slot_number, beacon.block_number, beacon.block_hash),
-                )
+                SignedEntityType::CardanoTransactions(beacon.epoch, beacon.block_number)
             }
         };
 
@@ -99,16 +93,11 @@ impl Hydrator {
 
 #[cfg(test)]
 mod tests {
-    use mithril_common::entities::ChainPoint;
-
     use super::*;
 
     #[test]
     fn hydrate_cardano_transaction_signed_entity_type() {
-        let expected = SignedEntityType::CardanoTransactions(
-            Epoch(35),
-            ChainPoint::new(66, 77, "block-hash-77"),
-        );
+        let expected = SignedEntityType::CardanoTransactions(Epoch(35), 77);
         let signed_entity = Hydrator::hydrate_signed_entity_type(
             SignedEntityTypeDiscriminants::CardanoTransactions.index(),
             &expected.get_json_beacon().unwrap(),

internal/mithril-persistence/src/database/repository/cardano_transaction_repository.rs

@@ -7,8 +7,8 @@ use async_trait::async_trait;
 use mithril_common::cardano_block_scanner::ImmutableLowerBoundFinder;
 use mithril_common::crypto_helper::MKTreeNode;
 use mithril_common::entities::{
-    BlockHash, BlockNumber, BlockRange, CardanoTransaction, ChainPoint, ImmutableFileNumber,
-    SlotNumber, TransactionHash,
+    BlockHash, BlockNumber, BlockRange, CardanoTransaction, ImmutableFileNumber, SlotNumber,
+    TransactionHash,
 };
 use mithril_common::signable_builder::BlockRangeRootRetriever;
 use mithril_common::StdResult;
@@ -262,10 +262,10 @@ impl CardanoTransactionRepository {
 impl BlockRangeRootRetriever for CardanoTransactionRepository {
     async fn retrieve_block_range_roots(
         &self,
-        up_to_beacon: &ChainPoint,
+        up_to_beacon: BlockNumber,
     ) -> StdResult<Box<dyn Iterator<Item = (BlockRange, MKTreeNode)>>> {
         let iterator = self
-            .retrieve_block_range_roots_up_to(up_to_beacon.block_number)
+            .retrieve_block_range_roots_up_to(up_to_beacon)
             .await?
             .collect::<Vec<_>>() // TODO: remove this collect to return the iterator directly
             .into_iter();

mithril-common/src/entities/cardano_chain_point.rs

@@ -16,6 +16,8 @@ pub type SlotNumber = u64;
 /// BlockNumber is the block number of a Cardano transaction.
 pub type BlockNumber = u64;
 
+impl Beacon for BlockNumber {}
+
 /// Hash of a Cardano Block
 pub type BlockHash = String;
 
@@ -69,8 +71,6 @@ impl ChainPoint {
     }
 }
 
-impl Beacon for ChainPoint {}
-
 impl Display for ChainPoint {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(

mithril-common/src/entities/signed_entity.rs

@@ -68,11 +68,12 @@ impl SignedEntity<CardanoTransactionsSnapshot> {
     cfg_test_tools! {
         /// Create a dummy [SignedEntity] for [CardanoTransactionsSnapshot] entity
         pub fn dummy() -> Self {
+            // vvvvv todo: use block_number for snapshot
             let chain_point = ChainPoint::dummy();
 
             SignedEntity {
                 signed_entity_id: "snapshot-id-123".to_string(),
-                signed_entity_type: SignedEntityType::CardanoTransactions(Epoch(5), chain_point.clone()),
+                signed_entity_type: SignedEntityType::CardanoTransactions(Epoch(5), chain_point.block_number),
                 certificate_id: "certificate-hash-123".to_string(),
                 artifact: CardanoTransactionsSnapshot::new("mkroot123".to_string(), chain_point),
                 created_at: DateTime::parse_from_rfc3339("2023-01-19T13:43:05.618857482Z")

mithril-common/src/entities/signed_entity_type.rs

@@ -6,7 +6,7 @@ use sha2::Sha256;
 use std::time::Duration;
 use strum::{AsRefStr, Display, EnumDiscriminants, EnumString};
 
-use super::{CardanoDbBeacon, ChainPoint, Epoch, TimePoint};
+use super::{BlockNumber, CardanoDbBeacon, Epoch, TimePoint};
 
 /// Database representation of the SignedEntityType::MithrilStakeDistribution value
 const ENTITY_TYPE_MITHRIL_STAKE_DISTRIBUTION: usize = 0;
@@ -41,7 +41,7 @@ pub enum SignedEntityType {
     CardanoImmutableFilesFull(CardanoDbBeacon),
 
     /// Cardano Transactions
-    CardanoTransactions(Epoch, ChainPoint),
+    CardanoTransactions(Epoch, BlockNumber),
 }
 
 impl SignedEntityType {
@@ -82,12 +82,10 @@ impl SignedEntityType {
             Self::CardanoStakeDistribution(value) | Self::MithrilStakeDistribution(value) => {
                 serde_json::to_string(value)?
             }
-            Self::CardanoTransactions(epoch, chain_point) => {
+            Self::CardanoTransactions(epoch, block_number) => {
                 let json = serde_json::json!({
                     "epoch": epoch,
-                    "slot_number": chain_point.slot_number,
-                    "block_number": chain_point.block_number,
-                    "block_hash": chain_point.block_hash
+                    "block_number": block_number,
                 });
                 serde_json::to_string(&json)?
             }
@@ -126,7 +124,7 @@ impl SignedEntityType {
                 ))
             }
             SignedEntityTypeDiscriminants::CardanoTransactions => {
-                Self::CardanoTransactions(time_point.epoch, time_point.chain_point.clone())
+                Self::CardanoTransactions(time_point.epoch, time_point.chain_point.block_number)
             }
         }
     }
@@ -142,9 +140,9 @@ impl SignedEntityType {
                 hasher.update(&db_beacon.epoch.to_be_bytes());
                 hasher.update(&db_beacon.immutable_file_number.to_be_bytes());
             }
-            SignedEntityType::CardanoTransactions(epoch, chain_point) => {
+            SignedEntityType::CardanoTransactions(epoch, block_number) => {
                 hasher.update(&epoch.to_be_bytes());
-                chain_point.feed_hash(hasher);
+                hasher.update(&block_number.to_be_bytes())
             }
         }
     }
@@ -223,37 +221,14 @@ mod tests {
             ))
         );
 
-        let reference_hash = hash(SignedEntityType::CardanoTransactions(
-            Epoch(35),
-            ChainPoint::new(66, 77, "block-hash-77"),
-        ));
+        let reference_hash = hash(SignedEntityType::CardanoTransactions(Epoch(35), 77));
         assert_ne!(
             reference_hash,
-            hash(SignedEntityType::CardanoTransactions(
-                Epoch(3),
-                ChainPoint::new(66, 77, "block-hash-77"),
-            ))
+            hash(SignedEntityType::CardanoTransactions(Epoch(3), 77))
         );
         assert_ne!(
             reference_hash,
-            hash(SignedEntityType::CardanoTransactions(
-                Epoch(35),
-                ChainPoint::new(12345, 77, "block-hash-77"),
-            ))
-        );
-        assert_ne!(
-            reference_hash,
-            hash(SignedEntityType::CardanoTransactions(
-                Epoch(35),
-                ChainPoint::new(66, 98765, "block-hash-77"),
-            ))
-        );
-        assert_ne!(
-            reference_hash,
-            hash(SignedEntityType::CardanoTransactions(
-                Epoch(35),
-                ChainPoint::new(66, 77, "other-block-hash"),
-            ))
+            hash(SignedEntityType::CardanoTransactions(Epoch(35), 98765))
         );
     }
 
@@ -264,14 +239,11 @@ mod tests {
             .unwrap();
         assert_same_json!("25", &cardano_stake_distribution_json);
 
-        let cardano_transactions_json = SignedEntityType::CardanoTransactions(
-            Epoch(35),
-            ChainPoint::new(66, 77, "block-hash-77"),
-        )
-        .get_json_beacon()
-        .unwrap();
+        let cardano_transactions_json = SignedEntityType::CardanoTransactions(Epoch(35), 77)
+            .get_json_beacon()
+            .unwrap();
         assert_same_json!(
-            r#"{"epoch":35,"slot_number":66,"block_number":77,"block_hash":"block-hash-77"}"#,
+            r#"{"epoch":35,"block_number":77}"#,
             &cardano_transactions_json
         );
 

mithril-common/src/messages/cardano_transactions_proof.rs

@@ -316,7 +316,7 @@ mod tests {
     #[cfg(feature = "fs")]
     mod fs_only {
         use crate::crypto_helper::{MKMap, MKMapNode};
-        use crate::entities::{BlockNumber, BlockRange, CardanoTransaction, ChainPoint};
+        use crate::entities::{BlockNumber, BlockRange, CardanoTransaction};
         use crate::signable_builder::{
             CardanoTransactionsSignableBuilder, MockBlockRangeRootRetriever,
             MockTransactionsImporter, SignableBuilder,
@@ -404,10 +404,7 @@ mod tests {
                 Logger::root(slog::Discard, slog::o!()),
             );
             cardano_transaction_signable_builder
-                .compute_protocol_message(ChainPoint {
-                    block_number,
-                    ..ChainPoint::dummy()
-                })
+                .compute_protocol_message(block_number)
                 .await
                 .unwrap()
         }

mithril-common/src/signable_builder/cardano_transactions.rs

@@ -6,7 +6,7 @@ use slog::{debug, Logger};
 
 use crate::{
     crypto_helper::{MKMap, MKMapNode, MKTreeNode},
-    entities::{BlockRange, ChainPoint, ProtocolMessage, ProtocolMessagePartKey},
+    entities::{BlockNumber, BlockRange, ProtocolMessage, ProtocolMessagePartKey},
     signable_builder::SignableBuilder,
     StdResult,
 };
@@ -19,7 +19,7 @@ use mockall::automock;
 #[async_trait]
 pub trait TransactionsImporter: Send + Sync {
     /// Returns all transactions up to the given beacon
-    async fn import(&self, up_to_beacon: &ChainPoint) -> StdResult<()>;
+    async fn import(&self, up_to_beacon: BlockNumber) -> StdResult<()>;
 }
 
 /// Block Range Merkle roots retriever
@@ -29,13 +29,13 @@ pub trait BlockRangeRootRetriever: Send + Sync {
     /// Returns a Merkle map of the block ranges roots up to a given beacon
     async fn retrieve_block_range_roots(
         &self,
-        up_to_beacon: &ChainPoint,
+        up_to_beacon: BlockNumber,
     ) -> StdResult<Box<dyn Iterator<Item = (BlockRange, MKTreeNode)>>>;
 
     /// Returns a Merkle map of the block ranges roots up to a given beacon
     async fn compute_merkle_map_from_block_range_roots(
         &self,
-        up_to_beacon: &ChainPoint,
+        up_to_beacon: BlockNumber,
     ) -> StdResult<MKMap<BlockRange, MKMapNode<BlockRange>>> {
         let block_range_roots_iterator = self
             .retrieve_block_range_roots(up_to_beacon)
@@ -71,18 +71,18 @@ impl CardanoTransactionsSignableBuilder {
 }
 
 #[async_trait]
-impl SignableBuilder<ChainPoint> for CardanoTransactionsSignableBuilder {
-    async fn compute_protocol_message(&self, beacon: ChainPoint) -> StdResult<ProtocolMessage> {
+impl SignableBuilder<BlockNumber> for CardanoTransactionsSignableBuilder {
+    async fn compute_protocol_message(&self, beacon: BlockNumber) -> StdResult<ProtocolMessage> {
         debug!(
             self.logger,
-            "Compute protocol message for CardanoTransactions at beacon: {beacon}"
+            "Compute protocol message for CardanoTransactions at block_number: {beacon}"
         );
 
-        self.transaction_importer.import(&beacon).await?;
+        self.transaction_importer.import(beacon).await?;
 
         let mk_root = self
             .block_range_root_retriever
-            .compute_merkle_map_from_block_range_roots(&beacon)
+            .compute_merkle_map_from_block_range_roots(beacon)
             .await?
             .compute_root()?;
 
@@ -93,7 +93,7 @@ impl SignableBuilder<ChainPoint> for CardanoTransactionsSignableBuilder {
         );
         protocol_message.set_message_part(
             ProtocolMessagePartKey::LatestBlockNumber,
-            beacon.block_number.to_string(),
+            beacon.to_string(),
         );
 
         Ok(protocol_message)
@@ -125,10 +125,7 @@ mod tests {
     #[tokio::test]
     async fn test_compute_signable() {
         // Arrange
-        let beacon = ChainPoint {
-            block_number: 1453,
-            ..ChainPoint::dummy()
-        };
+        let block_number = 1453;
         let transactions = CardanoTransactionsBuilder::new().build_transactions(3);
         let mk_map = compute_mk_map_from_transactions(transactions.clone());
         let mut transaction_importer = MockTransactionsImporter::new();
@@ -149,7 +146,7 @@ mod tests {
 
         // Action
         let signable = cardano_transactions_signable_builder
-            .compute_protocol_message(beacon.clone())
+            .compute_protocol_message(block_number)
             .await
             .unwrap();
 
@@ -161,14 +158,14 @@ mod tests {
         );
         signable_expected.set_message_part(
             ProtocolMessagePartKey::LatestBlockNumber,
-            format!("{}", beacon.block_number),
+            format!("{}", block_number),
         );
         assert_eq!(signable_expected, signable);
     }
 
     #[tokio::test]
     async fn test_compute_signable_with_no_block_range_root_return_error() {
-        let beacon = ChainPoint::dummy();
+        let block_number = 50;
         let mut transaction_importer = MockTransactionsImporter::new();
         transaction_importer.expect_import().return_once(|_| Ok(()));
         let mut block_range_root_retriever = MockBlockRangeRootRetriever::new();
@@ -182,7 +179,7 @@ mod tests {
         );
 
         let result = cardano_transactions_signable_builder
-            .compute_protocol_message(beacon.clone())
+            .compute_protocol_message(block_number)
             .await;
 
         assert!(result.is_err());