Block Number beacon in cardano transaction

internal/mithril-persistence/src/database/hydrator.rs

@@ -1,7 +1,9 @@
 //! Shared hydrator helpers for persistence
 
+use serde::Deserialize;
+
 use mithril_common::entities::{
-    CardanoDbBeacon, Epoch, SignedEntityType, SignedEntityTypeDiscriminants,
+    BlockNumber, CardanoDbBeacon, Epoch, SignedEntityType, SignedEntityTypeDiscriminants,
 };
 
 use crate::sqlite::HydrationError;
@@ -69,15 +71,39 @@ impl Hydrator {
                 SignedEntityType::CardanoImmutableFilesFull(beacon)
             }
             SignedEntityTypeDiscriminants::CardanoTransactions => {
-                let beacon: CardanoDbBeacon = serde_json::from_str(beacon_str).map_err(|e| {
-                    HydrationError::InvalidData(format!(
+                #[derive(Deserialize)]
+                struct CardanoTransactionsBeacon {
+                    epoch: Epoch,
+                    block_number: BlockNumber,
+                }
+
+                let beacon: CardanoTransactionsBeacon =
+                    serde_json::from_str(beacon_str).map_err(|e| {
+                        HydrationError::InvalidData(format!(
                         "Invalid Beacon JSON in open_message.beacon: '{beacon_str}'. Error: {e}"
                     ))
-                })?;
-                SignedEntityType::CardanoTransactions(beacon)
+                    })?;
+                SignedEntityType::CardanoTransactions(beacon.epoch, beacon.block_number)
             }
         };
 
         Ok(signed_entity)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn hydrate_cardano_transaction_signed_entity_type() {
+        let expected = SignedEntityType::CardanoTransactions(Epoch(35), 77);
+        let signed_entity = Hydrator::hydrate_signed_entity_type(
+            SignedEntityTypeDiscriminants::CardanoTransactions.index(),
+            &expected.get_json_beacon().unwrap(),
+        )
+        .unwrap();
+
+        assert_eq!(expected, signed_entity);
+    }
+}

internal/mithril-persistence/src/database/query/cardano_transaction/get_cardano_transaction.rs

@@ -64,6 +64,15 @@ impl GetCardanoTransactionQuery {
 
         Self { condition }
     }
+
+    pub fn with_highest_block_number() -> Self {
+        Self {
+            condition: WhereCondition::new(
+                "block_number = (select max(block_number) from cardano_tx)",
+                vec![],
+            ),
+        }
+    }
 }
 
 impl Query for GetCardanoTransactionQuery {
@@ -80,3 +89,49 @@ impl Query for GetCardanoTransactionQuery {
         format!("select {projection} from cardano_tx where {condition} order by block_number, transaction_hash")
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::database::query::InsertCardanoTransactionQuery;
+    use crate::database::test_helper::cardano_tx_db_connection;
+    use crate::sqlite::{ConnectionExtensions, SqliteConnection};
+
+    use super::*;
+
+    fn insert_transactions(connection: &SqliteConnection, records: Vec<CardanoTransactionRecord>) {
+        connection
+            .fetch_first(InsertCardanoTransactionQuery::insert_many(records).unwrap())
+            .unwrap();
+    }
+
+    #[test]
+    fn with_highest_block_number() {
+        let connection = cardano_tx_db_connection().unwrap();
+
+        let cursor = connection
+            .fetch(GetCardanoTransactionQuery::with_highest_block_number())
+            .unwrap();
+        assert_eq!(0, cursor.count());
+
+        insert_transactions(
+            &connection,
+            vec![
+                CardanoTransactionRecord::new("tx-hash-0", 10, 50, "block-hash-10", 1),
+                CardanoTransactionRecord::new("tx-hash-1", 10, 51, "block-hash-10", 1),
+                CardanoTransactionRecord::new("tx-hash-2", 11, 54, "block-hash-11", 1),
+                CardanoTransactionRecord::new("tx-hash-3", 11, 55, "block-hash-11", 1),
+            ],
+        );
+
+        let records: Vec<CardanoTransactionRecord> = connection
+            .fetch_collect(GetCardanoTransactionQuery::with_highest_block_number())
+            .unwrap();
+        assert_eq!(
+            vec![
+                CardanoTransactionRecord::new("tx-hash-2", 11, 54, "block-hash-11", 1),
+                CardanoTransactionRecord::new("tx-hash-3", 11, 55, "block-hash-11", 1),
+            ],
+            records
+        );
+    }
+}

internal/mithril-persistence/src/database/repository/cardano_transaction_repository.rs

@@ -3,12 +3,12 @@ use std::sync::Arc;
 
 use anyhow::Context;
 use async_trait::async_trait;
-use sqlite::Value;
 
+use mithril_common::cardano_block_scanner::ImmutableLowerBoundFinder;
 use mithril_common::crypto_helper::MKTreeNode;
 use mithril_common::entities::{
-    BlockHash, BlockNumber, BlockRange, CardanoTransaction, ImmutableFileNumber, SlotNumber,
-    TransactionHash,
+    BlockHash, BlockNumber, BlockRange, CardanoTransaction, ChainPoint, ImmutableFileNumber,
+    SlotNumber, TransactionHash,
 };
 use mithril_common::signable_builder::BlockRangeRootRetriever;
 use mithril_common::StdResult;
@@ -51,27 +51,6 @@ impl CardanoTransactionRepository {
             .fetch_collect(GetCardanoTransactionQuery::between_blocks(range))
     }
 
-    /// Return all the [CardanoTransactionRecord]s in the database up to the given beacon.
-    ///
-    /// Note: until we rely on block number based beacons, this function needs to compute the highest block number for the given immutable file number.
-    pub async fn get_transactions_up_to(
-        &self,
-        beacon: ImmutableFileNumber,
-    ) -> StdResult<Vec<CardanoTransactionRecord>> {
-        // Get the highest block number for the given immutable number.
-        // This is a temporary fix that will be removed when the retrieval is based on block number instead of immutable number.
-
-        if let Some(block_number) = self
-            .get_highest_block_number_for_immutable_number(beacon)
-            .await?
-        {
-            self.get_transactions_in_range_blocks(0..block_number + 1)
-                .await
-        } else {
-            Ok(vec![])
-        }
-    }
-
     /// Return the [CardanoTransactionRecord] for the given transaction hash.
     pub async fn get_transaction<T: Into<TransactionHash>>(
         &self,
@@ -127,22 +106,15 @@ impl CardanoTransactionRepository {
             .fetch_collect(InsertBlockRangeRootQuery::insert_many(records)?)
     }
 
-    // TODO: remove this function when the Cardano transaction signature is based on block number instead of immutable number
     /// Get the highest [BlockNumber] of the cardano transactions stored in the database.
-    pub async fn get_highest_block_number_for_immutable_number(
-        &self,
-        immutable_file_number: ImmutableFileNumber,
-    ) -> StdResult<Option<BlockNumber>> {
-        let highest: Option<i64> = self.connection.query_single_cell(
-            "select max(block_number) as highest from cardano_tx where immutable_file_number <= ?;",
-            &[Value::Integer(immutable_file_number as i64)],
-        )?;
-        highest
-            .map(u64::try_from)
-            .transpose()
-            .with_context(||
-                format!("Integer field max(block_number) (value={highest:?}) is incompatible with u64 representation.")
-            )
+    pub async fn get_transaction_highest_chain_point(&self) -> StdResult<Option<ChainPoint>> {
+        let first_transaction_with_highest_block_number = self
+            .connection
+            .fetch_first(GetCardanoTransactionQuery::with_highest_block_number())?;
+
+        Ok(first_transaction_with_highest_block_number.map(|record| {
+            ChainPoint::new(record.slot_number, record.block_number, record.block_hash)
+        }))
     }
 
     /// Get the highest start [BlockNumber] of the block range roots stored in the database.
@@ -288,24 +260,24 @@ impl CardanoTransactionRepository {
 impl BlockRangeRootRetriever for CardanoTransactionRepository {
     async fn retrieve_block_range_roots(
         &self,
-        up_to_beacon: ImmutableFileNumber,
+        up_to_beacon: BlockNumber,
     ) -> StdResult<Box<dyn Iterator<Item = (BlockRange, MKTreeNode)>>> {
-        // Get the highest block number for the given immutable number.
-        // This is a temporary fix that will be removed when the retrieval is based on block number instead of immutable number.
-        let block_number = self
-            .get_highest_block_number_for_immutable_number(up_to_beacon)
-            .await?
-            .unwrap_or(0);
-
         let iterator = self
-            .retrieve_block_range_roots_up_to(block_number)
+            .retrieve_block_range_roots_up_to(up_to_beacon)
             .await?
             .collect::<Vec<_>>() // TODO: remove this collect to return the iterator directly
             .into_iter();
         Ok(Box::new(iterator))
     }
 }
 
+#[async_trait]
+impl ImmutableLowerBoundFinder for CardanoTransactionRepository {
+    async fn find_lower_bound(&self) -> StdResult<Option<ImmutableFileNumber>> {
+        self.get_transaction_highest_immutable_file_number().await
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use mithril_common::test_utils::CardanoTransactionsBuilder;
@@ -450,60 +422,6 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn repository_get_up_to_beacon_transactions() {
-        let connection = Arc::new(cardano_tx_db_connection().unwrap());
-        let repository = CardanoTransactionRepository::new(connection);
-
-        let cardano_transactions: Vec<CardanoTransactionRecord> = CardanoTransactionsBuilder::new()
-            .max_transactions_per_immutable_file(10)
-            .first_immutable_file(120)
-            .build_transactions(40)
-            .into_iter()
-            .map(CardanoTransactionRecord::from)
-            .collect();
-
-        repository
-            .create_transactions(cardano_transactions.clone())
-            .await
-            .unwrap();
-
-        let transaction_result = repository.get_transactions_up_to(120).await.unwrap();
-        let transaction_up_to_immutable_file_number_12 = cardano_transactions[0..10].to_vec();
-        assert_eq!(
-            transaction_up_to_immutable_file_number_12,
-            transaction_result
-        );
-
-        let transaction_result = repository.get_transactions_up_to(300).await.unwrap();
-        let transaction_all = cardano_transactions[..].to_vec();
-        assert_eq!(transaction_all, transaction_result);
-
-        let transaction_result = repository.get_transactions_up_to(90).await.unwrap();
-        assert_eq!(Vec::<CardanoTransactionRecord>::new(), transaction_result);
-    }
-
-    #[tokio::test]
-    async fn get_transactions_up_to_return_empty_list_when_no_record_found_with_provided_immutable_file_number(
-    ) {
-        let connection = Arc::new(cardano_tx_db_connection().unwrap());
-        let repository = CardanoTransactionRepository::new(connection);
-
-        repository
-            .create_transactions(vec![CardanoTransaction::new(
-                "tx-hash-123".to_string(),
-                0,
-                50,
-                "block-hash-0",
-                99,
-            )])
-            .await
-            .unwrap();
-
-        let transaction_result = repository.get_transactions_up_to(90).await.unwrap();
-        assert_eq!(Vec::<CardanoTransactionRecord>::new(), transaction_result);
-    }
-
     #[tokio::test]
     async fn repository_get_all_stored_transactions() {
         let connection = Arc::new(cardano_tx_db_connection().unwrap());
@@ -563,6 +481,46 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn repository_get_transaction_highest_chain_point_without_transactions_in_db() {
+        let connection = Arc::new(cardano_tx_db_connection().unwrap());
+        let repository = CardanoTransactionRepository::new(connection);
+
+        let highest_beacon = repository
+            .get_transaction_highest_chain_point()
+            .await
+            .unwrap();
+        assert_eq!(None, highest_beacon);
+    }
+
+    #[tokio::test]
+    async fn repository_get_transaction_highest_chain_point_with_transactions_in_db() {
+        let connection = Arc::new(cardano_tx_db_connection().unwrap());
+        let repository = CardanoTransactionRepository::new(connection);
+
+        let cardano_transactions = vec![
+            CardanoTransaction::new("tx-hash-123", 10, 50, "block-hash-10", 50),
+            CardanoTransaction::new("tx-hash-456", 25, 51, "block-hash-25", 100),
+        ];
+        repository
+            .create_transactions(cardano_transactions)
+            .await
+            .unwrap();
+
+        let highest_beacon = repository
+            .get_transaction_highest_chain_point()
+            .await
+            .unwrap();
+        assert_eq!(
+            Some(ChainPoint {
+                slot_number: 51,
+                block_number: 25,
+                block_hash: "block-hash-25".to_string()
+            }),
+            highest_beacon
+        );
+    }
+
     #[tokio::test]
     async fn repository_get_transaction_highest_immutable_file_number_without_transactions_in_db() {
         let connection = Arc::new(cardano_tx_db_connection().unwrap());
@@ -953,4 +911,22 @@ mod tests {
             .unwrap();
         assert_eq!(Some(30), highest);
     }
+
+    #[tokio::test]
+    async fn find_block_scanner_lower_bound() {
+        let connection = Arc::new(cardano_tx_db_connection().unwrap());
+        let repository = CardanoTransactionRepository::new(connection);
+
+        let cardano_transactions = vec![
+            CardanoTransaction::new("tx-hash-123".to_string(), 10, 50, "block-hash-123", 50),
+            CardanoTransaction::new("tx-hash-456".to_string(), 11, 51, "block-hash-456", 100),
+        ];
+        repository
+            .create_transactions(cardano_transactions)
+            .await
+            .unwrap();
+
+        let highest_beacon = repository.find_lower_bound().await.unwrap();
+        assert_eq!(Some(100), highest_beacon);
+    }
 }

internal/mithril-persistence/src/database/version_checker.rs

@@ -165,10 +165,10 @@ pub struct SqlMigration {
 
 impl SqlMigration {
     /// Create a new SQL migration instance.
-    pub fn new(version: DbVersion, alteration: &str) -> Self {
+    pub fn new<T: Into<String>>(version: DbVersion, alteration: T) -> Self {
         Self {
             version,
-            alterations: alteration.to_string(),
+            alterations: alteration.into(),
         }
     }
 }