Make CardanoTransactionSnapshot entity use a ChainPoint beacon

Author: Alenar

mithril-common/src/entities/cardano_chain_point.rs

@@ -2,6 +2,7 @@ use std::cmp::Ordering;
 use std::fmt::{Display, Formatter};
 
 use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
 
 cfg_fs! {
     use pallas_network::miniprotocols::{chainsync::Tip, Point};
@@ -50,6 +51,12 @@ impl ChainPoint {
         self.slot_number == 0 && self.block_number == 0 && self.block_hash.is_empty()
     }
 
+    pub(crate) fn feed_hash(&self, hasher: &mut Sha256) {
+        hasher.update(self.slot_number.to_be_bytes());
+        hasher.update(self.block_number.to_be_bytes());
+        hasher.update(self.block_hash.as_bytes());
+    }
+
     cfg_test_tools! {
         /// Create a dummy ChainPoint
         pub fn dummy() -> Self {
@@ -192,4 +199,44 @@ mod tests {
 
         assert_eq!(Ordering::Less, chain_point1.cmp(&chain_point2));
     }
+
+    #[test]
+    fn feed_hash_use_all_properties() {
+        fn hash(chain_point: &ChainPoint) -> String {
+            let mut hasher = Sha256::new();
+            chain_point.feed_hash(&mut hasher);
+            hex::encode(hasher.finalize())
+        }
+
+        let chain_point = ChainPoint {
+            slot_number: 5,
+            block_number: 10,
+            block_hash: "block_hash".to_string(),
+        };
+        let reference_hash = hash(&chain_point);
+
+        assert_ne!(
+            reference_hash,
+            hash(&ChainPoint {
+                slot_number: 10000,
+                ..chain_point.clone()
+            })
+        );
+
+        assert_ne!(
+            reference_hash,
+            hash(&ChainPoint {
+                block_number: 10000,
+                ..chain_point.clone()
+            })
+        );
+
+        assert_ne!(
+            reference_hash,
+            hash(&ChainPoint {
+                block_hash: "other_block_hash".to_string(),
+                ..chain_point.clone()
+            })
+        );
+    }
 }

mithril-common/src/entities/cardano_transactions_snapshot.rs

@@ -1,11 +1,12 @@
-use crate::signable_builder::Artifact;
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 
-use super::CardanoDbBeacon;
+use crate::signable_builder::Artifact;
+
+use super::ChainPoint;
 
 /// Snapshot of a set of Cardano transactions
-#[derive(Clone, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CardanoTransactionsSnapshot {
     /// Hash of the Cardano transactions set
     pub hash: String,
@@ -14,15 +15,15 @@ pub struct CardanoTransactionsSnapshot {
     pub merkle_root: String,
 
     /// Beacon of the Cardano transactions set
-    pub beacon: CardanoDbBeacon,
+    pub chain_point: ChainPoint,
 }
 
 impl CardanoTransactionsSnapshot {
     /// Creates a new [CardanoTransactionsSnapshot]
-    pub fn new(merkle_root: String, beacon: CardanoDbBeacon) -> Self {
+    pub fn new(merkle_root: String, chain_point: ChainPoint) -> Self {
         let mut cardano_transactions_snapshot = Self {
             merkle_root,
-            beacon,
+            chain_point,
             hash: "".to_string(),
         };
         cardano_transactions_snapshot.hash = cardano_transactions_snapshot.compute_hash();
@@ -33,7 +34,7 @@ impl CardanoTransactionsSnapshot {
     fn compute_hash(&self) -> String {
         let mut hasher = Sha256::new();
         hasher.update(self.merkle_root.clone().as_bytes());
-        hasher.update(self.beacon.compute_hash().as_bytes());
+        self.chain_point.feed_hash(&mut hasher);
 
         hex::encode(hasher.finalize())
     }
@@ -52,18 +53,24 @@ mod tests {
 
     #[test]
     fn test_cardano_transactions_snapshot_compute_hash() {
-        let hash_expected = "66a1d7aa3995e9a0dce15fae3f6b91640824ecd1f81991df5ce4ddff62b34df4";
+        let hash_expected = "701a0fec8e7c6afca90f3f94b1f912ba6e179d891023465858abcad7db108730";
 
         assert_eq!(
             hash_expected,
-            CardanoTransactionsSnapshot::new("mk-root-123".to_string(), CardanoDbBeacon::default())
-                .compute_hash()
+            CardanoTransactionsSnapshot::new(
+                "mk-root-123".to_string(),
+                ChainPoint::new(100, 50, "block_hash-50")
+            )
+            .compute_hash()
         );
 
         assert_ne!(
             hash_expected,
-            CardanoTransactionsSnapshot::new("mk-root-456".to_string(), CardanoDbBeacon::default())
-                .compute_hash()
+            CardanoTransactionsSnapshot::new(
+                "mk-root-456".to_string(),
+                ChainPoint::new(100, 50, "block_hash-50")
+            )
+            .compute_hash()
         );
     }
 }

mithril-common/src/entities/signed_entity.rs

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

mithril-common/src/entities/signed_entity_type.rs

@@ -144,9 +144,7 @@ impl SignedEntityType {
             }
             SignedEntityType::CardanoTransactions(epoch, chain_point) => {
                 hasher.update(&epoch.to_be_bytes());
-                hasher.update(&chain_point.slot_number.to_be_bytes());
-                hasher.update(&chain_point.block_number.to_be_bytes());
-                hasher.update(chain_point.block_hash.as_bytes());
+                chain_point.feed_hash(hasher);
             }
         }
     }

mithril-common/src/test_utils/fake_data.rs

@@ -245,9 +245,10 @@ pub fn cardano_transactions_snapshot(total: u64) -> Vec<entities::CardanoTransac
         .map(|idx| {
             entities::CardanoTransactionsSnapshot::new(
                 format!("merkleroot-{idx}"),
-                entities::CardanoDbBeacon {
-                    immutable_file_number: idx,
-                    ..beacon()
+                entities::ChainPoint {
+                    block_number: idx,
+                    block_hash: format!("block_hash-{idx}"),
+                    ..chain_point()
                 },
             )
         })