feat(athena): Handle rollback and roll-forward for block event in rbac-registration module (#546)

* feat: implement rollback rolforward block handler

Signed-off-by: bkioshn <[email protected]>

* fix: cleanup

Signed-off-by: bkioshn <[email protected]>

* fix: finalize

Signed-off-by: bkioshn <[email protected]>

---------

Signed-off-by: bkioshn <[email protected]>

Author: bkioshn

hermes/apps/athena/modules/rbac-registration/Cargo.toml

@@ -10,6 +10,8 @@ crate-type = ["cdylib"]
 wit-bindgen = "0.43.0"
 anyhow = "1.0.98"
 serde_json = "1.0.142"
+strum = "0.27.2"
+strum_macros = "0.27.2"
 
 cardano-blockchain-types = { version = "0.0.6", git = "https://github.com/input-output-hk/catalyst-libs", tag = "cardano-blockchain-types/v0.0.6" }
 rbac-registration = { version = "0.0.9", git = "https://github.com/input-output-hk/catalyst-libs", tag = "rbac-registration/v0.0.9" }

hermes/apps/athena/modules/rbac-registration/src/database/create.rs

@@ -1,61 +1,55 @@
 //! Create the database tables for RBAC registration.
 
-use crate::{hermes::sqlite::api::Sqlite, utils::log::log_error};
+use crate::{
+    database::{
+        operation::Operation, query_builder::QueryBuilder, statement::DatabaseStatement,
+        RBAC_REGISTRATION_PERSISTENT_TABLE_NAME, RBAC_REGISTRATION_VOLATILE_TABLE_NAME,
+        RBAC_STAKE_ADDRESS_PERSISTENT_TABLE_NAME, RBAC_STAKE_ADDRESS_VOLATILE_TABLE_NAME,
+    },
+    hermes::sqlite::api::Sqlite,
+};
 
-/// RBAC registration database schema.
-const RBAC_REGISTRATION_TABLE: &str = r#"
-    CREATE TABLE IF NOT EXISTS rbac_registration (
-        txn_id          BLOB NOT NULL,      -- 32 bytes of transaction ID (aka transaction hash)
-        slot_no         INTEGER NOT NULL,   -- Slot number
-        txn_idx         INTEGER NOT NULL,   -- Index of the transaction in the block
-        prv_txn_id      BLOB,               -- 32 bytes of previous transaction ID (aka transaction hash)
-        purpose         TEXT,               -- Registration purpose
-        catalyst_id     TEXT,               -- Catalyst short ID - Exist only for Role0
-        problem_report  TEXT,               -- Problem report
+/// Create a persistent `rbac_registration` and `rbac_stake_address` table.
+pub(crate) fn create_rbac_persistent_tables(sqlite: &Sqlite) {
+    const FUNCTION_NAME: &str = "create_rbac_persistent_tables";
 
-        PRIMARY KEY (txn_id)
-
-    );
-    -- Use for root lookup by catalyst_id
-    CREATE INDEX IF NOT EXISTS idx_rbac_reg_cat_id ON rbac_registration (catalyst_id, slot_no, txn_idx);    
-    -- Child lookup
-    CREATE INDEX IF NOT EXISTS idx_rbac_reg_prv_tx ON rbac_registration (prv_txn_id, slot_no, txn_idx);
-"#;
+    if let Err(_) = DatabaseStatement::execute_statement(
+        sqlite,
+        &QueryBuilder::create_rbac_registration_table(RBAC_REGISTRATION_PERSISTENT_TABLE_NAME),
+        Operation::Create,
+        FUNCTION_NAME,
+    ) {
+        return;
+    }
 
-/// RBAC registration stake address database schema.
-const RBAC_STAKE_ADDRESS_TABLE: &str = r#"
-    CREATE TABLE IF NOT EXISTS rbac_stake_address (
-        stake_address   BLOB NOT NULL,      -- 29 bytes of stake hash (CIP19)
-        slot_no         INTEGER NOT NULL,   -- Slot number
-        txn_idx         INTEGER NOT NULL,   -- Index of the transaction in the block
-        catalyst_id     TEXT,               -- Catalyst short ID - Exist only for Role0
-        txn_id          BLOB NOT NULL,      -- 32 bytes of transaction ID (aka transaction hash)
+    if let Err(_) = DatabaseStatement::execute_statement(
+        sqlite,
+        &QueryBuilder::create_rbac_stake_address_table(RBAC_STAKE_ADDRESS_PERSISTENT_TABLE_NAME),
+        Operation::Create,
+        FUNCTION_NAME,
+    ) {
+        return;
+    }
+}
 
-        PRIMARY KEY (stake_address, txn_id)
-    );
-    -- Stake lookup (always want the newest registration first)
-    CREATE INDEX IF NOT EXISTS idx_stake_addr ON rbac_stake_address (stake_address, slot_no DESC, txn_idx DESC);
-"#;
+/// Create a volatile `rbac_registration` and `rbac_stake_address` table.
+pub(crate) fn create_rbac_volatile_tables(sqlite: &Sqlite) {
+    const FUNCTION_NAME: &str = "create_rbac_volatile_tables";
 
-/// Create a `rbac_registration` and `rbac_stake_address` table.
-pub(crate) fn create_rbac_tables(sqlite: &Sqlite) {
-    const FUNCTION_NAME: &str = "create_rbac_tables";
-    if let Err(e) = sqlite.execute(RBAC_REGISTRATION_TABLE) {
-        log_error(
-            file!(),
-            FUNCTION_NAME,
-            "hermes::sqlite::api::execute",
-            &format!("Failed to create rbac_registration table: {e}"),
-            None,
-        );
+    if let Err(_) = DatabaseStatement::execute_statement(
+        sqlite,
+        &QueryBuilder::create_rbac_registration_table(RBAC_REGISTRATION_VOLATILE_TABLE_NAME),
+        Operation::Create,
+        FUNCTION_NAME,
+    ) {
+        return;
     }
-    if let Err(e) = sqlite.execute(RBAC_STAKE_ADDRESS_TABLE) {
-        log_error(
-            file!(),
-            FUNCTION_NAME,
-            "hermes::sqlite::api::execute",
-            &format!("Failed to create rbac_stake_address table: {e}"),
-            None,
-        );
+    if let Err(_) = DatabaseStatement::execute_statement(
+        sqlite,
+        &QueryBuilder::create_rbac_stake_address_table(RBAC_STAKE_ADDRESS_VOLATILE_TABLE_NAME),
+        Operation::Create,
+        FUNCTION_NAME,
+    ) {
+        return;
     }
 }

hermes/apps/athena/modules/rbac-registration/src/database/delete/mod.rs

@@ -0,0 +1,4 @@
+//! Database DELETE operation.
+
+pub(crate) mod roll_back;
+pub(crate) mod roll_forward;

hermes/apps/athena/modules/rbac-registration/src/database/delete/roll_back.rs

@@ -0,0 +1,32 @@
+//! Handle block rollback from volatile table.
+
+use crate::{
+    database::{operation::Operation, query_builder::QueryBuilder, statement::DatabaseStatement},
+    hermes::sqlite::api::{Sqlite, Statement},
+};
+
+/// Prepare delete statement for deleting data when rollback happen from given volatile table.
+pub(crate) fn prepare_roll_back_delete_from_volatile(
+    sqlite: &Sqlite,
+    table: &str,
+) -> anyhow::Result<Statement> {
+    const FUNCTION_NAME: &str = "prepare_roll_back_delete_from_volatile";
+    DatabaseStatement::prepare_statement(
+        sqlite,
+        &QueryBuilder::delete_roll_back(table),
+        Operation::Delete,
+        FUNCTION_NAME,
+    )
+    .map_err(|e| anyhow::anyhow!(e))
+}
+
+/// Delete data for handling rollback from volatile table.
+pub(crate) fn roll_back_delete_from_volatile(
+    stmt: &Statement,
+    slot_no: u64,
+) {
+    const FUNCTION_NAME: &str = "roll_back_delete_from_volatile";
+    if let Err(_) = DatabaseStatement::bind_slot(stmt, slot_no, FUNCTION_NAME) {
+        return;
+    }
+}

hermes/apps/athena/modules/rbac-registration/src/database/delete/roll_forward.rs

@@ -0,0 +1,33 @@
+//! Handle block forward from volatile table.
+
+use crate::{
+    database::{operation::Operation, query_builder::QueryBuilder, statement::DatabaseStatement},
+    hermes::sqlite::api::{Sqlite, Statement},
+};
+
+/// Prepare delete statement for deleting data for roll forward from given volatile table.
+pub(crate) fn prepare_roll_forward_delete_from_volatile(
+    sqlite: &Sqlite,
+    table: &str,
+) -> anyhow::Result<Statement> {
+    const FUNCTION_NAME: &str = "prepare_roll_forward_delete_from_volatile";
+    DatabaseStatement::prepare_statement(
+        sqlite,
+        &QueryBuilder::delete_roll_forward(table),
+        Operation::Delete,
+        FUNCTION_NAME,
+    )
+    .map_err(|e| anyhow::anyhow!(e))
+}
+
+/// Delete data for handling roll forward from volatile table.
+pub(crate) fn roll_forward_delete_from_volatile(
+    stmt: &Statement,
+    slot_no: u64,
+) {
+    const FUNCTION_NAME: &str = "roll_forward_delete_from_volatile";
+
+    if let Err(_) = DatabaseStatement::bind_slot(stmt, slot_no, FUNCTION_NAME) {
+        return;
+    }
+}

hermes/apps/athena/modules/rbac-registration/src/database/insert.rs

@@ -0,0 +1,4 @@
+//! Database INSERT operation.
+
+pub(crate) mod rbac_table;
+pub(crate) mod stake_addr_table;