Remove conversion from or to u64

Author: sfauvel

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

@@ -30,17 +30,13 @@ impl Query for DeleteBlockRangeRootQuery {
 }
 
 impl DeleteBlockRangeRootQuery {
-    pub fn contains_or_above_block_number_threshold<T: Into<BlockNumber>>(
-        block_number_threshold: T,
+    pub fn contains_or_above_block_number_threshold(
+        block_number_threshold: BlockNumber,
     ) -> StdResult<Self> {
-        let threshold = block_number_threshold.into();
-        let block_range = BlockRange::from_block_number(threshold);
-        let threshold = Value::Integer(
-            block_range
-                .start
-                .try_into()
-                .with_context(|| format!("Failed to convert threshold `{threshold}` to i64"))?,
-        );
+        let block_range = BlockRange::from_block_number(block_number_threshold);
+        let threshold = Value::Integer(block_range.start.try_into().with_context(|| {
+            format!("Failed to convert threshold `{block_number_threshold}` to i64")
+        })?);
 
         Ok(Self {
             condition: WhereCondition::new("start >= ?*", vec![threshold]),
@@ -86,7 +82,10 @@ 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());

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

@@ -17,11 +17,11 @@ impl GetBlockRangeRootQuery {
         }
     }
 
-    pub fn contains_or_below_block_number<T: Into<BlockNumber>>(block_number: T) -> Self {
+    pub fn contains_or_below_block_number(block_number: BlockNumber) -> Self {
         Self {
             condition: WhereCondition::new(
                 "start < ?*",
-                vec![Value::Integer(*block_number.into() as i64)],
+                vec![Value::Integer(*block_number as i64)],
             ),
         }
     }
@@ -85,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);
     }
@@ -98,7 +100,7 @@ mod tests {
 
         let cursor: Vec<BlockRangeRootRecord> = connection
             .fetch_collect(GetBlockRangeRootQuery::contains_or_below_block_number(
-                10_000,
+                BlockNumber(10_000),
             ))
             .unwrap();
 
@@ -112,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);
@@ -125,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);
@@ -138,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

@@ -30,30 +30,20 @@ impl Query for DeleteCardanoTransactionQuery {
 }
 
 impl DeleteCardanoTransactionQuery {
-    pub fn below_block_number_threshold<T: Into<BlockNumber>>(
-        block_number_threshold: T,
-    ) -> StdResult<Self> {
-        let threshold = block_number_threshold.into();
-        let threshold = Value::Integer(
-            threshold
-                .try_into()
-                .with_context(|| format!("Failed to convert threshold `{threshold}` to i64"))?,
-        );
+    pub fn below_block_number_threshold(block_number_threshold: BlockNumber) -> StdResult<Self> {
+        let threshold = Value::Integer(block_number_threshold.try_into().with_context(|| {
+            format!("Failed to convert threshold `{block_number_threshold}` to i64")
+        })?);
 
         Ok(Self {
             condition: WhereCondition::new("block_number < ?*", vec![threshold]),
         })
     }
 
-    pub fn above_block_number_threshold<T: Into<BlockNumber>>(
-        block_number_threshold: T,
-    ) -> StdResult<Self> {
-        let threshold = block_number_threshold.into();
-        let threshold = Value::Integer(
-            threshold
-                .try_into()
-                .with_context(|| format!("Failed to convert threshold `{threshold}` to i64"))?,
-        );
+    pub fn above_block_number_threshold(block_number_threshold: BlockNumber) -> StdResult<Self> {
+        let threshold = Value::Integer(block_number_threshold.try_into().with_context(|| {
+            format!("Failed to convert threshold `{block_number_threshold}` to i64")
+        })?);
 
         Ok(Self {
             condition: WhereCondition::new("block_number > ?*", vec![threshold]),
@@ -94,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());
         }
@@ -105,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());
 
@@ -118,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());
 
@@ -131,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());
 
@@ -148,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());
         }
@@ -158,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());
 
@@ -173,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());
 
@@ -186,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());
 

mithril-aggregator/src/services/cardano_transactions_importer.rs

@@ -659,8 +659,8 @@ mod tests {
                 .expect_get_transactions_in_range()
                 // Lower bound should be the end block number of the last known block range
                 // Upper bound should be the block number provided to `import_block_ranges`
-                .withf(|range| {
-                    BlockRangesSequence::new(HIGHEST_BLOCK_RANGE_START..=(BlockRange::LENGTH * 5))
+                .withf(move |range| {
+                    BlockRangesSequence::new(HIGHEST_BLOCK_RANGE_START..=up_to_block_number)
                         .contains(range)
                 })
                 .returning(transactions_for_block);

mithril-common/benches/merkle_map.rs

@@ -37,10 +37,9 @@ fn generate_block_ranges_nodes_iterator(
         "total_block_ranges should be strictly greater than 0"
     );
     (0..total_block_ranges).map(move |block_range_index| {
-        let block_range = BlockRange::new(
-            block_range_index * total_transactions_per_block_range,
-            (block_range_index + 1) * total_transactions_per_block_range,
-        );
+        let start = block_range_index * total_transactions_per_block_range;
+        let end = (block_range_index + 1) * total_transactions_per_block_range;
+        let block_range = BlockRange::from(start..end);
         let mk_map_node = if block_range_index <= total_block_ranges - max_uncompressed_block_ranges
         {
             let leaves = (*block_range.start..*block_range.end)

mithril-common/src/entities/block_number.rs

@@ -1,4 +1,3 @@
-use std::cmp::Ordering;
 use std::fmt::{Display, Formatter};
 use std::num::TryFromIntError;
 use std::ops::{Deref, DerefMut};
@@ -16,7 +15,7 @@ use wasm_bindgen::prelude::*;
 
 /// BlockNumber is the block number of a Cardano transaction.
 #[derive(
-    Debug, Copy, Clone, Default, PartialEq, Serialize, Deserialize, Hash, Eq, PartialOrd, Ord,
+    Debug, Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Hash,
 )]
 #[cfg_attr(target_family = "wasm", wasm_bindgen)]
 pub struct BlockNumber(pub u64);
@@ -43,18 +42,6 @@ impl DerefMut for BlockNumber {
     }
 }
 
-impl From<u64> for BlockNumber {
-    fn from(value: u64) -> Self {
-        Self(value)
-    }
-}
-
-impl From<&u64> for BlockNumber {
-    fn from(value: &u64) -> Self {
-        (*value).into()
-    }
-}
-
 // Useful for conversion to sqlite number (that use i64)
 impl TryFrom<BlockNumber> for i64 {
     type Error = TryFromIntError;
@@ -64,30 +51,6 @@ impl TryFrom<BlockNumber> for i64 {
     }
 }
 
-impl PartialOrd<u64> for BlockNumber {
-    fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
-        self.0.partial_cmp(other)
-    }
-}
-
-impl PartialOrd<&u64> for BlockNumber {
-    fn partial_cmp(&self, other: &&u64) -> Option<Ordering> {
-        self.0.partial_cmp(*other)
-    }
-}
-
-impl PartialOrd<BlockNumber> for u64 {
-    fn partial_cmp(&self, other: &BlockNumber) -> Option<Ordering> {
-        self.partial_cmp(&other.0)
-    }
-}
-
-impl PartialOrd<&BlockNumber> for u64 {
-    fn partial_cmp(&self, other: &&BlockNumber) -> Option<Ordering> {
-        self.partial_cmp(&other.0)
-    }
-}
-
 impl_add_to_wrapper!(BlockNumber, u64);
 impl_sub_to_wrapper!(BlockNumber, u64);
 impl_mul_to_wrapper!(BlockNumber, u64);

mithril-common/src/entities/block_range.rs

@@ -27,14 +27,14 @@ impl BlockRange {
     /// Important: this value should be updated with extreme care (probably with an era change) in order to avoid signing disruptions.
     pub const LENGTH: BlockRangeLength = BlockNumber(15);
 
-    /// BlockRange factory
-    pub fn new<T1: Into<BlockNumber>, T2: Into<BlockNumber>>(start: T1, end: T2) -> Self {
-        Self {
-            inner_range: start.into()..end.into(),
+    cfg_test_tools! {
+        /// BlockRange factory
+        pub fn new(start: u64, end: u64) -> Self {
+            Self {
+                inner_range: BlockNumber(start)..BlockNumber(end),
+            }
         }
-    }
 
-    cfg_test_tools! {
         /// Try to add two BlockRanges
         pub fn try_add(&self, other: &BlockRange) -> StdResult<BlockRange> {
             if self.inner_range.end.max(other.inner_range.end)
@@ -82,7 +82,7 @@ impl BlockRange {
         }
         let block_range_start = Self::start_with_length(number, length);
         let block_range_end = block_range_start + length;
-        Ok(Self::new(*block_range_start, *block_range_end))
+        Ok(Self::from(*block_range_start..*block_range_end))
     }
 
     /// Get the start of the block range of given length that contains the given block number
@@ -238,11 +238,11 @@ mod tests {
     fn test_block_range_contains() {
         let block_range = BlockRange::new(1, 10);
 
-        assert!(block_range.contains(&1));
-        assert!(block_range.contains(&6));
+        assert!(block_range.contains(&BlockNumber(1)));
+        assert!(block_range.contains(&BlockNumber(6)));
         assert!(block_range.contains(&BlockNumber(9)));
 
-        assert!(block_range.contains(&0).not());
+        assert!(block_range.contains(&BlockNumber(0)).not());
         // The end of the range is exclusive
         assert!(block_range.contains(&BlockNumber(10)).not());
     }

mithril-signer/src/cardano_transactions_importer.rs

@@ -659,8 +659,8 @@ mod tests {
                 .expect_get_transactions_in_range()
                 // Lower bound should be the end block number of the last known block range
                 // Upper bound should be the block number provided to `import_block_ranges`
-                .withf(|range| {
-                    BlockRangesSequence::new(HIGHEST_BLOCK_RANGE_START..=(BlockRange::LENGTH * 5))
+                .withf(move |range| {
+                    BlockRangesSequence::new(HIGHEST_BLOCK_RANGE_START..=up_to_block_number)
                         .contains(range)
                 })
                 .returning(transactions_for_block);