Replace BlockNumber alias with dedicated structure

internal/mithril-persistence/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-persistence"
-version = "0.2.18"
+version = "0.2.19"
 description = "Common types, interfaces, and utilities to persist data for Mithril nodes."
 authors = { workspace = true }
 edition = { workspace = true }

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

@@ -97,7 +97,7 @@ mod tests {
 
     #[test]
     fn hydrate_cardano_transaction_signed_entity_type() {
-        let expected = SignedEntityType::CardanoTransactions(Epoch(35), 77);
+        let expected = SignedEntityType::CardanoTransactions(Epoch(35), BlockNumber(77));
         let signed_entity = Hydrator::hydrate_signed_entity_type(
             SignedEntityTypeDiscriminants::CardanoTransactions.index(),
             &expected.get_json_beacon().unwrap(),

internal/mithril-persistence/src/database/query/block_range_root/delete_block_range_root.rs

@@ -82,21 +82,24 @@ mod tests {
 
         let cursor = connection
             .fetch(
-                DeleteBlockRangeRootQuery::contains_or_above_block_number_threshold(100).unwrap(),
+                DeleteBlockRangeRootQuery::contains_or_above_block_number_threshold(BlockNumber(
+                    100,
+                ))
+                .unwrap(),
             )
             .expect("pruning shouldn't crash without block range root stored");
         assert_eq!(0, cursor.count());
     }
 
     #[test]
     fn test_prune_all_data_if_given_block_number_is_lower_than_stored_number_of_block() {
-        parameterized_test_prune_block_range(0, block_range_root_dataset().len());
+        parameterized_test_prune_block_range(BlockNumber(0), block_range_root_dataset().len());
     }
 
     #[test]
     fn test_prune_keep_all_block_range_root_if_given_number_of_block_is_greater_than_the_highest_one(
     ) {
-        parameterized_test_prune_block_range(100_000, 0);
+        parameterized_test_prune_block_range(BlockNumber(100_000), 0);
     }
 
     #[test]

internal/mithril-persistence/src/database/query/block_range_root/get_block_range_root.rs

@@ -19,7 +19,10 @@ impl GetBlockRangeRootQuery {
 
     pub fn contains_or_below_block_number(block_number: BlockNumber) -> Self {
         Self {
-            condition: WhereCondition::new("start < ?*", vec![Value::Integer(block_number as i64)]),
+            condition: WhereCondition::new(
+                "start < ?*",
+                vec![Value::Integer(*block_number as i64)],
+            ),
         }
     }
 
@@ -60,15 +63,15 @@ mod tests {
     fn block_range_root_dataset() -> Vec<BlockRangeRootRecord> {
         [
             (
-                BlockRange::from_block_number(15),
+                BlockRange::from_block_number(BlockNumber(15)),
                 MKTreeNode::from_hex("AAAA").unwrap(),
             ),
             (
-                BlockRange::from_block_number(30),
+                BlockRange::from_block_number(BlockNumber(30)),
                 MKTreeNode::from_hex("BBBB").unwrap(),
             ),
             (
-                BlockRange::from_block_number(45),
+                BlockRange::from_block_number(BlockNumber(45)),
                 MKTreeNode::from_hex("CCCC").unwrap(),
             ),
         ]
@@ -82,7 +85,9 @@ mod tests {
         let connection = cardano_tx_db_connection().unwrap();
 
         let cursor: Vec<BlockRangeRootRecord> = connection
-            .fetch_collect(GetBlockRangeRootQuery::contains_or_below_block_number(100))
+            .fetch_collect(GetBlockRangeRootQuery::contains_or_below_block_number(
+                BlockNumber(100),
+            ))
             .unwrap();
         assert_eq!(Vec::<BlockRangeRootRecord>::new(), cursor);
     }
@@ -95,7 +100,7 @@ mod tests {
 
         let cursor: Vec<BlockRangeRootRecord> = connection
             .fetch_collect(GetBlockRangeRootQuery::contains_or_below_block_number(
-                10_000,
+                BlockNumber(10_000),
             ))
             .unwrap();
 
@@ -109,7 +114,9 @@ mod tests {
         insert_block_range_roots(&connection, dataset.clone());
 
         let cursor: Vec<BlockRangeRootRecord> = connection
-            .fetch_collect(GetBlockRangeRootQuery::contains_or_below_block_number(44))
+            .fetch_collect(GetBlockRangeRootQuery::contains_or_below_block_number(
+                BlockNumber(44),
+            ))
             .unwrap();
 
         assert_eq!(&dataset[0..2], &cursor);
@@ -122,7 +129,9 @@ mod tests {
         insert_block_range_roots(&connection, dataset.clone());
 
         let cursor: Vec<BlockRangeRootRecord> = connection
-            .fetch_collect(GetBlockRangeRootQuery::contains_or_below_block_number(45))
+            .fetch_collect(GetBlockRangeRootQuery::contains_or_below_block_number(
+                BlockNumber(45),
+            ))
             .unwrap();
 
         assert_eq!(&dataset[0..2], &cursor);
@@ -135,7 +144,9 @@ mod tests {
         insert_block_range_roots(&connection, dataset.clone());
 
         let cursor: Vec<BlockRangeRootRecord> = connection
-            .fetch_collect(GetBlockRangeRootQuery::contains_or_below_block_number(46))
+            .fetch_collect(GetBlockRangeRootQuery::contains_or_below_block_number(
+                BlockNumber(46),
+            ))
             .unwrap();
 
         assert_eq!(dataset, cursor);

internal/mithril-persistence/src/database/query/cardano_transaction/delete_cardano_transaction.rs

@@ -67,12 +67,12 @@ mod tests {
 
     fn test_transaction_set() -> Vec<CardanoTransactionRecord> {
         vec![
-            CardanoTransactionRecord::new("tx-hash-0", 10, 50, "block-hash-10"),
-            CardanoTransactionRecord::new("tx-hash-1", 10, 51, "block-hash-10"),
-            CardanoTransactionRecord::new("tx-hash-2", 11, 52, "block-hash-11"),
-            CardanoTransactionRecord::new("tx-hash-3", 11, 53, "block-hash-11"),
-            CardanoTransactionRecord::new("tx-hash-4", 12, 54, "block-hash-12"),
-            CardanoTransactionRecord::new("tx-hash-5", 12, 55, "block-hash-12"),
+            CardanoTransactionRecord::new("tx-hash-0", BlockNumber(10), 50, "block-hash-10"),
+            CardanoTransactionRecord::new("tx-hash-1", BlockNumber(10), 51, "block-hash-10"),
+            CardanoTransactionRecord::new("tx-hash-2", BlockNumber(11), 52, "block-hash-11"),
+            CardanoTransactionRecord::new("tx-hash-3", BlockNumber(11), 53, "block-hash-11"),
+            CardanoTransactionRecord::new("tx-hash-4", BlockNumber(12), 54, "block-hash-12"),
+            CardanoTransactionRecord::new("tx-hash-5", BlockNumber(12), 55, "block-hash-12"),
         ]
     }
 
@@ -84,7 +84,10 @@ mod tests {
             let connection = cardano_tx_db_connection().unwrap();
 
             let cursor = connection
-                .fetch(DeleteCardanoTransactionQuery::below_block_number_threshold(100).unwrap())
+                .fetch(
+                    DeleteCardanoTransactionQuery::below_block_number_threshold(BlockNumber(100))
+                        .unwrap(),
+                )
                 .expect("pruning shouldn't crash without transactions stored");
             assert_eq!(0, cursor.count());
         }
@@ -95,7 +98,8 @@ mod tests {
             insert_transactions(&connection, test_transaction_set());
 
             let query =
-                DeleteCardanoTransactionQuery::below_block_number_threshold(100_000).unwrap();
+                DeleteCardanoTransactionQuery::below_block_number_threshold(BlockNumber(100_000))
+                    .unwrap();
             let cursor = connection.fetch(query).unwrap();
             assert_eq!(test_transaction_set().len(), cursor.count());
 
@@ -108,7 +112,8 @@ mod tests {
             let connection = cardano_tx_db_connection().unwrap();
             insert_transactions(&connection, test_transaction_set());
 
-            let query = DeleteCardanoTransactionQuery::below_block_number_threshold(0).unwrap();
+            let query = DeleteCardanoTransactionQuery::below_block_number_threshold(BlockNumber(0))
+                .unwrap();
             let cursor = connection.fetch(query).unwrap();
             assert_eq!(0, cursor.count());
 
@@ -121,7 +126,9 @@ mod tests {
             let connection = cardano_tx_db_connection().unwrap();
             insert_transactions(&connection, test_transaction_set());
 
-            let query = DeleteCardanoTransactionQuery::below_block_number_threshold(12).unwrap();
+            let query =
+                DeleteCardanoTransactionQuery::below_block_number_threshold(BlockNumber(12))
+                    .unwrap();
             let cursor = connection.fetch(query).unwrap();
             assert_eq!(4, cursor.count());
 
@@ -138,7 +145,10 @@ mod tests {
             let connection = cardano_tx_db_connection().unwrap();
 
             let cursor = connection
-                .fetch(DeleteCardanoTransactionQuery::above_block_number_threshold(100).unwrap())
+                .fetch(
+                    DeleteCardanoTransactionQuery::above_block_number_threshold(BlockNumber(100))
+                        .unwrap(),
+                )
                 .expect("pruning shouldn't crash without transactions stored");
             assert_eq!(0, cursor.count());
         }
@@ -148,7 +158,8 @@ mod tests {
             let connection = cardano_tx_db_connection().unwrap();
             insert_transactions(&connection, test_transaction_set());
 
-            let query = DeleteCardanoTransactionQuery::above_block_number_threshold(0).unwrap();
+            let query = DeleteCardanoTransactionQuery::above_block_number_threshold(BlockNumber(0))
+                .unwrap();
             let cursor = connection.fetch(query).unwrap();
             assert_eq!(test_transaction_set().len(), cursor.count());
 
@@ -163,7 +174,8 @@ mod tests {
             insert_transactions(&connection, test_transaction_set());
 
             let query =
-                DeleteCardanoTransactionQuery::above_block_number_threshold(100_000).unwrap();
+                DeleteCardanoTransactionQuery::above_block_number_threshold(BlockNumber(100_000))
+                    .unwrap();
             let cursor = connection.fetch(query).unwrap();
             assert_eq!(0, cursor.count());
 
@@ -176,7 +188,9 @@ mod tests {
             let connection = cardano_tx_db_connection().unwrap();
             insert_transactions(&connection, test_transaction_set());
 
-            let query = DeleteCardanoTransactionQuery::above_block_number_threshold(10).unwrap();
+            let query =
+                DeleteCardanoTransactionQuery::above_block_number_threshold(BlockNumber(10))
+                    .unwrap();
             let cursor = connection.fetch(query).unwrap();
             assert_eq!(4, cursor.count());
 

internal/mithril-persistence/src/database/query/cardano_transaction/get_cardano_transaction.rs

@@ -37,7 +37,7 @@ impl GetCardanoTransactionQuery {
         let condition = WhereCondition::where_in("transaction_hash", hashes_values).and_where(
             WhereCondition::new(
                 "block_number <= ?*",
-                vec![Value::Integer(up_to_or_equal as i64)],
+                vec![Value::Integer(*up_to_or_equal as i64)],
             ),
         );
 
@@ -50,8 +50,8 @@ impl GetCardanoTransactionQuery {
             condition = condition.or_where(WhereCondition::new(
                 "(block_number >= ?* and block_number < ?*)",
                 vec![
-                    Value::Integer(block_range.start as i64),
-                    Value::Integer(block_range.end as i64),
+                    Value::Integer(*block_range.start as i64),
+                    Value::Integer(*block_range.end as i64),
                 ],
             ))
         }
@@ -62,11 +62,11 @@ impl GetCardanoTransactionQuery {
     pub fn between_blocks(range: Range<BlockNumber>) -> Self {
         let condition = WhereCondition::new(
             "block_number >= ?*",
-            vec![Value::Integer(range.start as i64)],
+            vec![Value::Integer(*range.start as i64)],
         )
         .and_where(WhereCondition::new(
             "block_number < ?*",
-            vec![Value::Integer(range.end as i64)],
+            vec![Value::Integer(*range.end as i64)],
         ));
 
         Self { condition }
@@ -132,10 +132,10 @@ mod tests {
         insert_transactions(
             &connection,
             vec![
-                CardanoTransactionRecord::new("tx-hash-0", 10, 50, "block-hash-10"),
-                CardanoTransactionRecord::new("tx-hash-1", 10, 51, "block-hash-10"),
-                CardanoTransactionRecord::new("tx-hash-2", 11, 54, "block-hash-11"),
-                CardanoTransactionRecord::new("tx-hash-3", 11, 55, "block-hash-11"),
+                CardanoTransactionRecord::new("tx-hash-0", BlockNumber(10), 50, "block-hash-10"),
+                CardanoTransactionRecord::new("tx-hash-1", BlockNumber(10), 51, "block-hash-10"),
+                CardanoTransactionRecord::new("tx-hash-2", BlockNumber(11), 54, "block-hash-11"),
+                CardanoTransactionRecord::new("tx-hash-3", BlockNumber(11), 55, "block-hash-11"),
             ],
         );
 
@@ -144,8 +144,8 @@ mod tests {
             .unwrap();
         assert_eq!(
             vec![
-                CardanoTransactionRecord::new("tx-hash-2", 11, 54, "block-hash-11"),
-                CardanoTransactionRecord::new("tx-hash-3", 11, 55, "block-hash-11"),
+                CardanoTransactionRecord::new("tx-hash-2", BlockNumber(11), 54, "block-hash-11"),
+                CardanoTransactionRecord::new("tx-hash-3", BlockNumber(11), 55, "block-hash-11"),
             ],
             records
         );

internal/mithril-persistence/src/database/record/block_range_root.rs

@@ -1,7 +1,7 @@
 use sqlite::Row;
 
 use mithril_common::crypto_helper::MKTreeNode;
-use mithril_common::entities::BlockRange;
+use mithril_common::entities::{BlockNumber, BlockRange};
 
 use crate::database::Hydrator;
 use crate::sqlite::{HydrationError, Projection, SqLiteEntity};
@@ -37,7 +37,7 @@ impl SqLiteEntity for BlockRangeRootRecord {
     {
         let start = Hydrator::try_to_u64("block_range.start", row.read::<i64, _>(0))?;
         let end = Hydrator::try_to_u64("block_range.end", row.read::<i64, _>(1))?;
-        let range = BlockRange::from_block_number(start);
+        let range = BlockRange::from_block_number(BlockNumber(start));
         let merkle_root = row.read::<&str, _>(2);
 
         if range.start != start || range.end != end {
@@ -71,8 +71,6 @@ impl SqLiteEntity for BlockRangeRootRecord {
 mod tests {
     use sqlite::Connection;
 
-    use mithril_common::entities::BlockNumber;
-
     use super::*;
 
     fn select_block_range_from_db(start: BlockNumber, end: BlockNumber, merkle_root: &str) -> Row {
@@ -86,13 +84,13 @@ mod tests {
     fn hydrate_succeed_if_valid_block_range_in_row() {
         // A valid block range has both bounds as multiples of block range length and the interval
         // size is equal to block range length.
-        let row = select_block_range_from_db(0, BlockRange::LENGTH, "AAAA");
+        let row = select_block_range_from_db(BlockNumber(0), BlockRange::LENGTH, "AAAA");
         let res = BlockRangeRootRecord::hydrate(row).expect("Expected hydrate to succeed");
 
         assert_eq!(
             res,
             BlockRangeRootRecord {
-                range: BlockRange::from_block_number(0),
+                range: BlockRange::from_block_number(BlockNumber(0)),
                 merkle_root: MKTreeNode::from_hex("AAAA").unwrap(),
             }
         );
@@ -102,11 +100,11 @@ mod tests {
     fn hydrate_fail_if_invalid_block_range_in_row() {
         for invalid_row in [
             // Start is not a multiple of block range length
-            select_block_range_from_db(1, BlockRange::LENGTH, "AAAA"),
+            select_block_range_from_db(BlockNumber(1), BlockRange::LENGTH, "AAAA"),
             // End is not a multiple of block range length
-            select_block_range_from_db(0, BlockRange::LENGTH - 1, "AAAA"),
+            select_block_range_from_db(BlockNumber(0), BlockRange::LENGTH - 1, "AAAA"),
             // Interval is not equal to block range length
-            select_block_range_from_db(0, BlockRange::LENGTH * 4, "AAAA"),
+            select_block_range_from_db(BlockNumber(0), BlockRange::LENGTH * 4, "AAAA"),
         ] {
             let res =
                 BlockRangeRootRecord::hydrate(invalid_row).expect_err("Expected hydrate to fail");