Review: apply suggestions

* more explicit parameter name for `DeleteCardanoTransactionProvider` method
* Simplify `TransactionPruner` doc
* Remove 'decorator' from the transaction pruner name
* Simplify some generics declaration

Author: Alenar

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

@@ -37,22 +37,23 @@ impl<'conn> DeleteCardanoTransactionProvider<'conn> {
         Self { connection }
     }
 
-    fn get_prune_condition(&self, threshold: BlockNumber) -> StdResult<WhereCondition> {
-        let threshold = Value::Integer(
-            threshold
-                .try_into()
-                .with_context(|| format!("Failed to convert threshold `{threshold}` to i64"))?,
-        );
+    fn get_prune_condition(
+        &self,
+        block_number_threshold: BlockNumber,
+    ) -> StdResult<WhereCondition> {
+        let threshold = Value::Integer(block_number_threshold.try_into().with_context(|| {
+            format!("Failed to convert threshold `{block_number_threshold}` to i64")
+        })?);
 
         Ok(WhereCondition::new("block_number < ?*", vec![threshold]))
     }
 
     /// Prune the cardano transaction data below the given threshold.
     pub fn prune(
         &self,
-        threshold: BlockNumber,
+        block_number_threshold: BlockNumber,
     ) -> StdResult<EntityCursor<CardanoTransactionRecord>> {
-        let filters = self.get_prune_condition(threshold)?;
+        let filters = self.get_prune_condition(block_number_threshold)?;
 
         self.find(filters)
     }

mithril-signer/src/lib.rs

@@ -15,7 +15,7 @@ pub mod metrics;
 mod protocol_initializer_store;
 mod runtime;
 mod single_signer;
-mod transactions_importer_with_prune_decorator;
+mod transactions_importer_with_pruner;
 
 #[cfg(test)]
 pub use aggregator_client::dumb::DumbAggregatorClient;
@@ -29,7 +29,7 @@ pub use metrics::*;
 pub use protocol_initializer_store::{ProtocolInitializerStore, ProtocolInitializerStorer};
 pub use runtime::*;
 pub use single_signer::*;
-pub use transactions_importer_with_prune_decorator::*;
+pub use transactions_importer_with_pruner::*;
 
 /// HTTP request timeout duration in milliseconds
 const HTTP_REQUEST_TIMEOUT_DURATION: u64 = 30000;

mithril-signer/src/runtime/signer_services.rs

@@ -29,8 +29,8 @@ use mithril_persistence::{
 use crate::{
     aggregator_client::AggregatorClient, metrics::MetricsService, single_signer::SingleSigner,
     AggregatorHTTPClient, CardanoTransactionsImporter, Configuration, MithrilSingleSigner,
-    ProtocolInitializerStore, ProtocolInitializerStorer, HTTP_REQUEST_TIMEOUT_DURATION,
-    SQLITE_FILE, SQLITE_FILE_CARDANO_TRANSACTION,
+    ProtocolInitializerStore, ProtocolInitializerStorer, TransactionsImporterWithPruner,
+    HTTP_REQUEST_TIMEOUT_DURATION, SQLITE_FILE, SQLITE_FILE_CARDANO_TRANSACTION,
 };
 
 type StakeStoreService = Arc<StakeStore>;
@@ -274,7 +274,7 @@ impl<'a> ServiceBuilder for ProductionServiceBuilder<'a> {
             slog_scope::logger(),
         ));
         // Wrap the transaction importer with decorator to prune the transactions after import
-        let transactions_importer = Arc::new(crate::TransactionsImporterWithPruneDecorator::new(
+        let transactions_importer = Arc::new(TransactionsImporterWithPruner::new(
             self.config
                 .enable_transaction_pruning
                 .then_some(self.config.network_security_parameter),

mithril-signer/src/transactions_importer_with_prune_decorator.rs renamed to mithril-signer/src/transactions_importer_with_pruner.rs

@@ -10,23 +10,22 @@ use mithril_common::StdResult;
 #[cfg_attr(test, mockall::automock)]
 #[async_trait]
 pub trait TransactionPruner: Send + Sync {
-    /// Prune the transactions older than the given number of blocks (based on the block range root
-    /// stored).
+    /// Prune the transactions older than the given number of blocks.
     async fn prune(&self, number_of_blocks_to_keep: BlockNumber) -> StdResult<()>;
 }
 
 /// A decorator of [TransactionsImporter] that prunes the transactions older than a given number of
 /// blocks after running the import.
 ///
 /// If the number of blocks to keep is not provided, no pruning is performed.
-pub struct TransactionsImporterWithPruneDecorator {
+pub struct TransactionsImporterWithPruner {
     number_of_blocks_to_keep: Option<BlockNumber>,
     transaction_pruner: Arc<dyn TransactionPruner>,
     wrapped_importer: Arc<dyn TransactionsImporter>,
 }
 
-impl TransactionsImporterWithPruneDecorator {
-    /// Create a new instance of [TransactionsImporterWithPruneDecorator].
+impl TransactionsImporterWithPruner {
+    /// Create a new instance of [TransactionsImporterWithPruner].
     pub fn new(
         number_of_blocks_to_keep: Option<BlockNumber>,
         transaction_pruner: Arc<dyn TransactionPruner>,
@@ -41,7 +40,7 @@ impl TransactionsImporterWithPruneDecorator {
 }
 
 #[async_trait]
-impl TransactionsImporter for TransactionsImporterWithPruneDecorator {
+impl TransactionsImporter for TransactionsImporterWithPruner {
     async fn import(&self, up_to_beacon: ImmutableFileNumber) -> StdResult<()> {
         self.wrapped_importer.import(up_to_beacon).await?;
 
@@ -71,15 +70,15 @@ mod tests {
         }
     }
 
-    impl TransactionsImporterWithPruneDecorator {
-        pub fn new_with_mock<Ti, Pr>(
+    impl TransactionsImporterWithPruner {
+        pub fn new_with_mock<P, I>(
             number_of_blocks_to_keep: Option<BlockNumber>,
-            transaction_pruner_mock_config: Pr,
-            importer_mock_config: Ti,
+            transaction_pruner_mock_config: P,
+            importer_mock_config: I,
         ) -> Self
         where
-            Pr: FnOnce(&mut MockTransactionPruner),
-            Ti: FnOnce(&mut MockTransactionImporterImpl),
+            P: FnOnce(&mut MockTransactionPruner),
+            I: FnOnce(&mut MockTransactionImporterImpl),
         {
             let mut transaction_pruner = MockTransactionPruner::new();
             transaction_pruner_mock_config(&mut transaction_pruner);
@@ -96,7 +95,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_does_not_prune_if_none_is_configured() {
-        let importer = TransactionsImporterWithPruneDecorator::new_with_mock(
+        let importer = TransactionsImporterWithPruner::new_with_mock(
             None,
             |mock| {
                 mock.expect_prune().never();
@@ -112,7 +111,7 @@ mod tests {
     #[tokio::test]
     async fn test_does_prune_if_a_block_number_is_configured() {
         let expected_block_number: BlockNumber = 5;
-        let importer = TransactionsImporterWithPruneDecorator::new_with_mock(
+        let importer = TransactionsImporterWithPruner::new_with_mock(
             Some(expected_block_number),
             |mock| {
                 mock.expect_prune()