feat(send): add onchain max send (#152)

pwltr · web-flow · commit a1da9e53eeec · 2025-09-16T13:33:02.000+02:00
diff --git a/Bitkit/Services/LightningService.swift b/Bitkit/Services/LightningService.swift
@@ -279,21 +279,37 @@ class LightningService {
         return .fromSatPerKwu(satKwu: max(satPerKwu, 253)) // FEERATE_FLOOR_SATS_PER_KW is 253 in LDK
     }
 
-    func send(address: String, sats: UInt64, satsPerVbyte: UInt32, utxosToSpend: [SpendableUtxo]? = nil) async throws -> Txid {
+    func send(
+        address: String,
+        sats: UInt64,
+        satsPerVbyte: UInt32,
+        utxosToSpend: [SpendableUtxo]? = nil,
+        isMaxAmount: 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")
+        Logger.info("Sending \(sats) sats to \(address) with fee rate \(satsPerVbyte) sats/vbyte (isMaxAmount: \(isMaxAmount))")
 
         do {
             return try await ServiceQueue.background(.ldk) {
-                try node.onchainPayment().sendToAddress(
-                    address: address,
-                    amountSats: sats,
-                    feeRate: Self.convertVByteToKwu(satsPerVByte: satsPerVbyte),
-                    utxosToSpend: utxosToSpend
-                )
+                if isMaxAmount {
+                    // For max amount sends, use sendAllToAddress to send all available funds
+                    try node.onchainPayment().sendAllToAddress(
+                        address: address,
+                        retainReserve: true,
+                        feeRate: Self.convertVByteToKwu(satsPerVByte: satsPerVbyte)
+                    )
+                } else {
+                    // For normal sends, use sendToAddress with specific amount
+                    try node.onchainPayment().sendToAddress(
+                        address: address,
+                        amountSats: sats,
+                        feeRate: Self.convertVByteToKwu(satsPerVByte: satsPerVbyte),
+                        utxosToSpend: utxosToSpend
+                    )
+                }
             }
         } catch {
             dumpLdkLogs()
diff --git a/Bitkit/ViewModels/WalletViewModel.swift b/Bitkit/ViewModels/WalletViewModel.swift
@@ -7,8 +7,9 @@ class WalletViewModel: ObservableObject {
     @Published var walletExists: Bool? = nil
     @Published var isSyncingWallet = false // Syncing both LN and on chain
     @AppStorage("totalBalanceSats") var totalBalanceSats: Int = 0 // Combined onchain and LN
-    @AppStorage("totalOnchainSats") var totalOnchainSats: Int = 0 // Combined onchain
+    @AppStorage("totalOnchainSats") var totalOnchainSats: Int = 0 // The total balance of our on-chain wallet
     @AppStorage("totalLightningSats") var totalLightningSats: Int = 0 // Combined LN
+    @AppStorage("spendableOnchainBalanceSats") var spendableOnchainBalanceSats: Int = 0 // The spendable balance of our on-chain wallet
 
     // Receive flow
     @AppStorage("onchainAddress") var onchainAddress = ""
@@ -22,6 +23,7 @@ class WalletViewModel: ObservableObject {
     @Published var selectedSpeed: TransactionSpeed = .normal
     @Published var selectedUtxos: [SpendableUtxo]?
     @Published var availableUtxos: [SpendableUtxo] = []
+    @Published var isMaxAmountSend: Bool = false
 
     // LNURL withdraw flow
     @Published var lnurlWithdrawAmount: UInt64?
@@ -200,9 +202,10 @@ class WalletViewModel: ObservableObject {
     /// - Parameters:
     ///   - address: The bitcoin address to send to
     ///   - sats: The amount in satoshis to send
+    ///   - isMaxAmount: Whether this is a max amount send (uses sendAllToAddress)
     /// - Returns: The transaction ID (txid) of the sent transaction
     /// - Throws: An error if the transaction fails or if fee rates cannot be retrieved
-    func send(address: String, sats: UInt64) async throws -> Txid {
+    func send(address: String, sats: UInt64, isMaxAmount: Bool = false) async throws -> Txid {
         guard let selectedFeeRateSatsPerVByte else {
             throw AppError(message: "Fee rate not set", debugMessage: "Please set a fee rate before selecting UTXOs.")
         }
@@ -217,7 +220,8 @@ class WalletViewModel: ObservableObject {
             address: address,
             sats: sats,
             satsPerVbyte: selectedFeeRateSatsPerVByte,
-            utxosToSpend: selectedUtxos
+            utxosToSpend: selectedUtxos,
+            isMaxAmount: isMaxAmount
         )
 
         Task {
@@ -330,6 +334,34 @@ class WalletViewModel: ObservableObject {
         )
     }
 
+    /// Calculates the maximum sendable amount for onchain transactions
+    /// - Parameters:
+    ///   - address: The destination address
+    ///   - satsPerVByte: The fee rate in satoshis per virtual byte
+    /// - Returns: The maximum amount that can be sent (balance minus fees)
+    /// - Throws: Error if calculation fails
+    func calculateMaxSendableAmount(
+        address: String,
+        satsPerVByte: UInt32
+    ) async throws -> UInt64 {
+        let spendableBalance = UInt64(spendableOnchainBalanceSats)
+
+        availableUtxos = try await lightningService.listSpendableOutputs()
+
+        // Use LDK-Node's special handling - when we pass the spendable balance as amount,
+        // it will automatically calculate the fee for sending all available funds
+        // if the exact amount would result in insufficient funds due to fees
+        let fee = try await lightningService.calculateTotalFee(
+            address: address,
+            amountSats: spendableBalance,
+            satsPerVByte: satsPerVByte,
+            utxosToSpend: availableUtxos
+        )
+
+        // The max sendable amount is the spendable balance minus the fee
+        return spendableBalance >= fee ? spendableBalance - fee : 0
+    }
+
     // NOTE: Let's keep this here for now until we are sure new version below is working
     // func send(
     //     bolt11: String,
@@ -419,6 +451,7 @@ class WalletViewModel: ObservableObject {
             totalOnchainSats = Int(balanceDetails.totalOnchainBalanceSats)
             totalLightningSats = Int(balanceDetails.totalLightningBalanceSats)
             totalBalanceSats = Int(balanceDetails.totalLightningBalanceSats + balanceDetails.totalOnchainBalanceSats)
+            spendableOnchainBalanceSats = Int(balanceDetails.spendableOnchainBalanceSats)
         }
     }
 
@@ -527,6 +560,7 @@ class WalletViewModel: ObservableObject {
         selectedUtxos = nil
         availableUtxos = []
         selectedSpeed = speed
+        isMaxAmountSend = false
     }
 
     func wipe() async throws {
diff --git a/Bitkit/Views/Wallets/Send/SendAmountView.swift b/Bitkit/Views/Wallets/Send/SendAmountView.swift
@@ -9,10 +9,7 @@ struct SendAmountView: View {
     @Binding var navigationPath: [SendRoute]
 
     @StateObject private var amountViewModel = AmountInputViewModel()
-
-    var availableAmount: UInt64 {
-        app.selectedWalletToPayFrom == .lightning ? UInt64(wallet.totalLightningSats) : UInt64(wallet.totalOnchainSats)
-    }
+    @State private var maxSendableAmount: UInt64?
 
     var amountSats: UInt64 {
         amountViewModel.amountSats
@@ -22,6 +19,24 @@ struct SendAmountView: View {
         app.scannedOnchainInvoice != nil && app.scannedLightningInvoice != nil
     }
 
+    /// The amount to display in the available balance section
+    /// For onchain transactions, this shows the max sendable amount (balance minus fees)
+    /// For lightning transactions, this shows the total balance
+    var availableAmount: UInt64 {
+        if app.selectedWalletToPayFrom == .lightning {
+            return UInt64(wallet.totalLightningSats)
+        } else {
+            // For onchain, show max sendable amount if calculated, otherwise fall back to total balance
+            return maxSendableAmount ?? UInt64(wallet.spendableOnchainBalanceSats)
+        }
+    }
+
+    /// Determines if the current amount is a max amount send
+    var isMaxAmountSend: Bool {
+        guard app.selectedWalletToPayFrom == .onchain else { return false }
+        return amountSats == availableAmount && amountSats > 0
+    }
+
     var body: some View {
         VStack(spacing: 0) {
             SheetHeader(title: t("wallet__send_amount"), showBackButton: true)
@@ -97,12 +112,30 @@ struct SendAmountView: View {
                 // Set the amount to the scanned onchain invoice amount if it exists
                 amountViewModel.updateFromSats(invoice.amountSatoshis, currency: currency)
             }
+
+            // Calculate max sendable amount for onchain transactions
+            if app.selectedWalletToPayFrom == .onchain {
+                Task {
+                    await calculateMaxSendableAmount()
+                }
+            }
+        }
+        .onChange(of: app.selectedWalletToPayFrom) { newValue in
+            // Recalculate max sendable amount when switching wallet types
+            if newValue == .onchain {
+                Task {
+                    await calculateMaxSendableAmount()
+                }
+            } else {
+                maxSendableAmount = nil
+            }
         }
     }
 
     private func onContinue() async {
         do {
             wallet.sendAmountSats = amountSats
+            wallet.isMaxAmountSend = isMaxAmountSend
 
             // Lightning tx
             if app.selectedWalletToPayFrom == .lightning {
@@ -162,6 +195,30 @@ struct SendAmountView: View {
             app.toast(type: .error, title: "Send Error", description: error.localizedDescription)
         }
     }
+
+    private func calculateMaxSendableAmount() async {
+        // Make sure we have everything we need to calculate the max sendable amount
+        guard app.selectedWalletToPayFrom == .onchain else { return }
+        guard let address = app.scannedOnchainInvoice?.address else { return }
+        guard let feeRate = wallet.selectedFeeRateSatsPerVByte else { return }
+
+        do {
+            let maxAmount = try await wallet.calculateMaxSendableAmount(
+                address: address,
+                satsPerVByte: feeRate
+            )
+
+            await MainActor.run {
+                maxSendableAmount = maxAmount
+            }
+        } catch {
+            Logger.error("Failed to calculate max sendable amount: \(error)")
+            await MainActor.run {
+                // Fall back to total balance if calculation fails
+                maxSendableAmount = UInt64(wallet.spendableOnchainBalanceSats)
+            }
+        }
+    }
 }
 
 #Preview {
diff --git a/Bitkit/Views/Wallets/Send/SendConfirmationView.swift b/Bitkit/Views/Wallets/Send/SendConfirmationView.swift
@@ -272,7 +272,7 @@ struct SendConfirmationView: View {
                 navigationPath.append(.success(paymentHash))
             } else if app.selectedWalletToPayFrom == .onchain, let invoice = app.scannedOnchainInvoice {
                 let amount = wallet.sendAmountSats ?? invoice.amountSatoshis
-                let txid = try await wallet.send(address: invoice.address, sats: amount)
+                let txid = try await wallet.send(address: invoice.address, sats: amount, isMaxAmount: wallet.isMaxAmountSend)
 
                 // Set the amount for the success screen
                 wallet.sendAmountSats = amount
