feat: Get slot number by provided date-time endpoint

Earthfile

@@ -7,17 +7,17 @@ FROM debian:stable-slim
 
 # check-markdown markdown check using catalyst-ci.
 check-markdown:
-    DO github.com/input-output-hk/catalyst-ci/earthly/mdlint:v2.11.0+CHECK
+    DO github.com/input-output-hk/catalyst-ci/earthly/mdlint:v2.11.1+CHECK
 
 # markdown-check-fix markdown check and fix using catalyst-ci.
 markdown-check-fix:
     LOCALLY
 
-    DO github.com/input-output-hk/catalyst-ci/earthly/mdlint:v2.11.0+MDLINT_LOCALLY --src=$(echo ${PWD}) --fix=--fix
+    DO github.com/input-output-hk/catalyst-ci/earthly/mdlint:v2.11.1+MDLINT_LOCALLY --src=$(echo ${PWD}) --fix=--fix
 
 # check-spelling Check spelling in this repo inside a container.
 check-spelling:
-    DO github.com/input-output-hk/catalyst-ci/earthly/cspell:v2.11.0+CHECK
+    DO github.com/input-output-hk/catalyst-ci/earthly/cspell:v2.11.1+CHECK
 
 repo-docs:
     # Create artifacts of extra files we embed inside the documentation when its built.

catalyst-gateway/Cargo.toml

@@ -46,8 +46,11 @@ local-ip-address = "0.5.7"
 gethostname = "0.4.3"
 hex = "0.4.3"
 async-recursion = "1.0.5"
-pallas = { git = "https://github.com/input-output-hk/catalyst-pallas.git", branch = "fix/immutable-secondary", version = "0.24.0" }
+handlebars = "5.1.2"
 anyhow = "1.0.71"
+cddl = "0.9.2"
+ciborium = "0.2"
+pallas = { git = "https://github.com/input-output-hk/catalyst-pallas.git", branch = "fix/immutable-secondary", version = "0.24.0" }
 cardano-chain-follower= { git = "https://github.com/input-output-hk/hermes.git", version="0.0.1" }
 
 [workspace.lints.rust]

catalyst-gateway/Earthfile

@@ -4,7 +4,7 @@ VERSION --try --global-cache 0.7
 
 # Set up our target toolchains, and copy our files.
 builder:
-    DO github.com/input-output-hk/catalyst-ci/earthly/rust:v2.11.0+SETUP
+    DO github.com/input-output-hk/catalyst-ci/earthly/rust:v2.11.1+SETUP
 
     COPY --dir .cargo .config Cargo.* clippy.toml deny.toml rustfmt.toml bin crates .
     COPY --dir ./event-db/queries ./event-db/queries

catalyst-gateway/bin/Cargo.toml

@@ -66,5 +66,6 @@ async-recursion = { workspace = true }
 pallas = { workspace = true }
 cardano-chain-follower= { workspace = true }
 anyhow = { workspace = true }
-cddl = "0.9.2"
-ciborium = "0.2"
+handlebars = { workspace = true }
+cddl = { workspace = true }
+ciborium = { workspace = true }

catalyst-gateway/bin/src/event_db/follower.rs

@@ -1,11 +1,12 @@
 //! Follower Queries
 
 use cardano_chain_follower::Network;
+use handlebars::Handlebars;
 
 use crate::event_db::{Error, EventDB};
 
 /// Block time
-pub type BlockTime = chrono::DateTime<chrono::offset::Utc>;
+pub type DateTime = chrono::DateTime<chrono::offset::Utc>;
 /// Slot
 pub type SlotNumber = i64;
 /// Epoch
@@ -15,99 +16,167 @@ pub type BlockHash = String;
 /// Unique follower id
 pub type MachineId = String;
 
+/// `slot_no` column name
+const SLOT_NO_COLUMN: &str = "slot_no";
+/// `block_hash` column name
+const BLOCK_HASH_COLUMN: &str = "block_hash";
+/// `block_time` column name
+const BLOCK_TIME_COLUMN: &str = "block_time";
+/// `ended` column name
+const ENDED_COLUMN: &str = "ended";
+
+/// `insert_slot_index.sql`
+const INSERT_SLOT_INDEX_SQL: &str =
+    include_str!("../../../event-db/queries/follower/insert_slot_index.sql");
+/// `select_slot_info_by_datetime.sql.tmpl`
+const SLOT_INFO_SQL_TMPL: &str =
+    include_str!("../../../event-db/queries/follower/select_slot_info_by_datetime.sql.tmpl");
+
+/// Query type
+pub(crate) enum SlotInfoQueryType {
+    /// Previous slot info query type
+    Previous,
+    /// Current slot info query type
+    Current,
+    /// Next slot info query type
+    Next,
+}
+
+/// Slot info query template fields
+#[derive(serde::Serialize)]
+struct SlotInfoQueryTmplFields {
+    /// `sign` field from the sql template
+    sign: &'static str,
+    /// `ordering` field from the sql template
+    ordering: Option<&'static str>,
+}
+
+impl SlotInfoQueryType {
+    /// Get SQL query
+    fn get_sql_query(&self) -> Result<String, Error> {
+        let mut reg = Handlebars::new();
+        // disable default `html_escape` function
+        // which transforms `<`, `>` symbols to `&lt`, `&gt`
+        reg.register_escape_fn(|s| s.into());
+        let query = match self {
+            SlotInfoQueryType::Previous => {
+                reg.render_template(SLOT_INFO_SQL_TMPL, &SlotInfoQueryTmplFields {
+                    sign: "<",
+                    ordering: Some("DESC"),
+                })
+            },
+            SlotInfoQueryType::Current => {
+                reg.render_template(SLOT_INFO_SQL_TMPL, &SlotInfoQueryTmplFields {
+                    sign: "=",
+                    ordering: None,
+                })
+            },
+            SlotInfoQueryType::Next => {
+                reg.render_template(SLOT_INFO_SQL_TMPL, &SlotInfoQueryTmplFields {
+                    sign: ">",
+                    ordering: None,
+                })
+            },
+        };
+        query.map_err(|e| Error::Unknown(e.to_string()))
+    }
+}
+
 impl EventDB {
     /// Index follower block stream
     pub(crate) async fn index_follower_data(
-        &self, slot_no: SlotNumber, network: Network, epoch_no: EpochNumber, block_time: BlockTime,
+        &self, slot_no: SlotNumber, network: Network, epoch_no: EpochNumber, block_time: DateTime,
         block_hash: BlockHash,
     ) -> Result<(), Error> {
         let conn = self.pool.get().await?;
 
-        let network = match network {
-            Network::Mainnet => "mainnet".to_string(),
-            Network::Preview => "preview".to_string(),
-            Network::Preprod => "preprod".to_string(),
-            Network::Testnet => "testnet".to_string(),
-        };
-
         let _rows = conn
-            .query(
-                include_str!("../../../event-db/queries/follower/insert_slot_index.sql"),
-                &[
-                    &slot_no,
-                    &network,
-                    &epoch_no,
-                    &block_time,
-                    &hex::decode(block_hash).map_err(|e| Error::DecodeHex(e.to_string()))?,
-                ],
-            )
+            .query(INSERT_SLOT_INDEX_SQL, &[
+                &slot_no,
+                &network.to_string(),
+                &epoch_no,
+                &block_time,
+                &hex::decode(block_hash).map_err(|e| Error::DecodeHex(e.to_string()))?,
+            ])
             .await?;
 
         Ok(())
     }
 
+    /// Get slot info for the provided date-time and network and query type
+    pub(crate) async fn get_slot_info(
+        &self, date_time: DateTime, network: Network, query_type: SlotInfoQueryType,
+    ) -> Result<(SlotNumber, BlockHash, DateTime), Error> {
+        let conn = self.pool.get().await?;
+
+        let rows = conn
+            .query(&query_type.get_sql_query()?, &[
+                &network.to_string(),
+                &date_time,
+            ])
+            .await?;
+
+        let Some(row) = rows.first() else {
+            return Err(Error::NotFound);
+        };
+
+        let slot_number: SlotNumber = row.try_get(SLOT_NO_COLUMN)?;
+        let block_hash = hex::encode(row.try_get::<_, Vec<u8>>(BLOCK_HASH_COLUMN)?);
+        let block_time = row.try_get(BLOCK_TIME_COLUMN)?;
+        Ok((slot_number, block_hash, block_time))
+    }
+
     /// Check when last update occurred.
     /// Start follower from where previous follower left off.
     pub(crate) async fn last_updated_metadata(
         &self, network: Network,
-    ) -> Result<(SlotNumber, BlockHash, BlockTime), Error> {
+    ) -> Result<(SlotNumber, BlockHash, DateTime), Error> {
         let conn = self.pool.get().await?;
 
-        let network = match network {
-            Network::Mainnet => "mainnet".to_string(),
-            Network::Preview => "preview".to_string(),
-            Network::Preprod => "preprod".to_string(),
-            Network::Testnet => "testnet".to_string(),
-        };
-
         let rows = conn
             .query(
                 include_str!("../../../event-db/queries/follower/select_update_state.sql"),
-                &[&network],
+                &[&network.to_string()],
             )
             .await?;
 
         let Some(row) = rows.first() else {
             return Err(Error::NotFound);
         };
 
-        let slot_no = row.try_get("slot_no")?;
-        let block_hash = hex::encode(row.try_get::<_, Vec<u8>>("block_hash")?);
-        let last_updated = row.try_get("ended")?;
+        let slot_no = row.try_get(SLOT_NO_COLUMN)?;
+        let block_hash = hex::encode(row.try_get::<_, Vec<u8>>(BLOCK_HASH_COLUMN)?);
+        let last_updated = row.try_get(ENDED_COLUMN)?;
 
         Ok((slot_no, block_hash, last_updated))
     }
 
     /// Mark point in time where the last follower finished indexing in order for future
     /// followers to pick up from this point
     pub(crate) async fn refresh_last_updated(
-        &self, last_updated: BlockTime, slot_no: SlotNumber, block_hash: BlockHash,
+        &self, last_updated: DateTime, slot_no: SlotNumber, block_hash: BlockHash,
         network: Network, machine_id: &MachineId,
     ) -> Result<(), Error> {
         let conn = self.pool.get().await?;
 
         // Rollback or update
         let update = true;
 
-        let (id, network) = match network {
-            Network::Mainnet => (1, "mainnet".to_string()),
-            Network::Preview => (2, "preview".to_string()),
-            Network::Preprod => (3, "preprod".to_string()),
-            Network::Testnet => (4, "testnet".to_string()),
-        };
+        let network_id: u64 = network.into();
 
         // An insert only happens once when there is no update metadata available
         // All future additions are just updates on ended, slot_no and block_hash
         let _rows = conn
             .query(
                 include_str!("../../../event-db/queries/follower/insert_update_state.sql"),
                 &[
-                    &i64::from(id),
+                    &i64::try_from(network_id)
+                        .map_err(|_| Error::Unknown("Network id out of range".to_string()))?,
                     &last_updated,
                     &last_updated,
                     &machine_id,
                     &slot_no,
-                    &network,
+                    &network.to_string(),
                     &hex::decode(block_hash).map_err(|e| Error::DecodeHex(e.to_string()))?,
                     &update,
                 ],

catalyst-gateway/bin/src/event_db/utxo.rs

@@ -82,17 +82,10 @@ impl EventDB {
     ) -> Result<(), Error> {
         let conn = self.pool.get().await?;
 
-        let network = match network {
-            Network::Mainnet => "mainnet".to_string(),
-            Network::Preview => "preview".to_string(),
-            Network::Preprod => "preprod".to_string(),
-            Network::Testnet => "testnet".to_string(),
-        };
-
         let _rows = conn
             .query(
                 include_str!("../../../event-db/queries/utxo/insert_txn_index.sql"),
-                &[&tx_id, &slot_no, &network],
+                &[&tx_id, &slot_no, &network.to_string()],
             )
             .await?;
 
@@ -105,17 +98,10 @@ impl EventDB {
     ) -> Result<(StakeAmount, SlotNumber), Error> {
         let conn = self.pool.get().await?;
 
-        let network = match network {
-            Network::Mainnet => "mainnet".to_string(),
-            Network::Preview => "preview".to_string(),
-            Network::Preprod => "preprod".to_string(),
-            Network::Testnet => "testnet".to_string(),
-        };
-
         let row = conn
             .query_one(
                 include_str!("../../../event-db/queries/utxo/select_total_utxo_amount.sql"),
-                &[&stake_credential, &network, &slot_num],
+                &[&stake_credential, &network.to_string(), &slot_num],
             )
             .await?;