fix: reconnect known ble trezors

Author: ovitrif

app/src/main/java/to/bitkit/repositories/TrezorRepo.kt

@@ -644,6 +644,8 @@ class TrezorRepo @Inject constructor(
             awaitSetup()
             TrezorDebugLog.log("RECONNECT", "Setup OK")
             TrezorDebugLog.log("RECONNECT", "Scanning for devices...")
+            val knownDevices = (_state.value.knownDevices + loadKnownDevices()).distinctBy { it.id }
+            val knownDevice = knownDevices.find { it.matches(deviceId) }
             val scannedDevices = trezorService.scan()
             TrezorDebugLog.log(
                 "RECONNECT",
@@ -652,6 +654,7 @@ class TrezorRepo @Inject constructor(
             // Honor the transport the user selected — connect to exactly the
             // entry they tapped instead of overriding Bluetooth with USB.
             val device = scannedDevices.find { it.id == deviceId }
+                ?: knownDevice?.takeIf { it.transportType == TransportType.BLUETOOTH }?.toDeviceInfo()
                 ?: throw AppError("Device not found nearby — is it powered on?")
             TrezorDebugLog.log("RECONNECT", "Found matching device: id=${device.id}, name=${device.name}")
             TrezorDebugLog.log("RECONNECT", "Calling connectWithThpRetry...")
@@ -952,15 +955,27 @@ class TrezorRepo @Inject constructor(
                 throw e
             }
             TrezorDebugLog.log("THPRetry", "Error is retryable, attempting second connect...")
-            Logger.warn("Connection failed for $deviceId, retrying", e, context = TAG)
+            Logger.warn("Failed to connect to '$deviceId', retrying", e, context = TAG)
             logCredentialFileState(deviceId, "BEFORE 2nd attempt")
-            val result = connectDevice(deviceId, selection, requestUsbPermission)
+            val result = runSuspendCatching {
+                connectDevice(deviceId, selection, requestUsbPermission)
+            }.onFailure {
+                disconnectAfterFailedConnect(deviceId)
+            }.getOrThrow()
             logCredentialFileState(deviceId, "AFTER 2nd attempt (success)")
             TrezorDebugLog.log("THPRetry", "Second attempt succeeded")
             result
         }
     }
 
+    private suspend fun disconnectAfterFailedConnect(deviceId: String) {
+        runSuspendCatching { trezorService.disconnect() }
+            .onFailure {
+                Logger.warn("Failed to disconnect stale Trezor session for '$deviceId'", it, context = TAG)
+            }
+        _state.update { it.copy(connected = null) }
+    }
+
     private suspend fun connectDevice(
         deviceId: String,
         selection: WalletSelection,
@@ -1034,6 +1049,16 @@ data class KnownDevice(
 
 private fun KnownDevice.matches(deviceId: String) = id == deviceId || path == deviceId
 
+private fun KnownDevice.toDeviceInfo() = TrezorDeviceInfo(
+    id = id,
+    transportType = transportType.toCoreTransportType(),
+    name = name,
+    path = path,
+    label = label,
+    model = model,
+    isBootloader = false,
+)
+
 private fun TrezorTransportType.toTransportType(): TransportType = when (this) {
     TrezorTransportType.BLUETOOTH -> TransportType.BLUETOOTH
     TrezorTransportType.USB -> TransportType.USB

app/src/test/java/to/bitkit/repositories/TrezorRepoTest.kt

@@ -634,6 +634,21 @@ class TrezorRepoTest : BaseUnitTest() {
         verify(trezorService, times(2)).connect(eq(DEVICE_ID), any())
     }
 
+    @Test
+    fun `connect should disconnect stale session after retryable THP failures`() = test {
+        whenever(trezorService.connect(eq(DEVICE_ID), any()))
+            .thenThrow(RuntimeException("thp timeout"))
+            .thenThrow(RuntimeException("session timeout"))
+        sut = createSut()
+
+        val result = sut.connect(DEVICE_ID)
+
+        assertTrue(result.isFailure)
+        assertNull(sut.state.value.connected)
+        verify(trezorService, times(2)).connect(eq(DEVICE_ID), any())
+        verify(trezorService).disconnect()
+    }
+
     @Test
     fun `connect should not retry non-retryable errors`() = test {
         whenever(trezorService.connect(eq(DEVICE_ID), any())).thenThrow(RuntimeException("bad pin"))
@@ -980,6 +995,29 @@ class TrezorRepoTest : BaseUnitTest() {
         assertEquals(DEVICE_ID, sut.state.value.connectedDeviceId)
     }
 
+    @Test
+    fun `connectKnownDevice should use stored bluetooth device when scan misses active connection`() = test {
+        val bleDeviceId = "ble:57:21:A7:F9:DD:AD"
+        val knownDevice = mockKnownDevice(
+            id = bleDeviceId,
+            path = bleDeviceId,
+            transportType = TransportType.BLUETOOTH,
+        )
+        val features = mockFeatures()
+        whenever(hwWalletStore.loadKnownDevices()).thenReturn(listOf(knownDevice))
+        whenever(trezorService.scan()).thenReturn(emptyList())
+        whenever(trezorService.connect(eq(bleDeviceId), any())).thenReturn(features)
+        sut = createSut()
+
+        sut.initialize()
+        val result = sut.connectKnownDevice(bleDeviceId)
+
+        assertTrue(result.isSuccess)
+        assertEquals(features, result.getOrNull())
+        assertEquals(bleDeviceId, sut.state.value.connectedDeviceId)
+        verify(trezorService).connect(eq(bleDeviceId), any())
+    }
+
     // endregion
 
     // region clearError