PR review: Style & naming fix from PR

Author: Alenar

internal/mithril-persistence/src/sqlite/condition.rs

@@ -138,9 +138,6 @@ impl WhereCondition {
 }
 
 /// Get all condition builder.
-///
-/// By default, nothing will be filtered out when using this condition. But you
-/// can override this behavior by implementing this trait for your type.
 pub trait GetAllCondition {
     /// Get the condition for a get all query.
     fn get_all_condition() -> WhereCondition {

mithril-aggregator/src/database/record/block_range_root.rs

@@ -11,8 +11,7 @@ use crate::database::record::hydrator::try_to_u64;
 pub struct BlockRangeRootRecord {
     /// Range of block numbers covered
     pub range: BlockRange,
-    /// Merkle root of the block range, computed from the list of all transactions that are
-    /// included in the range
+    /// Merkle root of the block range, computed from the list of included transactions
     pub merkle_root: MKTreeNode,
 }
 

mithril-aggregator/src/database/record/interval_without_block_range_root.rs

@@ -5,7 +5,7 @@ use mithril_persistence::sqlite::{HydrationError, Projection, SqLiteEntity};
 
 use crate::database::record::hydrator::try_to_u64;
 
-/// Interval of block numbers without block ranges root.
+/// Interval of block numbers (`[start, end[`) without block ranges root.
 pub struct IntervalWithoutBlockRangeRootRecord {
     /// Start of the interval
     pub start: Option<BlockNumber>,

mithril-aggregator/src/database/repository/cardano_transaction_repository.rs

@@ -44,7 +44,7 @@ impl CardanoTransactionRepository {
     }
 
     /// Return all the [CardanoTransactionRecord]s in the database using chronological order.
-    pub async fn get_transactions_between_blocks(
+    pub async fn get_transactions_in_range_blocks(
         &self,
         range: Range<BlockNumber>,
     ) -> StdResult<Vec<CardanoTransactionRecord>> {
@@ -118,7 +118,7 @@ impl CardanoTransactionRepository {
     }
 
     /// Create new [BlockRangeRootRecord]s in the database.
-    pub async fn create_block_ranges<T: Into<BlockRangeRootRecord>>(
+    pub async fn create_block_range_roots<T: Into<BlockRangeRootRecord>>(
         &self,
         block_ranges: Vec<T>,
     ) -> StdResult<Vec<BlockRangeRootRecord>> {
@@ -226,23 +226,23 @@ impl TransactionStore for CardanoTransactionRepository {
         }
     }
 
-    async fn get_transactions_between(
+    async fn get_transactions_in_range(
         &self,
         range: Range<BlockNumber>,
     ) -> StdResult<Vec<CardanoTransaction>> {
-        self.get_transactions_between_blocks(range).await.map(|v| {
+        self.get_transactions_in_range_blocks(range).await.map(|v| {
             v.into_iter()
                 .map(|record| record.into())
                 .collect::<Vec<CardanoTransaction>>()
         })
     }
 
-    async fn store_block_ranges(
+    async fn store_block_range_roots(
         &self,
         block_ranges: Vec<(BlockRange, MKTreeNode)>,
     ) -> StdResult<()> {
         if !block_ranges.is_empty() {
-            self.create_block_ranges(block_ranges).await?;
+            self.create_block_range_roots(block_ranges).await?;
         }
         Ok(())
     }
@@ -535,7 +535,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn repository_get_transactions_between_blocks() {
+    async fn repository_get_transactions_in_range_blocks() {
         let connection = Arc::new(cardano_tx_db_connection().unwrap());
         let repository = CardanoTransactionRepository::new(connection);
 
@@ -550,23 +550,23 @@ mod tests {
             .unwrap();
 
         {
-            let transaction_result = repository.get_transactions_between(0..10).await.unwrap();
+            let transaction_result = repository.get_transactions_in_range(0..10).await.unwrap();
             assert_eq!(Vec::<CardanoTransaction>::new(), transaction_result);
         }
         {
-            let transaction_result = repository.get_transactions_between(13..21).await.unwrap();
+            let transaction_result = repository.get_transactions_in_range(13..21).await.unwrap();
             assert_eq!(Vec::<CardanoTransaction>::new(), transaction_result);
         }
         {
-            let transaction_result = repository.get_transactions_between(9..12).await.unwrap();
+            let transaction_result = repository.get_transactions_in_range(9..12).await.unwrap();
             assert_eq!(transactions[0..=1].to_vec(), transaction_result);
         }
         {
-            let transaction_result = repository.get_transactions_between(10..13).await.unwrap();
+            let transaction_result = repository.get_transactions_in_range(10..13).await.unwrap();
             assert_eq!(transactions.clone(), transaction_result);
         }
         {
-            let transaction_result = repository.get_transactions_between(11..14).await.unwrap();
+            let transaction_result = repository.get_transactions_in_range(11..14).await.unwrap();
             assert_eq!(transactions[1..=2].to_vec(), transaction_result);
         }
     }
@@ -604,7 +604,7 @@ mod tests {
             // The last block range give the lower bound
             let last_block_range = BlockRange::from_block_number(0);
             repository
-                .store_block_ranges(vec![(
+                .store_block_range_roots(vec![(
                     last_block_range.clone(),
                     MKTreeNode::from_hex("AAAA").unwrap(),
                 )])
@@ -631,7 +631,7 @@ mod tests {
 
         let last_block_range = BlockRange::from_block_number(BlockRange::LENGTH * 10);
         repository
-            .store_block_ranges(vec![(
+            .store_block_range_roots(vec![(
                 last_block_range.clone(),
                 MKTreeNode::from_hex("AAAA").unwrap(),
             )])
@@ -672,7 +672,7 @@ mod tests {
         let repository = CardanoTransactionRepository::new(connection.clone());
 
         repository
-            .store_block_ranges(vec![
+            .store_block_range_roots(vec![
                 (
                     BlockRange::from_block_number(0),
                     MKTreeNode::from_hex("AAAA").unwrap(),
@@ -709,11 +709,11 @@ mod tests {
         let range = BlockRange::from_block_number(0);
 
         repository
-            .store_block_ranges(vec![(range.clone(), MKTreeNode::from_hex("AAAA").unwrap())])
+            .store_block_range_roots(vec![(range.clone(), MKTreeNode::from_hex("AAAA").unwrap())])
             .await
             .unwrap();
         repository
-            .store_block_ranges(vec![(range.clone(), MKTreeNode::from_hex("BBBB").unwrap())])
+            .store_block_range_roots(vec![(range.clone(), MKTreeNode::from_hex("BBBB").unwrap())])
             .await
             .unwrap();
 

mithril-aggregator/src/dependency_injection/builder.rs

@@ -136,7 +136,7 @@ pub struct DependenciesBuilder {
     /// Cardano transactions store.
     pub transaction_store: Option<Arc<dyn TransactionStore>>,
 
-    /// Cardano transactions parser.
+    /// Cardano block scanner.
     pub block_scanner: Option<Arc<dyn BlockScanner>>,
 
     /// Immutable file digester service.
@@ -724,7 +724,7 @@ impl DependenciesBuilder {
         Ok(Arc::new(block_scanner))
     }
 
-    /// Transaction parser.
+    /// Block scanner
     pub async fn get_block_scanner(&mut self) -> Result<Arc<dyn BlockScanner>> {
         if self.block_scanner.is_none() {
             self.block_scanner = Some(self.build_block_scanner().await?);
@@ -1198,7 +1198,7 @@ impl DependenciesBuilder {
             signed_entity_storer: self.get_signed_entity_storer().await?,
             signer_getter: self.get_signer_store().await?,
             message_service: self.get_message_service().await?,
-            transaction_parser: self.get_block_scanner().await?,
+            block_scanner: self.get_block_scanner().await?,
             transaction_store: self.get_transaction_store().await?,
             prover_service: self.get_prover_service().await?,
         };

mithril-aggregator/src/dependency_injection/containers.rs

@@ -87,8 +87,8 @@ pub struct DependencyContainer {
     /// Cardano transactions store.
     pub transaction_store: Arc<dyn TransactionStore>,
 
-    /// Cardano transactions parser.
-    pub transaction_parser: Arc<dyn BlockScanner>,
+    /// Cardano block scanner.
+    pub block_scanner: Arc<dyn BlockScanner>,
 
     /// Immutable file observer service.
     pub immutable_file_observer: Arc<dyn ImmutableFileObserver>,

mithril-aggregator/src/services/cardano_transactions_importer.rs

@@ -32,14 +32,14 @@ pub trait TransactionStore: Send + Sync {
         &self,
     ) -> StdResult<Option<Range<BlockNumber>>>;
 
-    /// Get transactions between two block numbers
-    async fn get_transactions_between(
+    /// Get transactions in an interval of blocks
+    async fn get_transactions_in_range(
         &self,
         range: Range<BlockNumber>,
     ) -> StdResult<Vec<CardanoTransaction>>;
 
     /// Store list of block ranges with their corresponding merkle root
-    async fn store_block_ranges(
+    async fn store_block_range_roots(
         &self,
         block_ranges: Vec<(BlockRange, MKTreeNode)>,
     ) -> StdResult<()>;
@@ -127,7 +127,7 @@ impl CardanoTransactionsImporter {
             .transaction_store
             .get_block_interval_without_block_range_root()
             .await?
-            .map(|range| BlockRange::all_ranges_in(BlockRange::start(range.start)..range.end))
+            .map(|range| BlockRange::all_block_ranges_in(BlockRange::start(range.start)..range.end))
         {
             // Everything is already computed
             None => return Ok(()),
@@ -147,7 +147,7 @@ impl CardanoTransactionsImporter {
         for block_range in block_ranges {
             let transactions = self
                 .transaction_store
-                .get_transactions_between(block_range.start..block_range.end)
+                .get_transactions_in_range(block_range.start..block_range.end)
                 .await?;
 
             if transactions.is_empty() {
@@ -159,7 +159,7 @@ impl CardanoTransactionsImporter {
         }
 
         self.transaction_store
-            .store_block_ranges(block_ranges_with_merkle_root)
+            .store_block_range_roots(block_ranges_with_merkle_root)
             .await
     }
 }
@@ -318,7 +318,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn handle_gap_between_block_ranges() {
+    async fn if_theres_gap_between_two_stored_block_ranges_it_can_still_compute_their_root() {
         let connection = cardano_tx_db_connection().unwrap();
         let repository = Arc::new(CardanoTransactionRepository::new(Arc::new(connection)));
 
@@ -405,7 +405,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn if_half_transactions_are_stored_the_other_half_is_parsed_and_stored() {
+    async fn if_half_transactions_are_already_stored_the_other_half_is_parsed_and_stored() {
         let connection = cardano_tx_db_connection().unwrap();
         let repository = Arc::new(CardanoTransactionRepository::new(Arc::new(connection)));
 
@@ -457,7 +457,7 @@ mod tests {
         let transactions = into_transactions(&blocks);
         repository.store_transactions(transactions).await.unwrap();
         repository
-            .store_block_ranges(
+            .store_block_range_roots(
                 blocks[0..((BlockRange::LENGTH * 2) as usize)]
                     .iter()
                     .map(|b| {
@@ -509,8 +509,7 @@ mod tests {
     }
 
     #[tokio::test]
-    // async fn block_range_root_compute_work_on_block_range_starting_before_last_block_range_root_and_finishing_before_last_tx(
-    async fn block_range_root_only_retrieve_only_strictly_required_transactions() {
+    async fn block_range_root_retrieves_only_strictly_required_transactions() {
         fn transactions_for_block(range: Range<BlockNumber>) -> StdResult<Vec<CardanoTransaction>> {
             Ok(build_blocks(range.start, range.count() as BlockNumber)
                 .iter()
@@ -528,7 +527,7 @@ mod tests {
                 .returning(|| Ok(Some((BlockRange::LENGTH + 2)..(BlockRange::LENGTH * 5))))
                 .once();
             store_mock
-                .expect_get_transactions_between()
+                .expect_get_transactions_in_range()
                 // Lower bound should be the block number that start after the last known block range end
                 //
                 // if it's not a multiple of BlockRange::LENGTH, it should be the start block number
@@ -541,7 +540,9 @@ mod tests {
                     expected_range.contains(&range.start) && expected_range.contains(&range.end)
                 })
                 .returning(transactions_for_block);
-            store_mock.expect_store_block_ranges().returning(|_| Ok(()));
+            store_mock
+                .expect_store_block_range_roots()
+                .returning(|_| Ok(()));
 
             CardanoTransactionsImporter::new_for_test(
                 Arc::new(MockBlockScannerImpl::new()),

mithril-common/src/cardano_block_scanner.rs

@@ -62,7 +62,7 @@ pub trait BlockScanner: Sync + Send {
     ) -> StdResult<Vec<ScannedBlock>>;
 }
 
-/// Dumb transaction parser
+/// Dumb Block Scanner
 pub struct DumbBlockScanner {
     blocks: RwLock<Vec<ScannedBlock>>,
 }
@@ -161,7 +161,7 @@ impl ScannedBlock {
     }
 }
 
-/// Cardano transaction parser
+/// Cardano block scanner
 pub struct CardanoBlockScanner {
     logger: Logger,
     /// When set to true, no error is returned in case of unparsable block, and an error log is written instead.

mithril-common/src/entities/block_range.rs

@@ -58,8 +58,8 @@ impl BlockRange {
         Self::start_with_length(number, Self::LENGTH)
     }
 
-    /// Get all [BlockRange] contained in the given interval
-    pub fn all_ranges_in(interval: Range<BlockNumber>) -> Vec<BlockRange> {
+    /// Get all [BlockRange] strictly contained in the given interval
+    pub fn all_block_ranges_in(interval: Range<BlockNumber>) -> Vec<BlockRange> {
         let all_numbers: Vec<BlockNumber> =
             interval.skip_while(|i| i % Self::LENGTH != 0).collect();
         all_numbers
@@ -213,29 +213,29 @@ mod tests {
     }
 
     #[test]
-    fn test_block_range_all_ranges_in() {
-        assert_eq!(BlockRange::all_ranges_in(0..0), vec![]);
-        assert_eq!(BlockRange::all_ranges_in(0..1), vec![]);
-        assert_eq!(BlockRange::all_ranges_in(0..14), vec![]);
-        assert_eq!(BlockRange::all_ranges_in(1..15), vec![]);
+    fn test_block_range_all_block_ranges_in() {
+        assert_eq!(BlockRange::all_block_ranges_in(0..0), vec![]);
+        assert_eq!(BlockRange::all_block_ranges_in(0..1), vec![]);
+        assert_eq!(BlockRange::all_block_ranges_in(0..14), vec![]);
+        assert_eq!(BlockRange::all_block_ranges_in(1..15), vec![]);
         assert_eq!(
-            BlockRange::all_ranges_in(0..15),
+            BlockRange::all_block_ranges_in(0..15),
             vec![BlockRange::new(0, 15)]
         );
         assert_eq!(
-            BlockRange::all_ranges_in(0..16),
+            BlockRange::all_block_ranges_in(0..16),
             vec![BlockRange::new(0, 15)]
         );
         assert_eq!(
-            BlockRange::all_ranges_in(14..30),
+            BlockRange::all_block_ranges_in(14..30),
             vec![BlockRange::new(15, 30)]
         );
         assert_eq!(
-            BlockRange::all_ranges_in(14..31),
+            BlockRange::all_block_ranges_in(14..31),
             vec![BlockRange::new(15, 30)]
         );
         assert_eq!(
-            BlockRange::all_ranges_in(14..61),
+            BlockRange::all_block_ranges_in(14..61),
             vec![
                 BlockRange::new(15, 30),
                 BlockRange::new(30, 45),