fix: address corey hw transfer review items

Tighten broadcast connectivity detection, restore HW fee
grid with offline estimate, and clear pending broadcast from
updateHwLimits to keep signing cancellation in sync.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: piotr-iohk

Bitkit/Extensions/BroadcastError+Connectivity.swift

@@ -1,13 +1,45 @@
 import BitkitCore
 import Foundation
 
+extension BroadcastError {
+    /// Whether this broadcast failure is likely transient connectivity (retry without re-signing).
+    /// Core 0.4.1 maps both Electrum connect failures and node rejections to `ElectrumError`; rejections
+    /// must not be treated as connectivity until core splits the variant (see bitkit-core).
+    var isConnectivityFailure: Bool {
+        switch self {
+        case .InvalidHex, .InvalidTransaction:
+            return false
+        case .TaskError:
+            return true
+        case let .ElectrumError(errorDetails):
+            return Self.isElectrumConnectivityDetails(errorDetails)
+        }
+    }
+
+    private static func isElectrumConnectivityDetails(_ details: String) -> Bool {
+        let lower = details.lowercased()
+        if lower.hasPrefix("broadcast failed:") {
+            return false
+        }
+        if lower.hasPrefix("failed to connect to electrum:") {
+            return true
+        }
+        if lower.contains("offline")
+            || lower.contains("timeout")
+            || lower.contains("connection refused")
+            || lower.contains("dns")
+            || lower.contains("network")
+        {
+            return true
+        }
+        return false
+    }
+}
+
 extension Error {
     func isBroadcastConnectivityFailure() -> Bool {
         if let broadcastError = self as? BroadcastError {
-            if case .ElectrumError = broadcastError {
-                return true
-            }
-            return false
+            return broadcastError.isConnectivityFailure
         }
 
         if let appError = self as? AppError, let underlyingError = appError.underlyingError {

Bitkit/Managers/HwWalletManager.swift

@@ -547,10 +547,47 @@ final class HwWalletManager {
         sats: UInt64,
         satsPerVByte: UInt64,
         addressType: AddressScriptType = hwFundingDefaultAddressType
+    ) async throws -> HwFundingTransaction {
+        let fingerprint = try await TrezorService.shared.getDeviceFingerprint()
+        return try await composeFundingTransactionInternal(
+            deviceId: deviceId,
+            address: address,
+            sats: sats,
+            satsPerVByte: satsPerVByte,
+            fingerprint: fingerprint,
+            addressType: addressType
+        )
+    }
+
+    /// Offline coin-selection for the exact funding amount; returns the mining fee only.
+    func estimateOfflineFundingMiningFee(
+        deviceId: String,
+        address: String,
+        sats: UInt64,
+        satsPerVByte: UInt64,
+        addressType: AddressScriptType = hwFundingDefaultAddressType
+    ) async throws -> UInt64 {
+        let funding = try await composeFundingTransactionInternal(
+            deviceId: deviceId,
+            address: address,
+            sats: sats,
+            satsPerVByte: satsPerVByte,
+            fingerprint: nil,
+            addressType: addressType
+        )
+        return funding.miningFeeSats
+    }
+
+    private func composeFundingTransactionInternal(
+        deviceId: String,
+        address: String,
+        sats: UInt64,
+        satsPerVByte: UInt64,
+        fingerprint: String?,
+        addressType: AddressScriptType
     ) async throws -> HwFundingTransaction {
         let account = try getFundingAccount(deviceId: deviceId, addressType: addressType)
         let network = networkProvider()
-        let fingerprint = try await TrezorService.shared.getDeviceFingerprint()
         let params = ComposeParams(
             wallet: WalletParams(
                 extendedKey: account.xpub,

Bitkit/ViewModels/HwFundingSigner.swift

@@ -98,6 +98,18 @@ struct HwFundingSigner {
         connecting.warmUpConnection(deviceId: deviceId)
     }
 
+    /// Offline compose for the exact order amount; does not require a connected device.
+    func estimateOfflineFundingMiningFee(deviceId: String, address: String, sats: UInt64) async throws -> UInt64 {
+        let satsPerVByte = await resolvedSatsPerVByte()
+        return try await funding.estimateOfflineFundingMiningFee(
+            deviceId: deviceId,
+            address: address,
+            sats: sats,
+            satsPerVByte: satsPerVByte,
+            addressType: hwFundingDefaultAddressType
+        )
+    }
+
     private func ensureConnected(deviceId: String) async throws {
         do {
             try await withTimeout(timeouts.reconnect) {

Bitkit/ViewModels/TransferViewModel.swift

@@ -77,6 +77,14 @@ protocol HwTransferFunding: Sendable {
         satsPerVByte: UInt64,
         addressType: AddressScriptType
     ) async throws -> HwFundingTransaction
+    /// Offline coin-selection estimate for the exact funding amount (`fingerprint: nil`); fee only.
+    func estimateOfflineFundingMiningFee(
+        deviceId: String,
+        address: String,
+        sats: UInt64,
+        satsPerVByte: UInt64,
+        addressType: AddressScriptType
+    ) async throws -> UInt64
     func signFunding(deviceId: String, funding: HwFundingTransaction) async throws -> HwFundingSignedTx
     func broadcastFunding(serializedTx: String) async throws -> String
 }
@@ -500,7 +508,8 @@ class TransferViewModel: ObservableObject {
             -> (networkFeeSat: UInt64, serviceFeeSat: UInt64)
     ) async {
         guard let hwSigner else { return }
-        hwSpending = HwSpendingState(isLoading: true)
+        clearPendingHwFundingBroadcast()
+        hwSpending.isLoading = true
 
         let availability: HwFundingSigner.Availability
         do {
@@ -530,6 +539,22 @@ class TransferViewModel: ObservableObject {
         hwSpending.isLoading = false
     }
 
+    /// Best-effort offline mining-fee estimate for the Sign screen (`fingerprint: nil` compose).
+    func updateHwFundingFeeEstimate(order: IBtOrder, deviceId: String) async {
+        guard let hwSigner else { return }
+        guard !hwSpending.hasPendingBroadcast else { return }
+        guard let address = order.payment?.onchain?.address, !address.isEmpty else { return }
+        do {
+            hwSpending.miningFeeSats = try await hwSigner.estimateOfflineFundingMiningFee(
+                deviceId: deviceId,
+                address: address,
+                sats: order.feeSat
+            )
+        } catch {
+            Logger.debug("Skipped offline hardware funding fee estimate for '\(deviceId)'", context: "TransferViewModel")
+        }
+    }
+
     /// Pay for the order by composing and signing the funding send on the Trezor (via the signer),
     /// then record and watch it. Coordination only — the device orchestration lives in `HwFundingSigner`.
     func onTransferToSpendingHwConfirm(order: IBtOrder, deviceId: String) {
@@ -564,8 +589,8 @@ class TransferViewModel: ObservableObject {
                         order: order,
                         deviceId: deviceId,
                         address: address
-                    ) { funding in
-                        self.hwSpending.miningFeeSats = funding.miningFeeSats
+                    ) { [weak self] funding in
+                        self?.hwSpending.miningFeeSats = funding.miningFeeSats
                     }
                     pendingHwFundingBroadcast = PendingHwFundingBroadcast(
                         orderId: order.id,

Bitkit/Views/Transfer/Hardware/SpendingHwSign.swift

@@ -44,9 +44,9 @@ struct SpendingHwSign: View {
         .navigationBarHidden(true)
         .padding(.horizontal, 16)
         .bottomSafeAreaPadding()
-        .task {
-            // Warm up the BLE connection ahead of the user tapping Open Trezor Connect.
+        .task(id: order.id) {
             transfer.warmUpHardwareConnection(deviceId: deviceId)
+            await transfer.updateHwFundingFeeEstimate(order: order, deviceId: deviceId)
         }
         .onChange(of: transfer.hwSignedEvent) {
             navigation.navigate(.spendingHwSigned)
@@ -77,7 +77,7 @@ struct SpendingHwSign: View {
                 accentColor: .purpleAccent
             )
 
-            SpendingHwFeeGrid(order: order)
+            SpendingHwFeeGrid(order: order, miningFeeSats: transfer.hwSpending.miningFeeSats)
                 .padding(.top, 16)
 
             HStack(spacing: 16) {
@@ -151,19 +151,28 @@ struct SpendingHwSign: View {
 /// Blocktank order fee summary shared by the hardware Sign and Signed screens.
 struct SpendingHwFeeGrid: View {
     let order: IBtOrder
+    var miningFeeSats: UInt64 = 0
+
+    private var lspFee: UInt64 {
+        order.feeSat - order.clientBalanceSat
+    }
+
+    private var total: UInt64 {
+        order.feeSat + miningFeeSats
+    }
 
     var body: some View {
         VStack(spacing: 16) {
             HStack {
                 FeeDisplayRow(
                     label: t("lightning__spending_confirm__network_fee"),
-                    amount: order.networkFeeSat
+                    amount: miningFeeSats
                 )
                 .frame(maxWidth: .infinity)
 
                 FeeDisplayRow(
                     label: t("lightning__spending_confirm__lsp_fee"),
-                    amount: order.serviceFeeSat
+                    amount: lspFee
                 )
                 .frame(maxWidth: .infinity)
             }
@@ -177,7 +186,7 @@ struct SpendingHwFeeGrid: View {
 
                 FeeDisplayRow(
                     label: t("lightning__spending_confirm__total"),
-                    amount: order.feeSat
+                    amount: total
                 )
                 .frame(maxWidth: .infinity)
             }

Bitkit/Views/Transfer/Hardware/SpendingHwSigned.swift

@@ -27,7 +27,7 @@ struct SpendingHwSigned: View {
 
             DisplayText(t("lightning__transfer_hw__signed_title"), accentColor: .purpleAccent)
 
-            SpendingHwFeeGrid(order: order)
+            SpendingHwFeeGrid(order: order, miningFeeSats: transfer.hwSpending.miningFeeSats)
                 .padding(.top, 16)
 
             Image("check")

BitkitTests/BroadcastConnectivityTests.swift

@@ -3,15 +3,36 @@ import BitkitCore
 import XCTest
 
 final class BroadcastConnectivityTests: XCTestCase {
-    func testElectrumBroadcastErrorIsConnectivityFailure() {
+    func testElectrumConnectFailureIsConnectivityFailure() {
+        XCTAssertTrue(
+            BroadcastError.ElectrumError(errorDetails: "Failed to connect to Electrum: offline")
+                .isBroadcastConnectivityFailure()
+        )
+    }
+
+    func testElectrumOfflineDetailsAreConnectivityFailure() {
         XCTAssertTrue(BroadcastError.ElectrumError(errorDetails: "offline").isBroadcastConnectivityFailure())
     }
 
-    func testWrappedElectrumBroadcastErrorIsConnectivityFailure() {
+    func testElectrumBroadcastRejectionIsNotConnectivityFailure() {
+        XCTAssertFalse(
+            BroadcastError.ElectrumError(errorDetails: "Broadcast failed: bad-txns-inputs-missingorspent")
+                .isBroadcastConnectivityFailure()
+        )
+    }
+
+    func testWrappedElectrumConnectFailureIsConnectivityFailure() {
         let error = Bitkit.AppError(error: BroadcastError.ElectrumError(errorDetails: "offline"))
         XCTAssertTrue(error.isBroadcastConnectivityFailure())
     }
 
+    func testWrappedElectrumBroadcastRejectionIsNotConnectivityFailure() {
+        let error = Bitkit.AppError(
+            error: BroadcastError.ElectrumError(errorDetails: "Broadcast failed: min relay fee not met")
+        )
+        XCTAssertFalse(error.isBroadcastConnectivityFailure())
+    }
+
     func testUnrelatedErrorIsNotConnectivityFailure() {
         XCTAssertFalse(Bitkit.AppError(message: "nope", debugMessage: nil).isBroadcastConnectivityFailure())
     }

BitkitTests/HwTransferMocks.swift

@@ -22,6 +22,7 @@ final class MockHwFunding: HwTransferFunding {
     var broadcastTxId = "txid"
 
     private(set) var composeCalls: [(address: String, sats: UInt64, satsPerVByte: UInt64)] = []
+    private(set) var estimateCalls: [(address: String, sats: UInt64, satsPerVByte: UInt64)] = []
     private(set) var maxSpendableCalls: [(address: String, satsPerVByte: UInt64)] = []
     private(set) var signCalls = 0
     private(set) var broadcastCalls = 0
@@ -55,6 +56,18 @@ final class MockHwFunding: HwTransferFunding {
         return funding
     }
 
+    func estimateOfflineFundingMiningFee(
+        deviceId _: String,
+        address: String,
+        sats: UInt64,
+        satsPerVByte: UInt64,
+        addressType _: AddressScriptType
+    ) async throws -> UInt64 {
+        estimateCalls.append((address, sats, satsPerVByte))
+        if let composeError { throw composeError }
+        return funding.miningFeeSats
+    }
+
     func signFunding(deviceId _: String, funding _: HwFundingTransaction) async throws -> HwFundingSignedTx {
         signCalls += 1
         if signDelay > 0 { try await Task.sleep(nanoseconds: UInt64(signDelay * 1_000_000_000)) }

BitkitTests/TransferViewModelHwTests.swift

@@ -274,6 +274,50 @@ final class TransferViewModelHwTests: XCTestCase {
         if case .generic = vm.hwTransferError {} else { XCTFail("expected .generic error") }
     }
 
+    func testElectrumBroadcastRejectionClearsPendingState() async {
+        let funding = MockHwFunding()
+        funding.broadcastError = BroadcastError.ElectrumError(
+            errorDetails: "Broadcast failed: bad-txns-inputs-missingorspent"
+        )
+        let vm = makeViewModel(funding: funding, connecting: MockHwConnecting())
+
+        vm.onTransferToSpendingHwConfirm(order: .mock(), deviceId: "dev1")
+        await awaitSigningComplete(vm)
+
+        XCTAssertFalse(vm.hwSpending.hasPendingBroadcast)
+        if case .generic = vm.hwTransferError {} else { XCTFail("expected .generic error") }
+        XCTAssertEqual(funding.signCalls, 1)
+    }
+
+    func testUpdateHwLimitsClearsDesyncedPendingBroadcast() async {
+        let funding = MockHwFunding()
+        let vm = makeViewModel(funding: funding, connecting: MockHwConnecting())
+        funding.broadcastError = BroadcastError.ElectrumError(errorDetails: "offline")
+        let order = IBtOrder.mock()
+
+        vm.onTransferToSpendingHwConfirm(order: order, deviceId: "dev1")
+        await awaitSigningComplete(vm)
+        XCTAssertTrue(vm.hwSpending.hasPendingBroadcast)
+
+        await vm.updateHwLimits(deviceId: "dev1", blocktankInfo: nil, estimateOrderFee: { _, _ in (0, 0) })
+
+        XCTAssertFalse(vm.hwSpending.hasPendingBroadcast)
+        vm.cancelHwSigning()
+        XCTAssertEqual(funding.signCalls, 1, "cancel after limits reload must not be blocked by stale pending tx")
+    }
+
+    func testUpdateHwFundingFeeEstimateSetsMiningFeeBeforeSigning() async {
+        let funding = MockHwFunding()
+        let vm = makeViewModel(funding: funding, connecting: MockHwConnecting())
+        let order = IBtOrder.mock()
+
+        await vm.updateHwFundingFeeEstimate(order: order, deviceId: "dev1")
+
+        XCTAssertEqual(vm.hwSpending.miningFeeSats, funding.funding.miningFeeSats)
+        XCTAssertEqual(funding.estimateCalls.count, 1)
+        XCTAssertTrue(funding.composeCalls.isEmpty)
+    }
+
     func testReentrancyGuardIgnoresConcurrentConfirm() async {
         let funding = MockHwFunding()
         funding.composeError = MockHwFunding.TestError() // fail before the network-bound funding tail