feat: add seen at to activity

Author: ben-kaufman

src/lib.rs

@@ -1435,6 +1435,15 @@ pub fn is_address_used(address: String) -> Result<bool, ActivityError> {
     db.is_address_used(&address)
 }
 
+#[uniffi::export]
+pub fn mark_activity_as_seen(activity_id: String, seen_at: u64) -> 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.mark_activity_as_seen(&activity_id, seen_at)
+}
+
 #[uniffi::export]
 pub async fn blocktank_remove_all_orders() -> Result<(), BlocktankError> {
     let rt = ensure_runtime();

src/modules/activity/implementation.rs

@@ -12,7 +12,8 @@ const CREATE_ACTIVITIES_TABLE: &str = "
         tx_type TEXT NOT NULL CHECK (tx_type IN ('sent', 'received')),
         timestamp INTEGER NOT NULL CHECK (timestamp > 0),
         created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
-        updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
+        updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+        seen_at INTEGER CHECK (seen_at IS NULL OR seen_at > 0)
     )";
 
 const CREATE_ONCHAIN_TABLE: &str = "
@@ -641,6 +642,7 @@ impl ActivityDB {
             a.timestamp,
             a.created_at,
             a.updated_at,
+            a.seen_at,
 
             -- Onchain columns
             o.tx_id AS onchain_tx_id,
@@ -688,11 +690,12 @@ impl ActivityDB {
                     let timestamp: i64 = row.get(3)?;
                     let created_at: Option<i64> = row.get(4)?;
                     let updated_at: Option<i64> = row.get(5)?;
-                    let value: i64 = row.get(7)?;
-                    let fee: i64 = row.get(8)?;
-                    let fee_rate: i64 = row.get(9)?;
-                    let confirm_timestamp: Option<i64> = row.get(16)?;
-                    let boost_tx_ids_str: String = row.get(13)?;
+                    let seen_at: Option<i64> = row.get(6)?;
+                    let value: i64 = row.get(8)?;
+                    let fee: i64 = row.get(9)?;
+                    let fee_rate: i64 = row.get(10)?;
+                    let confirm_timestamp: Option<i64> = row.get(17)?;
+                    let boost_tx_ids_str: String = row.get(14)?;
                     let boost_tx_ids: Vec<String> = if boost_tx_ids_str.is_empty() {
                         Vec::new()
                     } else {
@@ -705,40 +708,43 @@ impl ActivityDB {
                         timestamp: timestamp as u64,
                         created_at: created_at.map(|t| t as u64),
                         updated_at: updated_at.map(|t| t as u64),
-                        tx_id: row.get(6)?,
+                        seen_at: seen_at.map(|t| t as u64),
+                        tx_id: row.get(7)?,
                         value: value as u64,
                         fee: fee as u64,
                         fee_rate: fee_rate as u64,
-                        address: row.get(10)?,
-                        confirmed: row.get(11)?,
-                        is_boosted: row.get(12)?,
+                        address: row.get(11)?,
+                        confirmed: row.get(12)?,
+                        is_boosted: row.get(13)?,
                         boost_tx_ids,
-                        is_transfer: row.get(14)?,
-                        does_exist: row.get(15)?,
+                        is_transfer: row.get(15)?,
+                        does_exist: row.get(16)?,
                         confirm_timestamp: confirm_timestamp.map(|t| t as u64),
-                        channel_id: row.get(17)?,
-                        transfer_tx_id: row.get(18)?,
+                        channel_id: row.get(18)?,
+                        transfer_tx_id: row.get(19)?,
                     }))
                 }
                 "lightning" => {
                     let timestamp: i64 = row.get(3)?;
                     let created_at: Option<i64> = row.get(4)?;
                     let updated_at: Option<i64> = row.get(5)?;
-                    let value: i64 = row.get(20)?;
-                    let fee: Option<i64> = row.get(22)?;
+                    let seen_at: Option<i64> = row.get(6)?;
+                    let value: i64 = row.get(21)?;
+                    let fee: Option<i64> = row.get(23)?;
 
                     Ok(Activity::Lightning(LightningActivity {
                         id: row.get(0)?,
                         tx_type: Self::parse_payment_type(row, 2)?,
                         timestamp: timestamp as u64,
                         created_at: created_at.map(|t| t as u64),
                         updated_at: updated_at.map(|t| t as u64),
-                        invoice: row.get(19)?,
+                        seen_at: seen_at.map(|t| t as u64),
+                        invoice: row.get(20)?,
                         value: value as u64,
-                        status: Self::parse_payment_state(row, 21)?,
+                        status: Self::parse_payment_state(row, 22)?,
                         fee: fee.map(|f| f as u64),
-                        message: row.get(23)?,
-                        preimage: row.get(24)?,
+                        message: row.get(24)?,
+                        preimage: row.get(25)?,
                     }))
                 }
                 _ => Err(rusqlite::Error::InvalidColumnType(
@@ -783,7 +789,7 @@ impl ActivityDB {
                     a.id, a.tx_type, o.tx_id, o.value, o.fee, o.fee_rate,
                     o.address, o.confirmed, a.timestamp, o.is_boosted,
                     o.boost_tx_ids, o.is_transfer, o.does_exist, o.confirm_timestamp,
-                    o.channel_id, o.transfer_tx_id, a.created_at, a.updated_at
+                    o.channel_id, o.transfer_tx_id, a.created_at, a.updated_at, a.seen_at
                 FROM activities a
                 JOIN onchain_activity o ON a.id = o.id
                 WHERE a.id = ?1";
@@ -800,6 +806,7 @@ impl ActivityDB {
                 let confirm_timestamp: Option<i64> = row.get(13)?;
                 let created_at: Option<i64> = row.get(16)?;
                 let updated_at: Option<i64> = row.get(17)?;
+                let seen_at: Option<i64> = row.get(18)?;
                 let boost_tx_ids_str: String = row.get(10)?;
                 let boost_tx_ids: Vec<String> = if boost_tx_ids_str.is_empty() {
                     Vec::new()
@@ -826,6 +833,7 @@ impl ActivityDB {
                     transfer_tx_id: row.get(15)?,
                     created_at: created_at.map(|t| t as u64),
                     updated_at: updated_at.map(|t| t as u64),
+                    seen_at: seen_at.map(|t| t as u64),
                 }))
             }) {
                 Ok(activity) => Ok(Some(activity)),
@@ -841,7 +849,7 @@ impl ActivityDB {
                 SELECT
                     a.id, a.tx_type, l.status, l.value, l.fee,
                     l.invoice, l.message, a.timestamp,
-                    l.preimage, a.created_at, a.updated_at
+                    l.preimage, a.created_at, a.updated_at, a.seen_at
                 FROM activities a
                 JOIN lightning_activity l ON a.id = l.id
                 WHERE a.id = ?1";
@@ -856,6 +864,7 @@ impl ActivityDB {
                 let timestamp: i64 = row.get(7)?;
                 let created_at: Option<i64> = row.get(9)?;
                 let updated_at: Option<i64> = row.get(10)?;
+                let seen_at: Option<i64> = row.get(11)?;
 
                 Ok(Activity::Lightning(LightningActivity {
                     id: row.get(0)?,
@@ -869,6 +878,7 @@ impl ActivityDB {
                     preimage: row.get(8)?,
                     created_at: created_at.map(|t| t as u64),
                     updated_at: updated_at.map(|t| t as u64),
+                    seen_at: seen_at.map(|t| t as u64),
                 }))
             }).map_err(|e| ActivityError::RetrievalError {
                 error_details: format!("Failed to get lightning activity: {}", e),
@@ -887,7 +897,7 @@ impl ActivityDB {
                 a.id, a.tx_type, o.tx_id, o.value, o.fee, o.fee_rate,
                 o.address, o.confirmed, a.timestamp, o.is_boosted,
                 o.boost_tx_ids, o.is_transfer, o.does_exist, o.confirm_timestamp,
-                o.channel_id, o.transfer_tx_id, a.created_at, a.updated_at
+                o.channel_id, o.transfer_tx_id, a.created_at, a.updated_at, a.seen_at
             FROM activities a
             JOIN onchain_activity o ON a.id = o.id
             WHERE o.tx_id = ?1 AND a.activity_type = 'onchain'
@@ -905,6 +915,7 @@ impl ActivityDB {
             let confirm_timestamp: Option<i64> = row.get(13)?;
             let created_at: Option<i64> = row.get(16)?;
             let updated_at: Option<i64> = row.get(17)?;
+            let seen_at: Option<i64> = row.get(18)?;
             let boost_tx_ids_str: String = row.get(10)?;
             let boost_tx_ids: Vec<String> = if boost_tx_ids_str.is_empty() {
                 Vec::new()
@@ -931,6 +942,7 @@ impl ActivityDB {
                 transfer_tx_id: row.get(15)?,
                 created_at: created_at.map(|t| t as u64),
                 updated_at: updated_at.map(|t| t as u64),
+                seen_at: seen_at.map(|t| t as u64),
             })
         }) {
             Ok(activity) => Ok(Some(activity)),
@@ -1081,6 +1093,24 @@ impl ActivityDB {
         Ok(())
     }
 
+    /// Marks an activity as seen by setting the seen_at timestamp.
+    pub fn mark_activity_as_seen(&mut self, activity_id: &str, seen_at: u64) -> Result<(), ActivityError> {
+        let rows = self.conn.execute(
+            "UPDATE activities SET seen_at = ?1 WHERE id = ?2",
+            rusqlite::params![seen_at as i64, activity_id],
+        ).map_err(|e| ActivityError::DataError {
+            error_details: format!("Failed to mark activity as seen: {}", e),
+        })?;
+
+        if rows == 0 {
+            return Err(ActivityError::DataError {
+                error_details: "No activity found with given ID".to_string(),
+            });
+        }
+
+        Ok(())
+    }
+
     /// Deletes an activity and associated data.
     pub fn delete_activity_by_id(&mut self, activity_id: &str) -> Result<bool, ActivityError> {
         let tx = self.conn.transaction().map_err(|e| ActivityError::DataError {

src/modules/activity/tests.rs

@@ -34,6 +34,7 @@ mod tests {
             transfer_tx_id: None,
             created_at: None,
             updated_at: None,
+            seen_at: None,
         }
     }
 
@@ -50,6 +51,7 @@ mod tests {
             preimage: Some("preimage123".to_string()),
             created_at: None,
             updated_at: None,
+            seen_at: None,
         }
     }
 
@@ -3536,4 +3538,109 @@ mod tests {
 
         cleanup(&db_path);
     }
+
+    #[test]
+    fn test_mark_activity_as_seen_onchain() {
+        let (mut db, db_path) = setup();
+        let activity = create_test_onchain_activity();
+        db.insert_onchain_activity(&activity).unwrap();
+
+        // Verify initial state - seen_at should be None
+        let retrieved = db.get_activity_by_id(&activity.id).unwrap().unwrap();
+        assert!(retrieved.get_seen_at().is_none(), "seen_at should be None initially");
+
+        // Mark as seen
+        let seen_timestamp = 1234567900u64;
+        db.mark_activity_as_seen(&activity.id, seen_timestamp).unwrap();
+
+        // Verify seen_at is now set
+        let retrieved = db.get_activity_by_id(&activity.id).unwrap().unwrap();
+        assert_eq!(retrieved.get_seen_at(), Some(seen_timestamp), "seen_at should be set");
+
+        cleanup(&db_path);
+    }
+
+    #[test]
+    fn test_mark_activity_as_seen_lightning() {
+        let (mut db, db_path) = setup();
+        let activity = create_test_lightning_activity();
+        db.insert_lightning_activity(&activity).unwrap();
+
+        // Verify initial state - seen_at should be None
+        let retrieved = db.get_activity_by_id(&activity.id).unwrap().unwrap();
+        assert!(retrieved.get_seen_at().is_none(), "seen_at should be None initially");
+
+        // Mark as seen
+        let seen_timestamp = 1234567900u64;
+        db.mark_activity_as_seen(&activity.id, seen_timestamp).unwrap();
+
+        // Verify seen_at is now set
+        let retrieved = db.get_activity_by_id(&activity.id).unwrap().unwrap();
+        assert_eq!(retrieved.get_seen_at(), Some(seen_timestamp), "seen_at should be set");
+
+        cleanup(&db_path);
+    }
+
+    #[test]
+    fn test_mark_activity_as_seen_nonexistent() {
+        let (mut db, db_path) = setup();
+
+        // Try to mark a non-existent activity as seen
+        let result = db.mark_activity_as_seen("nonexistent_id", 1234567900);
+        assert!(result.is_err(), "Should fail for non-existent activity");
+
+        cleanup(&db_path);
+    }
+
+    #[test]
+    fn test_seen_at_preserved_in_get_activities() {
+        let (mut db, db_path) = setup();
+        
+        // Insert two activities
+        let mut onchain = create_test_onchain_activity();
+        onchain.timestamp = 1000;
+        let mut lightning = create_test_lightning_activity();
+        lightning.timestamp = 2000;
+        
+        db.insert_onchain_activity(&onchain).unwrap();
+        db.insert_lightning_activity(&lightning).unwrap();
+        
+        // Mark only onchain as seen
+        let seen_timestamp = 3000u64;
+        db.mark_activity_as_seen(&onchain.id, seen_timestamp).unwrap();
+        
+        // Get all activities
+        let activities = db.get_activities(None, None, None, None, None, None, None, None).unwrap();
+        assert_eq!(activities.len(), 2);
+        
+        for activity in activities {
+            match activity {
+                Activity::Onchain(o) => {
+                    assert_eq!(o.seen_at, Some(seen_timestamp), "Onchain should have seen_at set");
+                }
+                Activity::Lightning(l) => {
+                    assert!(l.seen_at.is_none(), "Lightning should not have seen_at set");
+                }
+            }
+        }
+        
+        cleanup(&db_path);
+    }
+
+    #[test]
+    fn test_seen_at_preserved_in_get_activity_by_tx_id() {
+        let (mut db, db_path) = setup();
+        let activity = create_test_onchain_activity();
+        db.insert_onchain_activity(&activity).unwrap();
+
+        // Mark as seen
+        let seen_timestamp = 1234567900u64;
+        db.mark_activity_as_seen(&activity.id, seen_timestamp).unwrap();
+
+        // Retrieve by tx_id and verify seen_at
+        let retrieved = db.get_activity_by_tx_id(&activity.tx_id).unwrap().unwrap();
+        assert_eq!(retrieved.seen_at, Some(seen_timestamp), "seen_at should be preserved when getting by tx_id");
+
+        cleanup(&db_path);
+    }
 }

src/modules/activity/types.rs

@@ -51,6 +51,13 @@ impl Activity {
             Activity::Lightning(l) => l.updated_at,
         }
     }
+
+    pub fn get_seen_at(&self) -> Option<u64> {
+        match self {
+            Activity::Onchain(o) => o.seen_at,
+            Activity::Lightning(l) => l.seen_at,
+        }
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Copy, uniffi::Enum)]
@@ -96,6 +103,8 @@ pub struct OnchainActivity {
     pub created_at: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub updated_at: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub seen_at: Option<u64>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, uniffi::Record)]
@@ -113,6 +122,8 @@ pub struct LightningActivity {
     pub created_at: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub updated_at: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub seen_at: Option<u64>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, uniffi::Record)]