feat: add tx details table

Author: ben-kaufman

src/lib.rs

@@ -10,7 +10,7 @@ pub use modules::scanner::{
 pub use modules::lnurl;
 pub use modules::onchain;
 pub use modules::activity;
-use crate::activity::{ActivityError, ActivityDB, OnchainActivity, LightningActivity, Activity, ActivityFilter, SortDirection, PaymentType, DbError, ClosedChannelDetails, ActivityTags, PreActivityMetadata};
+use crate::activity::{ActivityError, ActivityDB, OnchainActivity, LightningActivity, Activity, ActivityFilter, SortDirection, PaymentType, DbError, ClosedChannelDetails, ActivityTags, PreActivityMetadata, TransactionDetails, TxInput, TxOutput};
 use crate::modules::blocktank::{BlocktankDB, BlocktankError, IBtInfo, IBtOrder, CreateOrderOptions, BtOrderState2, IBt0ConfMinTxFeeWindow, IBtEstimateFeeResponse, IBtEstimateFeeResponse2, CreateCjitOptions, ICJitEntry, CJitStateEnum, IBtBolt11Invoice, IGift, ChannelLiquidityOptions, ChannelLiquidityParams, DefaultLspBalanceParams};
 use crate::onchain::{AddressError, ValidationResult, GetAddressResponse, Network, GetAddressesResponse};
 pub use crate::onchain::WordCount;
@@ -1444,6 +1444,51 @@ pub fn mark_activity_as_seen(activity_id: String, seen_at: u64) -> Result<(), Ac
     db.mark_activity_as_seen(&activity_id, seen_at)
 }
 
+#[uniffi::export]
+pub fn upsert_transaction_details(details_list: Vec<TransactionDetails>) -> Result<(), ActivityError> {
+    let mut guard = get_activity_db()?;
+    let db = guard.activity_db.as_mut().ok_or(ActivityError::ConnectionError {
+        error_details: "Database not initialized. Call init_db first.".to_string()
+    })?;
+    db.upsert_transaction_details(&details_list)
+}
+
+#[uniffi::export]
+pub fn get_transaction_details(tx_id: String) -> Result<Option<TransactionDetails>, ActivityError> {
+    let guard = get_activity_db()?;
+    let db = guard.activity_db.as_ref().ok_or(ActivityError::ConnectionError {
+        error_details: "Database not initialized. Call init_db first.".to_string()
+    })?;
+    db.get_transaction_details(&tx_id)
+}
+
+#[uniffi::export]
+pub fn get_all_transaction_details() -> Result<Vec<TransactionDetails>, ActivityError> {
+    let guard = get_activity_db()?;
+    let db = guard.activity_db.as_ref().ok_or(ActivityError::ConnectionError {
+        error_details: "Database not initialized. Call init_db first.".to_string()
+    })?;
+    db.get_all_transaction_details()
+}
+
+#[uniffi::export]
+pub fn delete_transaction_details(tx_id: String) -> Result<bool, ActivityError> {
+    let mut guard = get_activity_db()?;
+    let db = guard.activity_db.as_mut().ok_or(ActivityError::ConnectionError {
+        error_details: "Database not initialized. Call init_db first.".to_string()
+    })?;
+    db.delete_transaction_details(&tx_id)
+}
+
+#[uniffi::export]
+pub fn wipe_all_transaction_details() -> Result<(), ActivityError> {
+    let mut guard = get_activity_db()?;
+    let db = guard.activity_db.as_mut().ok_or(ActivityError::ConnectionError {
+        error_details: "Database not initialized. Call init_db first.".to_string()
+    })?;
+    db.wipe_all_transaction_details()
+}
+
 #[uniffi::export]
 pub async fn blocktank_remove_all_orders() -> Result<(), BlocktankError> {
     let rt = ensure_runtime();

src/modules/activity/implementation.rs

@@ -1,6 +1,6 @@
 use rusqlite::{Connection, OptionalExtension};
 use serde_json;
-use crate::activity::{Activity, ActivityError, ActivityFilter, LightningActivity, OnchainActivity, PaymentState, PaymentType, SortDirection, ClosedChannelDetails, ActivityTags, PreActivityMetadata};
+use crate::activity::{Activity, ActivityError, ActivityFilter, LightningActivity, OnchainActivity, PaymentState, PaymentType, SortDirection, ClosedChannelDetails, ActivityTags, PreActivityMetadata, TransactionDetails, TxInput, TxOutput};
 
 pub struct ActivityDB {
     pub conn: Connection,
@@ -96,6 +96,14 @@ const CREATE_CLOSED_CHANNELS_TABLE: &str = "
         channel_closure_reason TEXT NOT NULL
     )";
 
+const CREATE_TRANSACTION_DETAILS_TABLE: &str = "
+    CREATE TABLE IF NOT EXISTS transaction_details (
+        tx_id TEXT PRIMARY KEY,
+        amount_sats INTEGER NOT NULL,
+        inputs TEXT NOT NULL,
+        outputs TEXT NOT NULL
+    )";
+
 const UPSERT_CLOSED_CHANNEL_SQL: &str = "
     INSERT OR REPLACE INTO closed_channels (
         channel_id, counterparty_node_id, funding_txo_txid, funding_txo_index,
@@ -248,6 +256,13 @@ impl ActivityDB {
             });
         }
 
+        // Create transaction details table
+        if let Err(e) = self.conn.execute(CREATE_TRANSACTION_DETAILS_TABLE, []) {
+            return Err(ActivityError::InitializationError {
+                error_details: format!("Error creating transaction_details table: {}", e),
+            });
+        }
+
         // Create indexes
         for statement in INDEX_STATEMENTS {
             if let Err(e) = self.conn.execute(statement, []) {
@@ -2051,6 +2066,157 @@ impl ActivityDB {
         Ok(rows > 0)
     }
 
+    /// Upserts transaction details for one or more onchain transactions.
+    pub fn upsert_transaction_details(&mut self, details_list: &[TransactionDetails]) -> Result<(), ActivityError> {
+        if details_list.is_empty() {
+            return Ok(());
+        }
+
+        let tx = self.conn.transaction().map_err(|e| ActivityError::DataError {
+            error_details: format!("Failed to start transaction: {}", e),
+        })?;
+
+        {
+            let mut stmt = tx.prepare(
+                "INSERT OR REPLACE INTO transaction_details (tx_id, amount_sats, inputs, outputs) VALUES (?1, ?2, ?3, ?4)"
+            ).map_err(|e| ActivityError::DataError {
+                error_details: format!("Failed to prepare statement: {}", e),
+            })?;
+
+            for details in details_list {
+                if details.tx_id.is_empty() {
+                    return Err(ActivityError::DataError {
+                        error_details: "Transaction ID cannot be empty".to_string(),
+                    });
+                }
+
+                let inputs_json = serde_json::to_string(&details.inputs).map_err(|e| ActivityError::DataError {
+                    error_details: format!("Failed to serialize inputs: {}", e),
+                })?;
+
+                let outputs_json = serde_json::to_string(&details.outputs).map_err(|e| ActivityError::DataError {
+                    error_details: format!("Failed to serialize outputs: {}", e),
+                })?;
+
+                stmt.execute(rusqlite::params![
+                    &details.tx_id,
+                    details.amount_sats,
+                    &inputs_json,
+                    &outputs_json,
+                ]).map_err(|e| ActivityError::InsertError {
+                    error_details: format!("Failed to upsert transaction details: {}", e),
+                })?;
+            }
+        }
+
+        tx.commit().map_err(|e| ActivityError::DataError {
+            error_details: format!("Failed to commit transaction: {}", e),
+        })?;
+
+        Ok(())
+    }
+
+    /// Retrieves transaction details by transaction ID.
+    pub fn get_transaction_details(&self, tx_id: &str) -> Result<Option<TransactionDetails>, ActivityError> {
+        let sql = "SELECT tx_id, amount_sats, inputs, outputs FROM transaction_details WHERE tx_id = ?1";
+
+        let mut stmt = self.conn.prepare(sql).map_err(|e| ActivityError::RetrievalError {
+            error_details: format!("Failed to prepare statement: {}", e),
+        })?;
+
+        match stmt.query_row([tx_id], |row| {
+            let tx_id: String = row.get(0)?;
+            let amount_sats: i64 = row.get(1)?;
+            let inputs_json: String = row.get(2)?;
+            let outputs_json: String = row.get(3)?;
+
+            let inputs: Vec<TxInput> = serde_json::from_str(&inputs_json).map_err(|_| {
+                rusqlite::Error::InvalidColumnType(2, "inputs".to_string(), rusqlite::types::Type::Text)
+            })?;
+
+            let outputs: Vec<TxOutput> = serde_json::from_str(&outputs_json).map_err(|_| {
+                rusqlite::Error::InvalidColumnType(3, "outputs".to_string(), rusqlite::types::Type::Text)
+            })?;
+
+            Ok(TransactionDetails {
+                tx_id,
+                amount_sats,
+                inputs,
+                outputs,
+            })
+        }) {
+            Ok(details) => Ok(Some(details)),
+            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+            Err(e) => Err(ActivityError::RetrievalError {
+                error_details: format!("Failed to get transaction details: {}", e),
+            }),
+        }
+    }
+
+    /// Retrieves all transaction details.
+    pub fn get_all_transaction_details(&self) -> Result<Vec<TransactionDetails>, ActivityError> {
+        let sql = "SELECT tx_id, amount_sats, inputs, outputs FROM transaction_details ORDER BY tx_id";
+
+        let mut stmt = self.conn.prepare(sql).map_err(|e| ActivityError::RetrievalError {
+            error_details: format!("Failed to prepare statement: {}", e),
+        })?;
+
+        let rows = stmt.query_map([], |row| {
+            let tx_id: String = row.get(0)?;
+            let amount_sats: i64 = row.get(1)?;
+            let inputs_json: String = row.get(2)?;
+            let outputs_json: String = row.get(3)?;
+
+            let inputs: Vec<TxInput> = serde_json::from_str(&inputs_json).map_err(|_| {
+                rusqlite::Error::InvalidColumnType(2, "inputs".to_string(), rusqlite::types::Type::Text)
+            })?;
+
+            let outputs: Vec<TxOutput> = serde_json::from_str(&outputs_json).map_err(|_| {
+                rusqlite::Error::InvalidColumnType(3, "outputs".to_string(), rusqlite::types::Type::Text)
+            })?;
+
+            Ok(TransactionDetails {
+                tx_id,
+                amount_sats,
+                inputs,
+                outputs,
+            })
+        }).map_err(|e| ActivityError::RetrievalError {
+            error_details: format!("Failed to execute query: {}", e),
+        })?;
+
+        let mut results = Vec::new();
+        for row in rows {
+            results.push(row.map_err(|e| ActivityError::DataError {
+                error_details: format!("Failed to process row: {}", e),
+            })?);
+        }
+
+        Ok(results)
+    }
+
+    /// Deletes transaction details by transaction ID.
+    pub fn delete_transaction_details(&mut self, tx_id: &str) -> Result<bool, ActivityError> {
+        let rows = self.conn.execute(
+            "DELETE FROM transaction_details WHERE tx_id = ?1",
+            [tx_id],
+        ).map_err(|e| ActivityError::DataError {
+            error_details: format!("Failed to delete transaction details: {}", e),
+        })?;
+
+        Ok(rows > 0)
+    }
+
+    /// Wipes all transaction details from the database.
+    pub fn wipe_all_transaction_details(&mut self) -> Result<(), ActivityError> {
+        self.conn.execute("DELETE FROM transaction_details", [])
+            .map_err(|e| ActivityError::DataError {
+                error_details: format!("Failed to delete all transaction details: {}", e),
+            })?;
+
+        Ok(())
+    }
+
     /// Wipes all activity data from the database
     /// This deletes all activities, which cascades to delete all activity_tags due to foreign key constraints.
     /// Also deletes all pre_activity_metadata and closed_channels.
@@ -2077,6 +2243,12 @@ impl ActivityDB {
                 error_details: format!("Failed to delete all closed channels: {}", e),
             })?;
 
+        // Delete all transaction details
+        tx.execute("DELETE FROM transaction_details", [])
+            .map_err(|e| ActivityError::DataError {
+                error_details: format!("Failed to delete all transaction details: {}", e),
+            })?;
+
         tx.commit().map_err(|e| ActivityError::DataError {
             error_details: format!("Failed to commit transaction: {}", e),
         })?;