Use new BlockNumber type in mithril-common

Only common compile, other crates still needs some work.

In order to do so some more capabilities add to be added to the
`BlockNumber`:
* Convertion from u64: to use with 'Into<BlockNumber>' generics, should
  be reserved to specific cases when it's clear that the number written
  is a Block Number and not something magic.
* PartialOrd from/to `u64`: so it can be passed to Range::contains
  method.

Author: Alenar

mithril-common/benches/block_range.rs

@@ -1,6 +1,6 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 
-use mithril_common::entities::BlockRange;
+use mithril_common::entities::{BlockNumber, BlockRange};
 
 fn all_block_ranges_in(c: &mut Criterion) {
     let mut group = c.benchmark_group("all_block_ranges_in");
@@ -14,7 +14,7 @@ fn all_block_ranges_in(c: &mut Criterion) {
             BenchmarkId::from_parameter(format!("0..{end_bound}")),
             &end_bound,
             |b, &end_bound| {
-                b.iter(|| BlockRange::all_block_ranges_in(0..=end_bound));
+                b.iter(|| BlockRange::all_block_ranges_in(BlockNumber(0)..=end_bound));
             },
         );
     }

mithril-common/benches/merkle_map.rs

@@ -1,5 +1,3 @@
-use std::ops::Range;
-
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use mithril_common::{
     crypto_helper::{MKMap, MKMapNode, MKMapValue, MKTree, MKTreeNode},
@@ -45,7 +43,7 @@ fn generate_block_ranges_nodes_iterator(
         );
         let mk_map_node = if block_range_index <= total_block_ranges - max_uncompressed_block_ranges
         {
-            let leaves = <Range<u64> as Clone>::clone(&block_range)
+            let leaves = (*block_range.start..*block_range.end)
                 .map(|leaf_index| leaf_index.to_string())
                 .collect::<Vec<_>>();
             let merkle_tree_block_range = MKTree::new(&leaves).unwrap();

mithril-common/src/cardano_block_scanner/chain_reader_block_streamer.rs

@@ -166,7 +166,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_parse_expected_nothing_strictly_above_block_number_threshold() {
-        let until_block_number = 10;
+        let until_block_number = BlockNumber(10);
         let chain_reader = Arc::new(Mutex::new(FakeChainReader::new(vec![
             ChainBlockNextAction::RollForward {
                 parsed_block: ScannedBlock::new(
@@ -224,16 +224,16 @@ mod tests {
     async fn test_parse_expected_multiple_rollforwards_below_block_number_threshold() {
         let chain_reader = Arc::new(Mutex::new(FakeChainReader::new(vec![
             ChainBlockNextAction::RollForward {
-                parsed_block: ScannedBlock::new("hash-1", 1, 10, Vec::<&str>::new()),
+                parsed_block: ScannedBlock::new("hash-1", BlockNumber(1), 10, Vec::<&str>::new()),
             },
             ChainBlockNextAction::RollForward {
-                parsed_block: ScannedBlock::new("hash-2", 2, 20, Vec::<&str>::new()),
+                parsed_block: ScannedBlock::new("hash-2", BlockNumber(2), 20, Vec::<&str>::new()),
             },
         ])));
         let mut block_streamer = ChainReaderBlockStreamer::try_new(
             chain_reader,
             None,
-            100,
+            BlockNumber(100),
             MAX_ROLL_FORWARDS_PER_POLL,
             TestLogger::stdout(),
         )
@@ -244,8 +244,8 @@ mod tests {
 
         assert_eq!(
             Some(ChainScannedBlocks::RollForwards(vec![
-                ScannedBlock::new("hash-1", 1, 10, Vec::<&str>::new()),
-                ScannedBlock::new("hash-2", 2, 20, Vec::<&str>::new())
+                ScannedBlock::new("hash-1", BlockNumber(1), 10, Vec::<&str>::new()),
+                ScannedBlock::new("hash-2", BlockNumber(2), 20, Vec::<&str>::new())
             ])),
             scanned_blocks,
         );
@@ -255,19 +255,19 @@ mod tests {
     async fn test_parse_expected_maximum_rollforwards_retrieved_per_poll() {
         let chain_reader = Arc::new(Mutex::new(FakeChainReader::new(vec![
             ChainBlockNextAction::RollForward {
-                parsed_block: ScannedBlock::new("hash-1", 1, 10, Vec::<&str>::new()),
+                parsed_block: ScannedBlock::new("hash-1", BlockNumber(1), 10, Vec::<&str>::new()),
             },
             ChainBlockNextAction::RollForward {
-                parsed_block: ScannedBlock::new("hash-2", 2, 20, Vec::<&str>::new()),
+                parsed_block: ScannedBlock::new("hash-2", BlockNumber(2), 20, Vec::<&str>::new()),
             },
             ChainBlockNextAction::RollForward {
-                parsed_block: ScannedBlock::new("hash-3", 3, 30, Vec::<&str>::new()),
+                parsed_block: ScannedBlock::new("hash-3", BlockNumber(3), 30, Vec::<&str>::new()),
             },
         ])));
         let mut block_streamer = ChainReaderBlockStreamer::try_new(
             chain_reader,
             None,
-            100,
+            BlockNumber(100),
             MAX_ROLL_FORWARDS_PER_POLL,
             TestLogger::stdout(),
         )
@@ -278,8 +278,8 @@ mod tests {
         let scanned_blocks = block_streamer.poll_next().await.expect("poll_next failed");
         assert_eq!(
             Some(ChainScannedBlocks::RollForwards(vec![
-                ScannedBlock::new("hash-1", 1, 10, Vec::<&str>::new()),
-                ScannedBlock::new("hash-2", 2, 20, Vec::<&str>::new())
+                ScannedBlock::new("hash-1", BlockNumber(1), 10, Vec::<&str>::new()),
+                ScannedBlock::new("hash-2", BlockNumber(2), 20, Vec::<&str>::new())
             ])),
             scanned_blocks,
         );
@@ -288,7 +288,7 @@ mod tests {
         assert_eq!(
             Some(ChainScannedBlocks::RollForwards(vec![ScannedBlock::new(
                 "hash-3",
-                3,
+                BlockNumber(3),
                 30,
                 Vec::<&str>::new()
             ),])),
@@ -306,8 +306,8 @@ mod tests {
         ])));
         let mut block_streamer = ChainReaderBlockStreamer::try_new(
             chain_reader,
-            Some(ChainPoint::new(100, 10, "hash-123")),
-            1,
+            Some(ChainPoint::new(100, BlockNumber(10), "hash-123")),
+            BlockNumber(1),
             MAX_ROLL_FORWARDS_PER_POLL,
             TestLogger::stdout(),
         )
@@ -327,7 +327,7 @@ mod tests {
         let mut block_streamer = ChainReaderBlockStreamer::try_new(
             chain_reader,
             None,
-            1,
+            BlockNumber(1),
             MAX_ROLL_FORWARDS_PER_POLL,
             TestLogger::stdout(),
         )
@@ -347,20 +347,25 @@ mod tests {
     ) {
         let chain_reader = Arc::new(Mutex::new(FakeChainReader::new(vec![
             ChainBlockNextAction::RollForward {
-                parsed_block: ScannedBlock::new("hash-8", 80, 8, Vec::<&str>::new()),
+                parsed_block: ScannedBlock::new("hash-8", BlockNumber(80), 8, Vec::<&str>::new()),
             },
             ChainBlockNextAction::RollForward {
-                parsed_block: ScannedBlock::new("hash-9", 90, 9, Vec::<&str>::new()),
+                parsed_block: ScannedBlock::new("hash-9", BlockNumber(90), 9, Vec::<&str>::new()),
             },
             ChainBlockNextAction::RollForward {
-                parsed_block: ScannedBlock::new("hash-10", 100, 10, Vec::<&str>::new()),
+                parsed_block: ScannedBlock::new(
+                    "hash-10",
+                    BlockNumber(100),
+                    10,
+                    Vec::<&str>::new(),
+                ),
             },
             ChainBlockNextAction::RollBackward { slot_number: 9 },
         ])));
         let mut block_streamer = ChainReaderBlockStreamer::try_new(
             chain_reader,
             None,
-            1000,
+            BlockNumber(1000),
             MAX_ROLL_FORWARDS_PER_POLL,
             TestLogger::stdout(),
         )
@@ -371,8 +376,8 @@ mod tests {
 
         assert_eq!(
             Some(ChainScannedBlocks::RollForwards(vec![
-                ScannedBlock::new("hash-8", 80, 8, Vec::<&str>::new()),
-                ScannedBlock::new("hash-9", 90, 9, Vec::<&str>::new())
+                ScannedBlock::new("hash-8", BlockNumber(80), 8, Vec::<&str>::new()),
+                ScannedBlock::new("hash-9", BlockNumber(90), 9, Vec::<&str>::new())
             ])),
             scanned_blocks,
         );
@@ -383,17 +388,17 @@ mod tests {
     ) {
         let chain_reader = Arc::new(Mutex::new(FakeChainReader::new(vec![
             ChainBlockNextAction::RollForward {
-                parsed_block: ScannedBlock::new("hash-8", 80, 8, Vec::<&str>::new()),
+                parsed_block: ScannedBlock::new("hash-8", BlockNumber(80), 8, Vec::<&str>::new()),
             },
             ChainBlockNextAction::RollForward {
-                parsed_block: ScannedBlock::new("hash-9", 90, 9, Vec::<&str>::new()),
+                parsed_block: ScannedBlock::new("hash-9", BlockNumber(90), 9, Vec::<&str>::new()),
             },
             ChainBlockNextAction::RollBackward { slot_number: 3 },
         ])));
         let mut block_streamer = ChainReaderBlockStreamer::try_new(
             chain_reader,
             None,
-            1000,
+            BlockNumber(1000),
             MAX_ROLL_FORWARDS_PER_POLL,
             TestLogger::stdout(),
         )
@@ -411,7 +416,7 @@ mod tests {
         let mut block_streamer = ChainReaderBlockStreamer::try_new(
             chain_reader,
             None,
-            1,
+            BlockNumber(1),
             MAX_ROLL_FORWARDS_PER_POLL,
             TestLogger::stdout(),
         )

mithril-common/src/cardano_block_scanner/dumb_block_scanner.rs

@@ -131,7 +131,12 @@ mod tests {
 
     #[tokio::test]
     async fn polling_with_one_set_of_block_returns_some_once() {
-        let expected_blocks = vec![ScannedBlock::new("hash-1", 1, 10, Vec::<&str>::new())];
+        let expected_blocks = vec![ScannedBlock::new(
+            "hash-1",
+            BlockNumber(1),
+            10,
+            Vec::<&str>::new(),
+        )];
         let mut streamer = DumbBlockStreamer::new().forwards(vec![expected_blocks.clone()]);
 
         let blocks = streamer.poll_next().await.unwrap();
@@ -147,12 +152,22 @@ mod tests {
     #[tokio::test]
     async fn polling_with_multiple_sets_of_blocks_returns_some_once() {
         let expected_blocks = vec![
-            vec![ScannedBlock::new("hash-1", 1, 10, Vec::<&str>::new())],
+            vec![ScannedBlock::new(
+                "hash-1",
+                BlockNumber(1),
+                10,
+                Vec::<&str>::new(),
+            )],
             vec![
-                ScannedBlock::new("hash-2", 2, 11, Vec::<&str>::new()),
-                ScannedBlock::new("hash-3", 3, 12, Vec::<&str>::new()),
+                ScannedBlock::new("hash-2", BlockNumber(2), 11, Vec::<&str>::new()),
+                ScannedBlock::new("hash-3", BlockNumber(3), 12, Vec::<&str>::new()),
             ],
-            vec![ScannedBlock::new("hash-4", 4, 13, Vec::<&str>::new())],
+            vec![ScannedBlock::new(
+                "hash-4",
+                BlockNumber(4),
+                13,
+                Vec::<&str>::new(),
+            )],
         ];
         let mut streamer = DumbBlockStreamer::new().forwards(expected_blocks.clone());
 
@@ -180,24 +195,34 @@ mod tests {
 
     #[tokio::test]
     async fn dumb_scanned_construct_a_streamer_based_on_its_stored_blocks() {
-        let expected_blocks = vec![ScannedBlock::new("hash-1", 1, 10, Vec::<&str>::new())];
+        let expected_blocks = vec![ScannedBlock::new(
+            "hash-1",
+            BlockNumber(1),
+            10,
+            Vec::<&str>::new(),
+        )];
 
         let scanner = DumbBlockScanner::new().forwards(vec![expected_blocks.clone()]);
-        let mut streamer = scanner.scan(None, 5).await.unwrap();
+        let mut streamer = scanner.scan(None, BlockNumber(5)).await.unwrap();
 
         let blocks = streamer.poll_all().await.unwrap();
         assert_eq!(blocks, expected_blocks);
     }
 
     #[tokio::test]
     async fn dumb_scanned_construct_a_streamer_based_on_its_stored_chain_scanned_blocks() {
-        let expected_blocks = vec![ScannedBlock::new("hash-1", 1, 10, Vec::<&str>::new())];
-        let expected_chain_point = ChainPoint::new(10, 2, "block-hash");
+        let expected_blocks = vec![ScannedBlock::new(
+            "hash-1",
+            BlockNumber(1),
+            10,
+            Vec::<&str>::new(),
+        )];
+        let expected_chain_point = ChainPoint::new(10, BlockNumber(2), "block-hash");
 
         let scanner = DumbBlockScanner::new()
             .forwards(vec![expected_blocks.clone()])
             .backward(expected_chain_point.clone());
-        let mut streamer = scanner.scan(None, 5).await.unwrap();
+        let mut streamer = scanner.scan(None, BlockNumber(5)).await.unwrap();
 
         let blocks = streamer.poll_next().await.unwrap();
         assert_eq!(
@@ -217,11 +242,21 @@ mod tests {
     #[tokio::test]
     async fn polling_with_can_return_roll_backward() {
         let expected_blocks = vec![
-            vec![ScannedBlock::new("hash-1", 1, 10, Vec::<&str>::new())],
-            vec![ScannedBlock::new("hash-4", 4, 13, Vec::<&str>::new())],
+            vec![ScannedBlock::new(
+                "hash-1",
+                BlockNumber(1),
+                10,
+                Vec::<&str>::new(),
+            )],
+            vec![ScannedBlock::new(
+                "hash-4",
+                BlockNumber(4),
+                13,
+                Vec::<&str>::new(),
+            )],
         ];
 
-        let expected_chain_point = ChainPoint::new(10, 2, "block-hash");
+        let expected_chain_point = ChainPoint::new(10, BlockNumber(2), "block-hash");
 
         let mut streamer = DumbBlockStreamer::new()
             .forwards(expected_blocks.clone())

mithril-common/src/cardano_block_scanner/scanned_block.rs

@@ -39,7 +39,7 @@ impl ScannedBlock {
 
         Self::new(
             multi_era_block.hash().to_string(),
-            multi_era_block.number(),
+            BlockNumber(multi_era_block.number()),
             multi_era_block.slot(),
             transactions,
         )

mithril-common/src/cardano_transactions_preloader.rs

@@ -116,9 +116,7 @@ impl CardanoTransactionsPreloader {
             .with_context(|| {
                 "No chain point yielded by the chain observer, is your cardano node ready?"
             })?;
-        let up_to_block_number = chain_point
-            .block_number
-            .saturating_sub(self.security_parameter);
+        let up_to_block_number = chain_point.block_number - self.security_parameter;
         self.importer.import(up_to_block_number).await?;
 
         Ok(())
@@ -154,8 +152,8 @@ mod tests {
 
     #[tokio::test]
     async fn call_its_inner_importer_when_is_activated() {
-        let chain_block_number = 5000;
-        let security_parameter = 542;
+        let chain_block_number = BlockNumber(5000);
+        let security_parameter = BlockNumber(542);
         let chain_observer = FakeObserver::new(Some(TimePoint {
             chain_point: ChainPoint {
                 block_number: chain_block_number,
@@ -194,7 +192,7 @@ mod tests {
         let preloader = CardanoTransactionsPreloader::new(
             Arc::new(SignedEntityTypeLock::default()),
             Arc::new(importer),
-            542,
+            BlockNumber(542),
             Arc::new(chain_observer),
             TestLogger::stdout(),
             Arc::new(CardanoTransactionsPreloaderActivation::new(false)),
@@ -218,7 +216,7 @@ mod tests {
         let preloader = CardanoTransactionsPreloader::new(
             Arc::new(SignedEntityTypeLock::default()),
             Arc::new(importer),
-            542,
+            BlockNumber(542),
             Arc::new(chain_observer),
             TestLogger::stdout(),
             Arc::new(preloader_checker),
@@ -239,7 +237,7 @@ mod tests {
         let preloader = CardanoTransactionsPreloader::new(
             Arc::new(SignedEntityTypeLock::default()),
             Arc::new(importer),
-            0,
+            BlockNumber(0),
             Arc::new(chain_observer),
             TestLogger::stdout(),
             Arc::new(CardanoTransactionsPreloaderActivation::new(true)),
@@ -260,7 +258,7 @@ mod tests {
             Arc::new(ImporterWithSignedEntityTypeLockCheck {
                 signed_entity_type_lock: signed_entity_type_lock.clone(),
             }),
-            0,
+            BlockNumber(0),
             Arc::new(FakeObserver::new(Some(TimePoint::dummy()))),
             TestLogger::stdout(),
             Arc::new(CardanoTransactionsPreloaderActivation::new(true)),
@@ -291,7 +289,7 @@ mod tests {
             Arc::new(ImporterWithSignedEntityTypeLockCheck {
                 signed_entity_type_lock: signed_entity_type_lock.clone(),
             }),
-            0,
+            BlockNumber(0),
             Arc::new(chain_observer),
             TestLogger::stdout(),
             Arc::new(CardanoTransactionsPreloaderActivation::new(true)),