feat: Transfer activities

Bitkit/AppScene.swift

@@ -50,7 +50,7 @@ struct AppScene: View {
         _currency = StateObject(wrappedValue: CurrencyViewModel())
         _blocktank = StateObject(wrappedValue: BlocktankViewModel())
         _activity = StateObject(wrappedValue: ActivityListViewModel(transferService: transferService))
-        _transfer = StateObject(wrappedValue: TransferViewModel(transferService: transferService))
+        _transfer = StateObject(wrappedValue: TransferViewModel(transferService: transferService, sheetViewModel: sheetViewModel))
         _widgets = StateObject(wrappedValue: WidgetsViewModel())
         _settings = StateObject(wrappedValue: SettingsViewModel.shared)
 

Bitkit/MainNavView.swift

@@ -139,6 +139,14 @@ struct MainNavView: View {
         ) {
             config in SendSheet(config: config)
         }
+        .sheet(
+            item: $sheets.forceTransferSheetItem,
+            onDismiss: {
+                sheets.hideSheet()
+            }
+        ) {
+            config in ForceTransferSheet(config: config)
+        }
         .accentColor(.white)
         .overlay {
             TabBar()

Bitkit/Models/TransactionMetadata.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+/// Metadata for onchain transactions that needs to be temporarily stored
+/// until it can be applied to activities during sync operations
+struct TransactionMetadata: Codable, Identifiable {
+    /// Transaction ID (also serves as the unique identifier)
+    let txId: String
+
+    /// Fee rate in satoshis per vbyte
+    let feeRate: UInt64
+
+    /// Destination address
+    let address: String
+
+    /// Whether this transaction is a transfer between wallets (e.g., channel funding)
+    let isTransfer: Bool
+
+    /// Associated channel ID for channel funding transactions
+    let channelId: String?
+
+    /// Timestamp when this metadata was created (for cleanup purposes)
+    let createdAt: UInt64
+
+    var id: String { txId }
+
+    init(
+        txId: String,
+        feeRate: UInt64,
+        address: String,
+        isTransfer: Bool,
+        channelId: String? = nil,
+        createdAt: UInt64
+    ) {
+        self.txId = txId
+        self.feeRate = feeRate
+        self.address = address
+        self.isTransfer = isTransfer
+        self.channelId = channelId
+        self.createdAt = createdAt
+    }
+}

Bitkit/Services/CoreService.swift

@@ -233,6 +233,79 @@ class ActivityService {
             Logger.info("Synced LDK payments - Added: \(addedCount) - Updated: \(updatedCount)", context: "CoreService")
             self.activitiesChangedSubject.send()
         }
+
+        try await updateActivitiesMetadata()
+    }
+
+    func updateActivitiesMetadata() async throws {
+        let allMetadata = try TransactionMetadataStorage.shared.getAll()
+
+        guard !allMetadata.isEmpty else {
+            Logger.debug("No transaction metadata to update", context: "CoreService.updateActivitiesMetadata")
+            return
+        }
+
+        try await ServiceQueue.background(.core) {
+            Logger.info("Updating activities with \(allMetadata.count) metadata entries", context: "CoreService.updateActivitiesMetadata")
+
+            var updatedCount = 0
+            var removedCount = 0
+
+            for metadata in allMetadata {
+                do {
+                    // Find activity by txId
+                    guard let activity = try getActivityById(activityId: metadata.txId) else {
+                        Logger.debug(
+                            "Activity not found for txId: \(metadata.txId), keeping metadata for next sync",
+                            context: "CoreService.updateActivitiesMetadata"
+                        )
+                        continue
+                    }
+
+                    // Only update onchain activities
+                    guard case var .onchain(onchainActivity) = activity else {
+                        Logger.debug("Activity \(metadata.txId) is not onchain, skipping", context: "CoreService.updateActivitiesMetadata")
+                        // Remove metadata since it won't be applicable
+                        try? TransactionMetadataStorage.shared.remove(txId: metadata.txId)
+                        removedCount += 1
+                        continue
+                    }
+
+                    // Update with metadata
+                    onchainActivity.feeRate = metadata.feeRate
+                    onchainActivity.address = metadata.address
+                    onchainActivity.isTransfer = metadata.isTransfer
+                    onchainActivity.channelId = metadata.channelId
+
+                    // Update transferTxId if this is a transfer
+                    if metadata.isTransfer {
+                        onchainActivity.transferTxId = metadata.txId
+                    }
+
+                    onchainActivity.updatedAt = UInt64(Date().timeIntervalSince1970)
+
+                    // Save updated activity
+                    try updateActivity(activityId: metadata.txId, activity: .onchain(onchainActivity))
+                    updatedCount += 1
+
+                    // Remove metadata after successful update
+                    try? TransactionMetadataStorage.shared.remove(txId: metadata.txId)
+                    removedCount += 1
+
+                    Logger.debug("Updated activity with metadata: \(metadata.txId)", context: "CoreService.updateActivitiesMetadata")
+                } catch {
+                    Logger.error("Failed to update activity metadata for \(metadata.txId): \(error)", context: "CoreService.updateActivitiesMetadata")
+                }
+            }
+
+            if updatedCount > 0 {
+                Logger.info(
+                    "Updated \(updatedCount) activities with metadata, removed \(removedCount) metadata entries",
+                    context: "CoreService.updateActivitiesMetadata"
+                )
+                self.activitiesChangedSubject.send()
+            }
+        }
     }
 
     func getActivity(id: String) async throws -> Activity? {

Bitkit/Services/LightningService.swift

@@ -350,16 +350,20 @@
         sats: UInt64,
         satsPerVbyte: UInt32,
         utxosToSpend: [SpendableUtxo]? = nil,
-        isMaxAmount: Bool = false
+        isMaxAmount: Bool = false,
+        isTransfer: Bool = false
     ) async throws -> Txid {
         guard let node else {
             throw AppError(serviceError: .nodeNotSetup)
         }
 
-        Logger.info("Sending \(sats) sats to \(address) with fee rate \(satsPerVbyte) sats/vbyte (isMaxAmount: \(isMaxAmount))")
+        Logger
+            .info(
+                "Sending \(sats) sats to \(address) with fee rate \(satsPerVbyte) sats/vbyte (isMaxAmount: \(isMaxAmount), isTransfer: \(isTransfer))"
+            )
 
         do {
-            return try await ServiceQueue.background(.ldk) {
+            let txid = try await ServiceQueue.background(.ldk) {
                 if isMaxAmount {
                     // For max amount sends, use sendAllToAddress to send all available funds
                     try node.onchainPayment().sendAllToAddress(
@@ -377,6 +381,20 @@
                     )
                 }
             }
+
+            // Capture transaction metadata for later activity update
+            let metadata = TransactionMetadata(
+                txId: txid,
+                feeRate: UInt64(satsPerVbyte),
+                address: address,
+                isTransfer: isTransfer,
+                channelId: nil,
+                createdAt: UInt64(Date().timeIntervalSince1970)
+            )
+            try? TransactionMetadataStorage.shared.insert(metadata)
+            Logger.debug("Captured transaction metadata for txid: \(txid), isTransfer: \(isTransfer)", context: "LightningService")
+
+            return txid
         } catch {
             dumpLdkLogs()
             throw error
@@ -419,16 +437,26 @@
         }
     }
 
-    func closeChannel(_ channel: ChannelDetails) async throws {
+    func closeChannel(_ channel: ChannelDetails, force: Bool = false, forceCloseReason: String? = nil) async throws {
         guard let node else {
             throw AppError(serviceError: .nodeNotStarted)
         }
 
         return try await ServiceQueue.background(.ldk) {
-            try node.closeChannel(
-                userChannelId: channel.userChannelId,
-                counterpartyNodeId: channel.counterpartyNodeId
-            )
+            Logger.debug("Initiating channel close (force=\(force)): '\(channel.channelId)'", context: "LightningService")
+
+            if force {
+                try node.forceCloseChannel(
+                    userChannelId: channel.userChannelId,
+                    counterpartyNodeId: channel.counterpartyNodeId,
+                    reason: forceCloseReason ?? ""
+                )
+            } else {
+                try node.closeChannel(
+                    userChannelId: channel.userChannelId,
+                    counterpartyNodeId: channel.counterpartyNodeId
+                )
+            }
         }
     }
 
@@ -558,15 +586,15 @@
 
                 // TODO: actual event handler
                 switch event {
                 case let .paymentSuccessful(paymentId, paymentHash, paymentPreimage, feePaidMsat):
                     Logger.info("✅ Payment successful: paymentId: \(paymentId ?? "?") paymentHash: \(paymentHash) feePaidMsat: \(feePaidMsat ?? 0)")
                 case let .paymentFailed(paymentId, paymentHash, reason):
                     Logger.info(
                         "❌ Payment failed: paymentId: \(paymentId ?? "?") paymentHash: \(paymentHash ?? "") reason: \(reason.debugDescription)"
                     )
                 case let .paymentReceived(paymentId, paymentHash, amountMsat, feePaidMsat):
                     Logger.info("🤑 Payment received: paymentId: \(paymentId ?? "?") paymentHash: \(paymentHash) amountMsat: \(amountMsat)")
                 case let .paymentClaimable(paymentId, paymentHash, claimableAmountMsat, claimDeadline, customRecords):
                     Logger.info(
                         "🫰 Payment claimable: paymentId: \(paymentId) paymentHash: \(paymentHash) claimableAmountMsat: \(claimableAmountMsat)"
                     )

Bitkit/Services/TransactionMetadataStorage.swift

@@ -0,0 +1,120 @@
+import Combine
+import Foundation
+
+/// Handles persistence of TransactionMetadata objects using UserDefaults
+/// Metadata is temporarily stored until it can be applied to activities during sync
+class TransactionMetadataStorage {
+    static let shared = TransactionMetadataStorage()
+
+    private let defaults: UserDefaults
+    private let metadataKey = "transactionMetadata"
+
+    private let metadataChangedSubject = PassthroughSubject<Void, Never>()
+
+    var metadataChangedPublisher: AnyPublisher<Void, Never> {
+        metadataChangedSubject.eraseToAnyPublisher()
+    }
+
+    private init(suiteName: String? = nil) {
+        if let suiteName {
+            defaults = UserDefaults(suiteName: suiteName) ?? .standard
+        } else {
+            defaults = .standard
+        }
+    }
+
+    /// Insert a new transaction metadata entry
+    func insert(_ metadata: TransactionMetadata) throws {
+        var allMetadata = try getAll()
+
+        // Check if metadata for this txId already exists
+        if allMetadata.contains(where: { $0.txId == metadata.txId }) {
+            Logger.warn("Transaction metadata for \(metadata.txId) already exists, skipping insert", context: "TransactionMetadataStorage")
+            return
+        }
+
+        allMetadata.append(metadata)
+        try save(allMetadata)
+        Logger.info("Inserted transaction metadata: txId=\(metadata.txId)", context: "TransactionMetadataStorage")
+        metadataChangedSubject.send()
+    }
+
+    /// Insert a list of transaction metadata entries (for restore operations)
+    func insertList(_ metadataList: [TransactionMetadata]) throws {
+        var allMetadata = try getAll()
+        var hasChanges = false
+
+        for metadata in metadataList {
+            // Only insert if not already present
+            if !allMetadata.contains(where: { $0.txId == metadata.txId }) {
+                allMetadata.append(metadata)
+                hasChanges = true
+            }
+        }
+
+        if hasChanges {
+            try save(allMetadata)
+            Logger.info("Inserted \(metadataList.count) transaction metadata entries", context: "TransactionMetadataStorage")
+            metadataChangedSubject.send()
+        }
+    }
+
+    /// Get all stored transaction metadata
+    func getAll() throws -> [TransactionMetadata] {
+        guard let data = defaults.data(forKey: metadataKey) else {
+            return []
+        }
+
+        let decoder = JSONDecoder()
+        return try decoder.decode([TransactionMetadata].self, from: data)
+    }
+
+    /// Remove metadata by transaction ID
+    func remove(txId: String) throws {
+        var allMetadata = try getAll()
+        let originalCount = allMetadata.count
+
+        allMetadata.removeAll { $0.txId == txId }
+
+        if allMetadata.count != originalCount {
+            try save(allMetadata)
+            Logger.info("Removed transaction metadata: txId=\(txId)", context: "TransactionMetadataStorage")
+            metadataChangedSubject.send()
+        }
+    }
+
+    /// Remove all transaction metadata (for testing or cleanup)
+    func removeAll() throws {
+        let allMetadata = try getAll()
+
+        if allMetadata.isEmpty {
+            return
+        }
+
+        defaults.removeObject(forKey: metadataKey)
+        Logger.info("Removed all transaction metadata (\(allMetadata.count) entries)", context: "TransactionMetadataStorage")
+        metadataChangedSubject.send()
+    }
+
+    /// Remove old metadata entries that are older than the specified timestamp
+    func removeOld(olderThan timestamp: UInt64) throws {
+        var allMetadata = try getAll()
+        let originalCount = allMetadata.count
+
+        allMetadata.removeAll { $0.createdAt < timestamp }
+
+        if allMetadata.count != originalCount {
+            try save(allMetadata)
+            Logger.info("Removed \(originalCount - allMetadata.count) old transaction metadata entries", context: "TransactionMetadataStorage")
+            metadataChangedSubject.send()
+        }
+    }
+
+    // MARK: - Private Helpers
+
+    private func save(_ metadata: [TransactionMetadata]) throws {
+        let encoder = JSONEncoder()
+        let data = try encoder.encode(metadata)
+        defaults.set(data, forKey: metadataKey)
+    }
+}

Bitkit/ViewModels/SheetViewModel.swift

@@ -5,6 +5,7 @@ enum SheetID: String, CaseIterable {
     case appUpdate
     case backup
     case boost
+    case forceTransfer
     case forgotPin
     case gift
     case highBalance
@@ -287,4 +288,16 @@ class SheetViewModel: ObservableObject {
             }
         }
     }
+
+    var forceTransferSheetItem: ForceTransferSheetItem? {
+        get {
+            guard let config = activeSheetConfiguration, config.id == .forceTransfer else { return nil }
+            return ForceTransferSheetItem()
+        }
+        set {
+            if newValue == nil {
+                activeSheetConfiguration = nil
+            }
+        }
+    }
 }