feat: add database wipe methods for activity and blocktank modules

- Add activity_wipe_all() to clear all activities and tags
- Add blocktank_remove_all_orders() to clear order history
- Add blocktank_remove_all_cjit_entries() to clear CJIT entries
- Add blocktank_wipe_all() to clear all blocktank tables
- Add wipe_all_databases() for global database reset
- Update tests accordingly

Author: coreyphillips

src/lib.rs

@@ -1244,4 +1244,95 @@ pub fn trezor_compose_transaction(
         Ok(result) => Ok(result),
         Err(e) => Err(TrezorConnectError::ClientError { error_details: e.to_string() }),
     }
+}
+
+#[uniffi::export]
+pub fn activity_wipe_all() -> Result<(), ActivityError> {
+    let cell = DB.get().ok_or(ActivityError::ConnectionError {
+        error_details: "Database not initialized. Call init_db first.".to_string()
+    })?;
+    let mut guard = cell.lock().unwrap();
+    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()
+}
+
+#[uniffi::export]
+pub async fn blocktank_remove_all_orders() -> Result<(), BlocktankError> {
+    let rt = ensure_runtime();
+    rt.spawn(async move {
+        let cell = ASYNC_DB.get().ok_or(BlocktankError::ConnectionError {
+            error_details: "Database not initialized. Call init_db first.".to_string()
+        })?;
+        let guard = cell.lock().await;
+        let db = guard.blocktank_db.as_ref().ok_or(BlocktankError::ConnectionError {
+            error_details: "Database not initialized. Call init_db first.".to_string()
+        })?;
+        db.remove_all_orders().await
+    }).await.unwrap()
+}
+
+#[uniffi::export]
+pub async fn blocktank_remove_all_cjit_entries() -> Result<(), BlocktankError> {
+    let rt = ensure_runtime();
+    rt.spawn(async move {
+        let cell = ASYNC_DB.get().ok_or(BlocktankError::ConnectionError {
+            error_details: "Database not initialized. Call init_db first.".to_string()
+        })?;
+        let guard = cell.lock().await;
+        let db = guard.blocktank_db.as_ref().ok_or(BlocktankError::ConnectionError {
+            error_details: "Database not initialized. Call init_db first.".to_string()
+        })?;
+        db.remove_all_cjit_entries().await
+    }).await.unwrap()
+}
+
+#[uniffi::export]
+pub async fn blocktank_wipe_all() -> Result<(), BlocktankError> {
+    let rt = ensure_runtime();
+    rt.spawn(async move {
+        let cell = ASYNC_DB.get().ok_or(BlocktankError::ConnectionError {
+            error_details: "Database not initialized. Call init_db first.".to_string()
+        })?;
+        let guard = cell.lock().await;
+        let db = guard.blocktank_db.as_ref().ok_or(BlocktankError::ConnectionError {
+            error_details: "Database not initialized. Call init_db first.".to_string()
+        })?;
+        db.wipe_all().await
+    }).await.unwrap()
+}
+
+#[uniffi::export]
+pub async fn wipe_all_databases() -> Result<String, DbError> {
+    let rt = ensure_runtime();
+
+    // Wipe activity database
+    {
+        let cell = DB.get().ok_or(DbError::InitializationError {
+            error_details: "Database not initialized. Call init_db first.".to_string()
+        })?;
+        let mut guard = cell.lock().unwrap();
+        if let Some(db) = guard.activity_db.as_mut() {
+            db.wipe_all().map_err(|e| DbError::InitializationError {
+                error_details: format!("Failed to wipe activity database: {}", e)
+            })?;
+        }
+    }
+
+    // Wipe blocktank database
+    rt.spawn(async move {
+        let cell = ASYNC_DB.get().ok_or(DbError::InitializationError {
+            error_details: "Database not initialized. Call init_db first.".to_string()
+        })?;
+        let guard = cell.lock().await;
+        if let Some(db) = guard.blocktank_db.as_ref() {
+            db.wipe_all().await.map_err(|e| DbError::InitializationError {
+                error_details: format!("Failed to wipe blocktank database: {}", e)
+            })?;
+        }
+        Ok::<(), DbError>(())
+    }).await.unwrap()?;
+
+    Ok("All databases wiped successfully".to_string())
 }

src/modules/activity/implementation.rs

@@ -1019,4 +1019,38 @@ impl ActivityDB {
             SortDirection::Desc => "DESC"
         }
     }
+
+    /// Removes all activities from the database
+    pub fn remove_all(&mut self) -> Result<(), ActivityError> {
+        let tx = self.conn.transaction().map_err(|e| ActivityError::DataError {
+            error_details: format!("Failed to start transaction: {}", e),
+        })?;
+
+        // Delete from activities table (this will cascade to other tables due to foreign key constraints)
+        tx.execute("DELETE FROM activities", [])
+            .map_err(|e| ActivityError::DataError {
+                error_details: format!("Failed to delete all activities: {}", e),
+            })?;
+
+        tx.commit().map_err(|e| ActivityError::DataError {
+            error_details: format!("Failed to commit transaction: {}", e),
+        })?;
+
+        Ok(())
+    }
+
+    /// Removes all tags from the database
+    pub fn remove_all_tags(&mut self) -> Result<(), ActivityError> {
+        self.conn.execute("DELETE FROM activity_tags", [])
+            .map_err(|e| ActivityError::DataError {
+                error_details: format!("Failed to delete all tags: {}", e),
+            })?;
+
+        Ok(())
+    }
+
+    /// Wipes all activity data from the database
+    pub fn wipe_all(&mut self) -> Result<(), ActivityError> {
+        self.remove_all()
+    }
 }

src/modules/activity/tests.rs

@@ -1280,4 +1280,127 @@ mod tests {
 
         cleanup(&db_path);
     }
+
+    #[test]
+    fn test_remove_all() {
+        let (mut db, db_path) = setup();
+
+        // Insert multiple activities
+        let activity1 = create_test_onchain_activity();
+        let mut activity2 = create_test_lightning_activity();
+        activity2.id = "test_lightning_2".to_string();
+        let mut activity3 = create_test_onchain_activity();
+        activity3.id = "test_onchain_3".to_string();
+
+        db.insert_onchain_activity(&activity1).unwrap();
+        db.insert_lightning_activity(&activity2).unwrap();
+        db.insert_onchain_activity(&activity3).unwrap();
+
+        // Add tags to verify cascade deletion
+        db.add_tags(&activity1.id, &["tag1".to_string(), "tag2".to_string()]).unwrap();
+        db.add_tags(&activity2.id, &["tag3".to_string()]).unwrap();
+
+        // Verify activities exist
+        let activities = db.get_activities(None, None, None, None, None, None, None, None).unwrap();
+        assert_eq!(activities.len(), 3);
+
+        // Verify tags exist
+        let tags = db.get_all_unique_tags().unwrap();
+        assert_eq!(tags.len(), 3);
+
+        // Remove all activities
+        db.remove_all().unwrap();
+
+        // Verify all activities are deleted
+        let activities_after = db.get_activities(None, None, None, None, None, None, None, None).unwrap();
+        assert_eq!(activities_after.len(), 0);
+
+        // Verify tags are also deleted (cascade)
+        let tags_after = db.get_all_unique_tags().unwrap();
+        assert_eq!(tags_after.len(), 0);
+
+        cleanup(&db_path);
+    }
+
+    #[test]
+    fn test_remove_all_tags() {
+        let (mut db, db_path) = setup();
+
+        // Insert activities
+        let activity1 = create_test_onchain_activity();
+        let mut activity2 = create_test_lightning_activity();
+        activity2.id = "test_lightning_2".to_string();
+
+        db.insert_onchain_activity(&activity1).unwrap();
+        db.insert_lightning_activity(&activity2).unwrap();
+
+        // Add multiple tags
+        db.add_tags(&activity1.id, &["tag1".to_string(), "tag2".to_string(), "tag3".to_string()]).unwrap();
+        db.add_tags(&activity2.id, &["tag4".to_string(), "tag5".to_string()]).unwrap();
+
+        // Verify tags exist
+        let tags = db.get_all_unique_tags().unwrap();
+        assert_eq!(tags.len(), 5);
+
+        // Remove all tags
+        db.remove_all_tags().unwrap();
+
+        // Verify all tags are deleted
+        let tags_after = db.get_all_unique_tags().unwrap();
+        assert_eq!(tags_after.len(), 0);
+
+        // Verify activities still exist
+        let activities = db.get_activities(None, None, None, None, None, None, None, None).unwrap();
+        assert_eq!(activities.len(), 2);
+
+        cleanup(&db_path);
+    }
+
+    #[test]
+    fn test_wipe_all() {
+        let (mut db, db_path) = setup();
+
+        // Insert various activities
+        let activity1 = create_test_onchain_activity();
+        let mut activity2 = create_test_lightning_activity();
+        activity2.id = "test_lightning_2".to_string();
+        let mut activity3 = create_test_onchain_activity();
+        activity3.id = "test_onchain_3".to_string();
+        let mut activity4 = create_test_lightning_activity();
+        activity4.id = "test_lightning_4".to_string();
+
+        db.insert_onchain_activity(&activity1).unwrap();
+        db.insert_lightning_activity(&activity2).unwrap();
+        db.insert_onchain_activity(&activity3).unwrap();
+        db.insert_lightning_activity(&activity4).unwrap();
+
+        // Add tags
+        db.add_tags(&activity1.id, &["payment".to_string()]).unwrap();
+        db.add_tags(&activity2.id, &["invoice".to_string()]).unwrap();
+        db.add_tags(&activity3.id, &["transfer".to_string()]).unwrap();
+        db.add_tags(&activity4.id, &["payment".to_string(), "invoice".to_string()]).unwrap();
+
+        // Verify data exists
+        let activities = db.get_activities(None, None, None, None, None, None, None, None).unwrap();
+        assert_eq!(activities.len(), 4);
+        let tags = db.get_all_unique_tags().unwrap();
+        assert_eq!(tags.len(), 3);
+
+        // Wipe all data
+        db.wipe_all().unwrap();
+
+        // Verify everything is deleted
+        let activities_after = db.get_activities(None, None, None, None, None, None, None, None).unwrap();
+        assert_eq!(activities_after.len(), 0);
+        let tags_after = db.get_all_unique_tags().unwrap();
+        assert_eq!(tags_after.len(), 0);
+
+        // Verify we can still insert new data after wipe
+        let new_activity = create_test_onchain_activity();
+        db.insert_onchain_activity(&new_activity).unwrap();
+        let activities_new = db.get_activities(None, None, None, None, None, None, None, None).unwrap();
+        assert_eq!(activities_new.len(), 1);
+
+        cleanup(&db_path);
+    }
 }

src/modules/blocktank/db.rs

@@ -821,4 +821,70 @@ impl BlocktankDB {
 
         Ok(entries)
     }
+
+    /// Removes all orders from the database
+    pub async fn remove_all_orders(&self) -> Result<(), BlocktankError> {
+        let conn = self.conn.lock().await;
+
+        conn.execute("DELETE FROM orders", [])
+            .map_err(|e| BlocktankError::DatabaseError {
+                error_details: format!("Failed to delete all orders: {}", e),
+            })?;
+
+        Ok(())
+    }
+
+    /// Removes all CJIT entries from the database
+    pub async fn remove_all_cjit_entries(&self) -> Result<(), BlocktankError> {
+        let conn = self.conn.lock().await;
+
+        conn.execute("DELETE FROM cjit_entries", [])
+            .map_err(|e| BlocktankError::DatabaseError {
+                error_details: format!("Failed to delete all CJIT entries: {}", e),
+            })?;
+
+        Ok(())
+    }
+
+    /// Removes all info entries from the database
+    pub async fn remove_all_info(&self) -> Result<(), BlocktankError> {
+        let conn = self.conn.lock().await;
+
+        conn.execute("DELETE FROM info", [])
+            .map_err(|e| BlocktankError::DatabaseError {
+                error_details: format!("Failed to delete all info entries: {}", e),
+            })?;
+
+        Ok(())
+    }
+
+    /// Removes all data from all Blocktank tables
+    pub async fn wipe_all(&self) -> Result<(), BlocktankError> {
+        let mut conn = self.conn.lock().await;
+
+        let tx = conn.transaction().map_err(|e| BlocktankError::DatabaseError {
+            error_details: format!("Failed to start transaction: {}", e),
+        })?;
+
+        tx.execute("DELETE FROM orders", [])
+            .map_err(|e| BlocktankError::DatabaseError {
+                error_details: format!("Failed to delete orders: {}", e),
+            })?;
+
+        tx.execute("DELETE FROM cjit_entries", [])
+            .map_err(|e| BlocktankError::DatabaseError {
+                error_details: format!("Failed to delete CJIT entries: {}", e),
+            })?;
+
+        tx.execute("DELETE FROM info", [])
+            .map_err(|e| BlocktankError::DatabaseError {
+                error_details: format!("Failed to delete info entries: {}", e),
+            })?;
+
+        tx.commit().map_err(|e| BlocktankError::DatabaseError {
+            error_details: format!("Failed to commit transaction: {}", e),
+        })?;
+
+        Ok(())
+    }
 }