fix retrieve full list of transactions for block ranges

mithril-aggregator/src/database/provider/cardano_transaction/get_cardano_transaction.rs

@@ -2,7 +2,7 @@ use std::ops::Range;
 
 use sqlite::Value;
 
-use mithril_common::entities::{BlockNumber, TransactionHash};
+use mithril_common::entities::{BlockNumber, BlockRange, TransactionHash};
 use mithril_persistence::sqlite::{
     Provider, SourceAlias, SqLiteEntity, SqliteConnection, WhereCondition,
 };
@@ -40,6 +40,24 @@ impl<'client> GetCardanoTransactionProvider<'client> {
         WhereCondition::where_in("transaction_hash", hashes_values)
     }
 
+    pub fn get_transaction_block_ranges_condition(
+        &self,
+        block_ranges: Vec<BlockRange>,
+    ) -> WhereCondition {
+        let mut where_condition = WhereCondition::default();
+        for block_range in block_ranges {
+            where_condition = where_condition.or_where(WhereCondition::new(
+                "start = ?* and end = ",
+                vec![
+                    Value::Integer(block_range.start as i64),
+                    Value::Integer(block_range.end as i64),
+                ],
+            ))
+        }
+
+        where_condition
+    }
+
     pub fn get_transaction_between_blocks_condition(
         &self,
         range: Range<BlockNumber>,

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

@@ -310,6 +310,20 @@ impl TransactionsRetriever for CardanoTransactionRepository {
             .map(|record| record.into())
             .collect())
     }
+
+    async fn get_by_block_ranges(
+        &self,
+        block_ranges: Vec<BlockRange>,
+    ) -> StdResult<Vec<CardanoTransaction>> {
+        let provider = GetCardanoTransactionProvider::new(&self.connection);
+        let filters = provider.get_transaction_block_ranges_condition(block_ranges);
+        let transactions = provider.find(filters)?;
+
+        Ok(transactions
+            .into_iter()
+            .map(|record| record.into())
+            .collect())
+    }
 }
 
 #[async_trait]

mithril-aggregator/src/services/prover.rs

@@ -1,5 +1,5 @@
 use std::{
-    collections::{BTreeMap, HashMap},
+    collections::{BTreeMap, BTreeSet, HashMap},
     sync::Arc,
 };
 
@@ -39,6 +39,12 @@ pub trait TransactionsRetriever: Sync + Send {
         &self,
         hashes: Vec<TransactionHash>,
     ) -> StdResult<Vec<CardanoTransaction>>;
+
+    /// Get by block ranges
+    async fn get_by_block_ranges(
+        &self,
+        block_ranges: Vec<BlockRange>,
+    ) -> StdResult<Vec<CardanoTransaction>>;
 }
 
 /// Mithril prover
@@ -59,15 +65,31 @@ impl MithrilProverService {
         }
     }
 
-    /// Get all the transactions of the block ranges in which the given transaction hashes are included
-    async fn get_transactions_grouped_by_block_range(
+    async fn get_block_ranges(
+        &self,
+        transaction_hashes: &[TransactionHash],
+    ) -> StdResult<Vec<BlockRange>> {
+        let transactions = self
+            .transaction_retriever
+            .get_by_hashes(transaction_hashes.to_vec())
+            .await?;
+        let block_ranges = transactions
+            .iter()
+            .map(|t| BlockRange::from_block_number(t.block_number))
+            .collect::<BTreeSet<_>>();
+
+        Ok(block_ranges.into_iter().collect::<Vec<_>>())
+    }
+
+    /// Get all the transactions of the block ranges
+    async fn get_all_transactions_for_block_ranges(
         &self,
-        hashes: &[TransactionHash],
+        block_ranges: &[BlockRange],
     ) -> StdResult<HashMap<BlockRange, Vec<CardanoTransaction>>> {
         let mut block_ranges_map = HashMap::new();
         let transactions = self
             .transaction_retriever
-            .get_by_hashes(hashes.to_vec())
+            .get_by_block_ranges(block_ranges.to_vec())
             .await?;
         for transaction in transactions {
             let block_range = BlockRange::from_block_number(transaction.block_number);
@@ -88,8 +110,9 @@ impl ProverService for MithrilProverService {
         transaction_hashes: &[TransactionHash],
     ) -> StdResult<Vec<CardanoTransactionsSetProof>> {
         // 1 - Compute the set of block ranges with transactions to prove
+        let block_ranges_transactions = self.get_block_ranges(transaction_hashes).await?;
         let block_range_transactions = self
-            .get_transactions_grouped_by_block_range(transaction_hashes)
+            .get_all_transactions_for_block_ranges(&block_ranges_transactions)
             .await?;
         println!(
             "block_range_transactions: {:?}",
@@ -236,6 +259,16 @@ mod tests {
         let prover = build_prover(
             |retriever_mock| {
                 let transactions_by_hashes_res = transactions.clone();
+                let block_ranges_res = transactions
+                    .iter()
+                    .map(|t| BlockRange::from_block_number(t.block_number))
+                    .collect::<BTreeSet<_>>()
+                    .into_iter()
+                    .collect::<Vec<_>>();
+                retriever_mock
+                    .expect_get_by_hashes()
+                    .with(eq(transaction_hashes.clone()))
+                    .return_once(move |_| Ok(transactions_by_hashes_res));
                 retriever_mock
                     .expect_get_by_hashes()
                     .with(eq(transaction_hashes.clone()))