Merge pull request #621 from synonymdev/fix/hw-wallet-v1-polish

fix: polish trezor reliability and ux

Author: piotr-iohk

Bitkit.xcodeproj/project.pbxproj

@@ -1201,7 +1201,7 @@
 			repositoryURL = "https://github.com/synonymdev/bitkit-core";
 			requirement = {
 				kind = exactVersion;
-				version = 0.4.0;
+				version = 0.4.1;
 			};
 		};
 		96E20CD22CB6D91A00C24149 /* XCRemoteSwiftPackageReference "CodeScanner" */ = {

Bitkit.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -46,9 +46,14 @@ private struct HardwareWalletCell: View {
             onTap(wallet)
         } label: {
             VStack(alignment: .leading) {
-                CaptionMText(wallet.name)
-                    .lineLimit(1)
-                    .padding(.bottom, 4)
+                HStack(spacing: 4) {
+                    CaptionMText(wallet.name)
+                        .lineLimit(1)
+
+                    HwWalletConnectionIcon(isConnected: wallet.isConnected)
+                        .frame(width: 16, height: 16)
+                }
+                .padding(.bottom, 4)
 
                 HStack(spacing: 4) {
                     Image("btc-circle-blue")
@@ -63,9 +68,6 @@ private struct HardwareWalletCell: View {
                         enableHide: true,
                         symbolColor: .textPrimary
                     )
-
-                    HwWalletConnectionIcon(isConnected: wallet.isConnected)
-                        .frame(width: 16, height: 16)
                 }
             }
             .frame(maxWidth: .infinity, alignment: .leading)

Bitkit/Components/HardwareWalletsGrid.swift

@@ -0,0 +1,51 @@
+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 {
+            return broadcastError.isConnectivityFailure
+        }
+
+        if let appError = self as? AppError, let underlyingError = appError.underlyingError {
+            return underlyingError.isBroadcastConnectivityFailure()
+        }
+
+        return false
+    }
+}

Bitkit/Extensions/BroadcastError+Connectivity.swift

@@ -1,5 +1,7 @@
 import BitkitCore
 
+private let firmwareErrorCode = 99
+
 extension Error {
     /// Whether this error is a Trezor on-device cancellation (user declined signing, or cancelled PIN
     /// / passphrase entry). Distinct from Swift `CancellationError` (the flow/task being dismissed).
@@ -38,4 +40,20 @@ extension Error {
 
         return false
     }
+
+    func isTrezorFirmwareError() -> Bool {
+        if let appError = self as? AppError {
+            let message = appError.debugMessage ?? appError.message
+            if message.contains("Device error (code \(firmwareErrorCode))") && message.contains("Firmware error") {
+                return true
+            }
+            if let underlyingError = appError.underlyingError {
+                return underlyingError.isTrezorFirmwareError()
+            }
+            return false
+        }
+
+        let message = localizedDescription
+        return message.contains("Device error (code \(firmwareErrorCode))") && message.contains("Firmware error")
+    }
 }

Bitkit/Extensions/TrezorError+Cancellation.swift

@@ -13,6 +13,7 @@ struct MainNavView: View {
     @EnvironmentObject private var settings: SettingsViewModel
     @EnvironmentObject private var sheets: SheetViewModel
     @EnvironmentObject private var wallet: WalletViewModel
+    @EnvironmentObject private var transfer: TransferViewModel
     @Environment(TrezorManager.self) private var trezorManager
     @Environment(HwWalletManager.self) private var hwWalletManager
     @Environment(\.scenePhase) var scenePhase
@@ -32,6 +33,12 @@ struct MainNavView: View {
         NavigationStack(path: $navigation.path) {
             navigationContent
         }
+        .onChange(of: transfer.hwFundingComplete) { _, complete in
+            if complete {
+                transfer.consumeHwFundingComplete()
+                navigation.navigate(.spendingHwSigned)
+            }
+        }
         .sheet(
             item: $sheets.addTagSheetItem,
             onDismiss: {

Bitkit/MainNavView.swift

@@ -164,6 +164,17 @@ final class HwWalletManager {
         recomputeDerivedState()
     }
 
+    /// Removes a hardware wallet and forgets every device entry that belongs to its wallet identity.
+    func removeWallet(
+        _ wallet: HwWallet,
+        forgetDevice: (String) async -> Void
+    ) async {
+        removeDevice(id: wallet.id)
+        for deviceId in wallet.deviceIds {
+            await forgetDevice(deviceId)
+        }
+    }
+
     // MARK: - Watcher orchestration
 
     /// Reconcile watchers in response to a settings change, but only when the monitored address
@@ -536,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/Managers/HwWalletManager.swift

@@ -156,7 +156,6 @@ final class TrezorManager {
         default:
             Logger.info(message, context: "TrezorManager")
         }
-        TrezorDebugLog.shared.log(message)
     }
 
     // MARK: - State Reset Helpers
@@ -655,13 +654,37 @@ final class TrezorManager {
     /// failure so the transfer flow can surface a reconnect error.
     func ensureConnected(deviceId: String) async throws {
         if connectedDevice?.id == deviceId, await trezorService.isConnected() {
+            let features = try await refreshedFeaturesIfLocked()
+            try requireUnlocked(features: features)
             return
         }
         // A stale or mismatched session blocks a clean reconnect — clear it first.
         if connectedDevice != nil {
             await disconnectStaleSession(deviceId: connectedDevice?.id ?? deviceId)
         }
         try await reconnectKnownDevice(deviceId: deviceId)
+        try requireUnlocked(features: deviceFeatures)
+    }
+
+    private func refreshedFeaturesIfLocked() async throws -> TrezorFeatures {
+        guard let features = deviceFeatures else {
+            let refreshed = try await trezorService.refreshFeatures()
+            deviceFeatures = refreshed
+            return refreshed
+        }
+        if features.pinProtection == true, features.unlocked == false {
+            let refreshed = try await trezorService.refreshFeatures()
+            deviceFeatures = refreshed
+            return refreshed
+        }
+        return features
+    }
+
+    private func requireUnlocked(features: TrezorFeatures?) throws {
+        guard let features else { return }
+        if features.pinProtection == true, features.unlocked == false {
+            throw TrezorError.DeviceBusy
+        }
     }
 
     private func reconnectKnownDevice(deviceId: String) async throws {
@@ -710,12 +733,15 @@ final class TrezorManager {
     /// Tear down the current device session so the next connect establishes a fresh one. Used after
     /// a signing failure or timeout, where the transport session may be left in a bad state.
     func disconnectStaleSession(deviceId: String) async {
-        do {
-            try await trezorService.disconnect()
-        } catch {
-            trezorLog("Failed to disconnect stale session for '\(deviceId)': \(error)", level: "warn")
-        }
-        clearDisconnectedDeviceState()
+        await Task.detached { @MainActor [weak self] in
+            guard let self else { return }
+            do {
+                try await trezorService.disconnect()
+            } catch {
+                trezorLog("Failed to disconnect stale session for '\(deviceId)': \(error)", level: "warn")
+            }
+            clearDisconnectedDeviceState()
+        }.value
     }
 
     /// Reconstruct a `TrezorDeviceInfo` for reconnecting to a known BLE device when a fresh scan

Bitkit/Managers/TrezorManager.swift

@@ -39,7 +39,7 @@
 "hardware__connect_title" = "Connect Device";
 "hardware__connect_header" = "Searching for <accent>devices</accent>";
 "hardware__connect_text" = "Please connect your hardware wallet now via Bluetooth.";
-"hardware__connect_error" = "Could not connect to your Trezor. Check that it is unlocked and try again.";
+"hardware__connect_error" = "Could not connect to your hardware device. Make sure it is unlocked, nearby, and not connected to another phone or computer, then try again.";
 "hardware__search_error" = "Could not search for hardware wallets. Check your connection and try again.";
 "hardware__pairing_code_invalid" = "Incorrect pairing code. Put your Trezor back in pairing mode and try again.";
 "hardware__device_busy" = "Your Trezor is busy. Unlock it on the device, then try again.";