Merge branch 'fix/transfer-spending-max-lsp-cap' of github.com:synonymdev/bitkit-ios into fix/transfer-spending-max-lsp-cap

Author: jvsena42

Bitkit/Components/Widgets/Suggestions.swift

@@ -164,6 +164,10 @@ struct Suggestions: View {
     /// When true, show a fixed set of static cards and ignore taps (e.g. widget preview).
     var isPreview: Bool = false
 
+    /// When editing the home grid, keep the widget visible (and reorderable/removable) by falling
+    /// back to the static preview set when there are no live cards to show.
+    var isEditing: Bool = false
+
     var previewCardIds: [String]?
 
     static let previewSheetCardIds = ["backupSeedPhrase", "pin", "transferToSpending", "support"]
@@ -250,8 +254,30 @@ struct Suggestions: View {
         )
     }
 
+    private var isEditingFallback: Bool {
+        isEditing && !isPreview && visibleCards.isEmpty
+    }
+
+    private var cardsToShow: [SuggestionCardData] {
+        guard isEditingFallback else { return visibleCards }
+        return Self.visibleCards(
+            wallet: wallet,
+            app: app,
+            settings: settings,
+            suggestionsManager: suggestionsManager,
+            pubkyProfile: pubkyProfile,
+            isPaykitUIEnabled: isPaykitUIActive,
+            isPreview: true,
+            previewCardIds: Self.previewSheetCardIds
+        )
+    }
+
+    private var renderStatic: Bool {
+        isPreview || isEditingFallback
+    }
+
     var body: some View {
-        if visibleCards.isEmpty {
+        if cardsToShow.isEmpty {
             EmptyView()
         } else {
             LazyVGrid(
@@ -261,25 +287,25 @@ struct Suggestions: View {
                 ],
                 spacing: 16
             ) {
-                ForEach(visibleCards) { card in
+                ForEach(cardsToShow) { card in
                     SuggestionCard(
                         title: card.title,
                         description: card.description,
                         imageName: card.imageName,
                         accentColor: card.color,
-                        onTap: { if !isPreview { onItemTap(card) } },
+                        onTap: { if !renderStatic { onItemTap(card) } },
                         onDismiss: { dismissCard(card) }
                     )
                     .background {
-                        if isPreview {
+                        if renderStatic {
                             RoundedRectangle(cornerRadius: 16).fill(Color.black)
                         }
                     }
                     .accessibilityElement(children: .contain)
                     .accessibilityIdentifier("Suggestion-\(card.accessibilityId)")
                 }
             }
-            .allowsHitTesting(!isPreview)
+            .allowsHitTesting(!renderStatic)
             .sheet(isPresented: $showShareSheet) {
                 ShareSheet(activityItems: [
                     t(

Bitkit/Components/Widgets/SuggestionsWidget.swift

@@ -13,7 +13,7 @@ struct SuggestionsWidget: View {
             hasBackground: false,
             onEditingEnd: onEditingEnd
         ) {
-            Suggestions(isPreview: isPreview)
+            Suggestions(isPreview: isPreview, isEditing: isEditing)
         }
     }
 }

Bitkit/ViewModels/AppViewModel.swift

@@ -387,7 +387,17 @@ extension AppViewModel {
                                 return
                             }
 
-                            // Lightning insufficient for any reason (no channels, no capacity, etc).
+                            // Channels exist but none are usable (e.g. peer offline): still prefer
+                            // lightning. The send sheet shows the sync overlay and either proceeds
+                            // over lightning when the peer reconnects or falls back to onchain
+                            // after its timeout.
+                            if let channels = lightningService.channels, !channels.isEmpty, !channels.contains(where: \.isUsable) {
+                                handleScannedLightningInvoice(lightningInvoice, bolt11: lnInvoice, onchainInvoice: invoice)
+                                return
+                            }
+
+                            // Lightning insufficient for any other reason (no channels at all, or
+                            // usable channels without capacity).
                             // Fall back to onchain and validate onchain balance immediately.
                             let onchainBalance = lightningService.balances?.spendableOnchainBalanceSats ?? 0
                             guard validateOnchainBalance(invoiceAmount: invoice.amountSatoshis, onchainBalance: onchainBalance) else {

Bitkit/Views/Offline/OfflineSheetScreen.swift

@@ -25,12 +25,17 @@ private struct OfflineSheetOverlayModifier: ViewModifier {
     @EnvironmentObject private var network: NetworkMonitor
 
     let title: String
+    var forceShow = false
+
+    private var isShowing: Bool {
+        !network.isConnected || forceShow
+    }
 
     func body(content: Content) -> some View {
         ZStack(alignment: .top) {
             content
 
-            if !network.isConnected {
+            if isShowing {
                 OfflineSheetScreen(title: title)
                     .transition(.opacity)
 
@@ -41,14 +46,15 @@ private struct OfflineSheetOverlayModifier: ViewModifier {
                     .padding(.top, 12)
             }
         }
-        .animation(.easeInOut(duration: 0.3), value: network.isConnected)
+        .animation(.easeInOut(duration: 0.3), value: isShowing)
     }
 }
 
 extension View {
-    /// Overlays a `OfflineSheetScreen` when the device is offline.
+    /// Overlays a `OfflineSheetScreen` when the device is offline, or whenever `forceShow` is true
+    /// (e.g. connection issues beyond device connectivity, like an unreachable Lightning peer).
     /// The underlying content remains mounted so navigation state and inputs are preserved.
-    func offlineSheetOverlay(title: String) -> some View {
-        modifier(OfflineSheetOverlayModifier(title: title))
+    func offlineSheetOverlay(title: String, forceShow: Bool = false) -> some View {
+        modifier(OfflineSheetOverlayModifier(title: title, forceShow: forceShow))
     }
 }

Bitkit/Views/Wallets/Send/SendAmountView.swift

@@ -297,9 +297,20 @@ struct SendAmountView: View {
         guard app.selectedWalletToPayFrom == .lightning else { return }
         guard let bolt11 = app.scannedLightningInvoice?.bolt11 else { return }
 
+        let buffer: UInt64 = 2 // TODO: find out why this is needed
+
+        // Without usable outbound capacity (e.g. peer offline) there is nothing to estimate,
+        // and subtracting the buffer below would underflow `UInt64`.
+        let maxSendable = UInt64(clamping: wallet.maxSendLightningSats)
+        guard maxSendable > buffer else {
+            await MainActor.run {
+                routingFee = 0
+            }
+            return
+        }
+
         do {
-            let buffer: UInt64 = 2 // TODO: find out why this is needed
-            let fee = try await wallet.estimateRoutingFees(bolt11: bolt11, amountSats: UInt64(wallet.maxSendLightningSats) - buffer)
+            let fee = try await wallet.estimateRoutingFees(bolt11: bolt11, amountSats: maxSendable - buffer)
             await MainActor.run {
                 routingFee = fee + buffer
             }

Bitkit/Views/Wallets/Send/SendSheet.swift

@@ -43,6 +43,7 @@ struct SendSheetItem: SheetItem {
 
 struct SendSheet: View {
     @EnvironmentObject private var app: AppViewModel
+    @EnvironmentObject private var network: NetworkMonitor
     @EnvironmentObject private var settings: SettingsViewModel
     @EnvironmentObject private var sheets: SheetViewModel
     @EnvironmentObject private var tagManager: TagManager
@@ -52,15 +53,17 @@ struct SendSheet: View {
 
     @State private var navigationPath: [SendRoute] = []
     @State private var hasValidatedAfterSync = false
+    @State private var syncTimedOut = false
     @State private var pinCheckContinuations: [CheckedContinuation<Bool, Never>] = []
 
+    /// How long the sync overlay may wait for channels to become usable before falling back
+    private static let syncTimeoutSeconds: TimeInterval = 20
+
     /// Show sync overlay when node is not ready for payments
     /// For lightning: need node running AND at least one usable channel (peer connected).
     /// If there are no channels at all, we should NOT wait behind the sync UI – that's a capacity issue, not a sync issue.
     /// For onchain: only need node running.
     private var shouldShowSyncOverlay: Bool {
-        Logger.debug("shouldShowSyncOverlay: \(wallet.nodeLifecycleState)", context: "SendSheet")
-
         // Node must be running
         guard wallet.nodeLifecycleState == .running else { return true }
 
@@ -83,6 +86,22 @@ struct SendSheet: View {
         return false
     }
 
+    /// Identity for the sync timeout task. The timer only counts down while the overlay is visible
+    /// and the device is online (while offline, `offlineSheetOverlay` covers the sheet and a timeout
+    /// would act on stale state). Node readiness is part of the identity so the window restarts when
+    /// the node reaches `.running` mid-wait and the timeout can still fall back with fresh balances.
+    private struct SyncTimeoutPhase: Equatable {
+        let isActive: Bool
+        let isNodeRunning: Bool
+    }
+
+    private var syncTimeoutPhase: SyncTimeoutPhase {
+        SyncTimeoutPhase(
+            isActive: shouldShowSyncOverlay && network.isConnected,
+            isNodeRunning: wallet.nodeLifecycleState == .running
+        )
+    }
+
     var body: some View {
         Sheet(id: .send, data: config) {
             if shouldShowSyncOverlay {
@@ -99,11 +118,21 @@ struct SendSheet: View {
             }
         }
         .animation(.easeInOut(duration: 0.3), value: shouldShowSyncOverlay)
-        .offlineSheetOverlay(title: t("wallet__send_bitcoin"))
+        .offlineSheetOverlay(title: t("wallet__send_bitcoin"), forceShow: syncTimedOut)
+        .onChange(of: shouldShowSyncOverlay, initial: true) { _, isShowing in
+            Logger.debug("shouldShowSyncOverlay: \(isShowing) (node: \(wallet.nodeLifecycleState))", context: "SendSheet")
+        }
         .onAppear {
             tagManager.clearSelectedTags()
             wallet.resetSendState(speed: settings.defaultTransactionSpeed)
             hasValidatedAfterSync = false
+            syncTimedOut = false
+
+            // A plain Send open (TabBar) must not inherit invoice state from an earlier scan,
+            // e.g. one abandoned behind the sync overlay. Invoice-carrying opens use other routes.
+            if config.initialRoute == .options {
+                app.resetSendState()
+            }
 
             Task {
                 do {
@@ -145,6 +174,38 @@ struct SendSheet: View {
                 validatePaymentAfterSync()
             }
         }
+        .task(id: syncTimeoutPhase) {
+            // Bound the sync overlay wait so a peer that never connects can't leave the user
+            // waiting indefinitely (the onChange above only fires if channels become usable).
+            guard syncTimeoutPhase.isActive else {
+                // Reset the connection-issues overlay only once the sync wait actually resolves;
+                // going offline merely pauses the timer and keeps the timed-out state.
+                if !shouldShowSyncOverlay {
+                    syncTimedOut = false
+                }
+                return
+            }
+
+            try? await Task.sleep(for: .seconds(Self.syncTimeoutSeconds))
+            guard !Task.isCancelled, syncTimeoutPhase.isActive, !hasValidatedAfterSync else { return }
+
+            handleSyncTimeout()
+        }
+    }
+
+    /// Called when the sync overlay has been visible for `syncTimeoutSeconds` without channels becoming usable.
+    /// Unified invoices fall back to onchain; everything else shows the connection-issues screen
+    /// (via the forced `offlineSheetOverlay`) and keeps waiting for the peer.
+    private func handleSyncTimeout() {
+        let canFallBackToOnchain = wallet.nodeLifecycleState == .running
+            && app.scannedLightningInvoice != nil
+            && app.scannedOnchainInvoice != nil
+
+        if canFallBackToOnchain {
+            validatePaymentAfterSync(ignoreChannelWait: true)
+        } else {
+            syncTimedOut = true
+        }
     }
 
     /// Validates onchain balance and shows toast + dismisses sheet if insufficient.
@@ -198,15 +259,16 @@ struct SendSheet: View {
     /// Validates payment affordability after sync completes
     /// For lightning: falls back to onchain for unified invoices, shows error for pure lightning invoices
     /// For onchain: validates balance and shows error if insufficient
-    private func validatePaymentAfterSync() {
+    /// Pass `ignoreChannelWait: true` to validate even while channels are unusable (sync timeout).
+    private func validatePaymentAfterSync(ignoreChannelWait: Bool = false) {
         // Validate lightning payment if present
         if let lightningInvoice = app.scannedLightningInvoice {
             // For lightning, if we have channels but none are usable yet, wait for them
             // to become usable. If there are no channels at all, or channels are already
             // usable, proceed with validation/fallback.
             // Use channelCount as fallback in case channels array is nil but count is cached
             let hasAnyChannels = (wallet.channels?.isEmpty == false) || wallet.channelCount > 0
-            if hasAnyChannels, !wallet.hasUsableChannels {
+            if hasAnyChannels, !wallet.hasUsableChannels, !ignoreChannelWait {
                 // We have channels but none usable yet → wait
                 return
             }

Bitkit/Views/Widgets/WidgetPreviewSheetView.swift

@@ -9,9 +9,15 @@ struct WidgetPreviewSheetView: View {
     @EnvironmentObject private var app: AppViewModel
     @EnvironmentObject private var currency: CurrencyViewModel
     @EnvironmentObject private var navigation: NavigationViewModel
+    @EnvironmentObject private var pubkyProfile: PubkyProfileManager
+    @EnvironmentObject private var settings: SettingsViewModel
     @EnvironmentObject private var sheets: SheetViewModel
+    @EnvironmentObject private var suggestionsManager: SuggestionsManager
+    @EnvironmentObject private var wallet: WalletViewModel
     @EnvironmentObject private var widgets: WidgetsViewModel
 
+    @AppStorage(PaykitFeatureFlags.uiEnabledKey) private var isPaykitUIEnabled = false
+
     @State private var carouselPage: Int
     @State private var showDeleteAlert = false
 
@@ -55,6 +61,23 @@ struct WidgetPreviewSheetView: View {
         carouselPage == 0 && supportsSmall ? .small : .wide
     }
 
+    private var isPaykitUIActive: Bool {
+        PaykitFeatureFlags.isUIAvailable && isPaykitUIEnabled
+    }
+
+    /// Whether the Suggestions widget would currently show no cards (mirrors what the live
+    /// `Suggestions` view renders, including the `pubkyProfile` completion check).
+    private var suggestionsAreEmpty: Bool {
+        Suggestions.visibleCards(
+            wallet: wallet,
+            app: app,
+            settings: settings,
+            suggestionsManager: suggestionsManager,
+            pubkyProfile: pubkyProfile,
+            isPaykitUIEnabled: isPaykitUIActive
+        ).isEmpty
+    }
+
     var body: some View {
         VStack(alignment: .leading, spacing: 16) {
             SheetHeader(title: metadata.name, showBackButton: true)
@@ -261,6 +284,9 @@ struct WidgetPreviewSheetView: View {
     // MARK: - Actions
 
     private func onSave() {
+        if type == .suggestions, suggestionsAreEmpty {
+            suggestionsManager.resetDismissed()
+        }
         widgets.saveWidget(type, size: chosenSize)
         sheets.hideSheet()
         navigation.reset()

changelog.d/next/590.fixed.md

@@ -0,0 +1 @@
+Sending no longer waits indefinitely or crashes when Lightning channels stay unavailable: Bitkit now prefers Lightning while the peer reconnects, then falls back to an onchain payment when possible or shows the connection issues screen after a short wait.

changelog.d/next/596.fixed.md

@@ -0,0 +1 @@
+Re-adding the Suggestions widget now restores the default suggestion cards when all of them had been dismissed.