Merge branch 'master' into feat/trezor-hidden-wallet-and-watcher

Author: ovitrif

Bitkit/Components/NumberPad.swift

@@ -10,6 +10,7 @@ struct NumberPad: View {
     let type: NumberPadType
     let decimalSeparator: String
     let errorKey: String?
+    let isDisabled: Bool
     let onDeleteLongPress: (() -> Void)?
     let onPress: (String) -> Void
 
@@ -25,12 +26,14 @@ struct NumberPad: View {
         type: NumberPadType = .simple,
         decimalSeparator: String = ".",
         errorKey: String? = nil,
+        isDisabled: Bool = false,
         onDeleteLongPress: (() -> Void)? = nil,
         onPress: @escaping (String) -> Void
     ) {
         self.type = type
         self.decimalSeparator = decimalSeparator
         self.errorKey = errorKey
+        self.isDisabled = isDisabled
         self.onDeleteLongPress = onDeleteLongPress
         self.onPress = onPress
     }
@@ -127,6 +130,8 @@ struct NumberPad: View {
                 )
             }
         }
+        .opacity(isDisabled ? 0.5 : 1)
+        .disabled(isDisabled)
     }
 }
 

Bitkit/ViewModels/TransferViewModel.swift

@@ -360,6 +360,45 @@ class TransferViewModel: ObservableObject {
         transferValues = calculateTransferValues(clientBalanceSat: clientBalanceSat, blocktankInfo: blocktankInfo)
     }
 
+    /// Calculates the max amount transferable to spending and the value to display as "Available".
+    ///
+    /// The prospective client balance is clamped to the LSP's `maxClientBalanceSat` before
+    /// computing liquidity options: an on-chain balance larger than the LSP's max channel size
+    /// otherwise makes the liquidity calculation report `maxClientBalanceSat = 0` (the balance
+    /// already saturates the channel), collapsing the spendable amount to zero and stranding the
+    /// funds on-chain.
+    ///
+    /// - `transferValues`: liquidity options for a given client balance (prod: `calculateTransferValues`)
+    /// - `estimateOrderFee`: Blocktank order fee for a given client/LSP balance
+    func calculateSpendingLimits(
+        onchainAvailable: UInt64,
+        lspMaxClientBalance: UInt64?,
+        transferValues: (_ clientBalance: UInt64) -> TransferValues,
+        estimateOrderFee: (_ clientBalance: UInt64, _ lspBalance: UInt64) async throws -> (networkFeeSat: UInt64, serviceFeeSat: UInt64)
+    ) async rethrows -> (available: UInt64, max: UInt64) {
+        // First pass: estimate the LSP fee against the full on-chain balance.
+        let values1 = transferValues(onchainAvailable)
+        let lspBalance1 = max(values1.defaultLspBalance, values1.minLspBalance)
+        let fee1 = try await estimateOrderFee(onchainAvailable, lspBalance1)
+        let initialFees = fee1.networkFeeSat + fee1.serviceFeeSat
+        let balanceAfterLspFee = onchainAvailable > initialFees ? onchainAvailable - initialFees : 0
+
+        let cappedClientBalance: UInt64 = {
+            guard let cap = lspMaxClientBalance, cap > 0 else { return balanceAfterLspFee }
+            return min(balanceAfterLspFee, cap)
+        }()
+
+        // Second pass with the clamped balance.
+        let values2 = transferValues(cappedClientBalance)
+        guard values2.maxClientBalance > 0 else { return (0, 0) }
+        let lspBalance2 = max(values2.defaultLspBalance, values2.minLspBalance)
+        let fee2 = try await estimateOrderFee(cappedClientBalance, lspBalance2)
+        let finalFees = fee2.networkFeeSat + fee2.serviceFeeSat
+        let afterFee = onchainAvailable > finalFees ? onchainAvailable - finalFees : 0
+        let result = min(values2.maxClientBalance, afterFee)
+        return (result, result)
+    }
+
     /// Calculates max client balance accounting for LDK reserve requirement
     func getMaxClientBalance(maxChannelSize: UInt64) -> UInt64 {
         let minRemoteBalance = UInt64(Double(maxChannelSize) * 0.025)

Bitkit/Views/Transfer/SpendingAdvancedView.swift

@@ -117,14 +117,23 @@ struct SpendingAdvancedView: View {
             }
         }
         .onChange(of: transfer.transferValues.maxLspBalance, initial: true) { updateInputCap() }
-        .onChange(of: amountViewModel.maxExceededCount) { showMaxExceededToast() }
+        .onChange(of: amountViewModel.maxExceededCount) { onMaxExceeded() }
     }
 
     private func updateInputCap() {
         let maxLspBalance = transfer.transferValues.maxLspBalance
         amountViewModel.maxAmountOverride = maxLspBalance > 0 ? maxLspBalance : nil
     }
 
+    private func onMaxExceeded() {
+        // Snap the input to the max so the user lands on the highest allowed amount.
+        let maxLspBalance = transfer.transferValues.maxLspBalance
+        if maxLspBalance > 0 {
+            amountViewModel.updateFromSats(maxLspBalance, currency: currency)
+        }
+        showMaxExceededToast()
+    }
+
     private func showMaxExceededToast() {
         app.toast(
             type: .warning,

Bitkit/Views/Transfer/SpendingAmount.swift

@@ -1,3 +1,4 @@
+import BitkitCore
 import LDKNode
 import SwiftUI
 
@@ -12,13 +13,31 @@ struct SpendingAmount: View {
 
     @State private var amountViewModel = AmountInputViewModel()
     @State private var isLoading = false
+    @State private var isCalculatingMax = true
     @State private var availableAmount: UInt64?
     @State private var maxTransferAmount: UInt64?
 
     private var amountSats: UInt64 {
         amountViewModel.amountSats
     }
 
+    /// Inputs the max calculation depends on. A single `.task(id:)` keyed on this restarts the
+    /// calculation (with structured cancellation) whenever either input changes, so concurrent
+    /// reloads can neither overlap nor leak the loading flag.
+    private struct MaxCalcInputs: Equatable {
+        let maxChannelSizeSat: UInt64?
+        let maxClientBalanceSat: UInt64?
+        let spendableOnchainBalanceSats: Int
+    }
+
+    private var maxCalcInputs: MaxCalcInputs {
+        MaxCalcInputs(
+            maxChannelSizeSat: blocktank.info?.options.maxChannelSizeSat,
+            maxClientBalanceSat: blocktank.info?.options.maxClientBalanceSat,
+            spendableOnchainBalanceSats: wallet.spendableOnchainBalanceSats
+        )
+    }
+
     private var isValidAmount: Bool {
         guard let max = maxTransferAmount else { return false }
         return amountSats <= max
@@ -61,7 +80,8 @@ struct SpendingAmount: View {
 
             NumberPad(
                 type: amountViewModel.getNumberPadType(currency: currency),
-                errorKey: amountViewModel.errorKey
+                errorKey: amountViewModel.errorKey,
+                isDisabled: isCalculatingMax
             ) { key in
                 amountViewModel.handleNumberPadInput(key, currency: currency)
             }
@@ -79,22 +99,28 @@ struct SpendingAmount: View {
         .padding(.horizontal, 16)
         .bottomSafeAreaPadding()
         .offlineOverlay(title: t("lightning__transfer__nav_title"))
-        .task(id: blocktank.info?.options.maxChannelSizeSat) {
+        .task(id: maxCalcInputs) {
+            await MainActor.run { isCalculatingMax = true }
             await calculateMaxTransferAmount()
-        }
-        .onChange(of: wallet.spendableOnchainBalanceSats) {
-            Task {
-                await calculateMaxTransferAmount()
+            if !Task.isCancelled {
+                await MainActor.run { isCalculatingMax = false }
             }
         }
         .onChange(of: maxTransferAmount) { updateInputCap() }
-        .onChange(of: amountViewModel.maxExceededCount) { showMaxExceededToast() }
+        .onChange(of: amountViewModel.maxExceededCount) { onMaxExceeded() }
     }
 
     private func updateInputCap() {
         amountViewModel.maxAmountOverride = (maxTransferAmount ?? 0) > 0 ? maxTransferAmount : nil
     }
 
+    private func onMaxExceeded() {
+        if let max = maxTransferAmount {
+            amountViewModel.updateFromSats(max, currency: currency)
+        }
+        showMaxExceededToast()
+    }
+
     private func showMaxExceededToast() {
         app.toast(
             type: .warning,
@@ -178,10 +204,9 @@ struct SpendingAmount: View {
 
             guard let feeEstimates = await feeEstimatesManager.getEstimates(refresh: true) else {
                 await MainActor.run {
-                    let balance = UInt64(wallet.spendableOnchainBalanceSats)
-                    availableAmount = balance
-                    let values = transfer.calculateTransferValues(clientBalanceSat: balance, blocktankInfo: info)
-                    maxTransferAmount = min(values.maxClientBalance, balance)
+                    let fallback = fallbackMaxTransferAmount(info: info)
+                    availableAmount = fallback
+                    maxTransferAmount = fallback
                 }
                 return
             }
@@ -193,40 +218,37 @@ struct SpendingAmount: View {
                 satsPerVByte: fastFeeRate
             )
 
-            // First pass: estimate with calculatedAvailableAmount to get approximate clientBalance
-            let values1 = transfer.calculateTransferValues(clientBalanceSat: calculatedAvailableAmount, blocktankInfo: info)
-            let lspBalance1 = max(values1.defaultLspBalance, values1.minLspBalance)
-            let feeEstimate1 = try await blocktank.estimateOrderFee(
-                clientBalance: calculatedAvailableAmount,
-                lspBalance: lspBalance1
-            )
-            let lspFees1 = feeEstimate1.networkFeeSat + feeEstimate1.serviceFeeSat
-            let approxClientBalance = UInt64(max(0, Int64(calculatedAvailableAmount) - Int64(lspFees1)))
-
-            // Second pass: recalculate lspBalance with actual clientBalance (same as onContinue will use)
-            // This ensures fee estimation matches the actual order creation
-            let values2 = transfer.calculateTransferValues(clientBalanceSat: approxClientBalance, blocktankInfo: info)
-            let lspBalance2 = max(values2.defaultLspBalance, values2.minLspBalance)
-            let feeEstimate2 = try await blocktank.estimateOrderFee(
-                clientBalance: approxClientBalance,
-                lspBalance: lspBalance2
+            let (available, maxAmount) = try await transfer.calculateSpendingLimits(
+                onchainAvailable: calculatedAvailableAmount,
+                lspMaxClientBalance: info.options.maxClientBalanceSat,
+                transferValues: { transfer.calculateTransferValues(clientBalanceSat: $0, blocktankInfo: info) },
+                estimateOrderFee: { clientBalance, lspBalance in
+                    let estimate = try await blocktank.estimateOrderFee(clientBalance: clientBalance, lspBalance: lspBalance)
+                    return (estimate.networkFeeSat, estimate.serviceFeeSat)
+                }
             )
-            let lspFees = feeEstimate2.networkFeeSat + feeEstimate2.serviceFeeSat
-            let maxClientBalance = UInt64(max(0, Int64(calculatedAvailableAmount) - Int64(lspFees)))
-            let result = min(values2.maxClientBalance, maxClientBalance)
 
             await MainActor.run {
-                availableAmount = calculatedAvailableAmount
-                maxTransferAmount = result
+                availableAmount = available
+                maxTransferAmount = maxAmount
             }
         } catch {
             Logger.error("Failed to calculate max transfer amount: \(error)")
             await MainActor.run {
-                let balance = UInt64(wallet.spendableOnchainBalanceSats)
-                availableAmount = balance
-                let values = transfer.calculateTransferValues(clientBalanceSat: balance, blocktankInfo: info)
-                maxTransferAmount = min(values.maxClientBalance, balance)
+                let fallback = fallbackMaxTransferAmount(info: info)
+                availableAmount = fallback
+                maxTransferAmount = fallback
             }
         }
     }
+
+    /// Fallback max when fee estimates are unavailable: clamp the client balance to the LSP's max
+    /// client balance so the liquidity calculation doesn't collapse to zero on a saturating balance.
+    private func fallbackMaxTransferAmount(info: IBtInfo) -> UInt64 {
+        let balance = UInt64(wallet.spendableOnchainBalanceSats)
+        let lspMaxClientBalance = info.options.maxClientBalanceSat
+        let clientBalance = lspMaxClientBalance > 0 ? min(balance, lspMaxClientBalance) : balance
+        let values = transfer.calculateTransferValues(clientBalanceSat: clientBalance, blocktankInfo: info)
+        return min(values.maxClientBalance, balance)
+    }
 }

Bitkit/Views/Wallets/Activity/ActivityItemView.swift

@@ -566,33 +566,37 @@ struct ActivityItemView: View {
                 }
                 .accessibilityIdentifier(boostButtonIdentifier)
 
-                if isTransfer, let channelId = transferChannelId {
-                    CustomButton(
-                        title: t("lightning__connection"), size: .small,
-                        icon: Image("bolt-hollow")
-                            .foregroundColor(accentColor),
-                        shouldExpand: true
-                    ) {
-                        navigation.navigate(.connectionDetail(channelId: channelId))
-                    }
-                    .accessibilityIdentifier("ChannelButton")
-                } else {
-                    CustomButton(
-                        title: t("wallet__activity_explore"), size: .small,
-                        icon: Image("branch")
-                            .foregroundColor(accentColor),
-                        shouldExpand: true
-                    ) {
-                        navigation.navigate(.activityExplorer(viewModel.activity))
-                    }
-                    .accessibilityIdentifier("ActivityTxDetails")
-                }
+                exploreButton
             }
             .frame(maxWidth: .infinity)
+
+            if isTransfer, let channelId = transferChannelId {
+                CustomButton(
+                    title: t("lightning__connection"), size: .small,
+                    icon: Image("bolt-hollow")
+                        .foregroundColor(accentColor),
+                    shouldExpand: true
+                ) {
+                    navigation.navigate(.connectionDetail(channelId: channelId))
+                }
+                .accessibilityIdentifier("ChannelButton")
+            }
         }
         .frame(maxWidth: .infinity)
     }
 
+    private var exploreButton: some View {
+        CustomButton(
+            title: t("wallet__activity_explore"), size: .small,
+            icon: Image("branch")
+                .foregroundColor(accentColor),
+            shouldExpand: true
+        ) {
+            navigation.navigate(.activityExplorer(viewModel.activity))
+        }
+        .accessibilityIdentifier("ActivityTxDetails")
+    }
+
     private func detachContact() async {
         do {
             try await activityList.setContact(nil, forPaymentId: viewModel.activityId)