fix: address trezor review comments

app/src/main/java/to/bitkit/data/TrezorStore.kt

@@ -4,10 +4,13 @@ import android.content.Context
 import androidx.datastore.core.DataStore
 import androidx.datastore.dataStore
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
 import kotlinx.serialization.Serializable
 import to.bitkit.data.serializers.TrezorDataSerializer
+import to.bitkit.di.IoDispatcher
 import to.bitkit.repositories.KnownDevice
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -20,20 +23,24 @@ private val Context.trezorDataStore: DataStore<TrezorData> by dataStore(
 @Singleton
 class TrezorStore @Inject constructor(
     @ApplicationContext private val context: Context,
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) {
     private val store = context.trezorDataStore
 
     val data: Flow<TrezorData> = store.data
 
-    suspend fun loadKnownDevices(): List<KnownDevice> =
+    suspend fun loadKnownDevices(): List<KnownDevice> = withContext(ioDispatcher) {
         store.data.first().knownDevices
+    }
 
-    suspend fun saveKnownDevices(devices: List<KnownDevice>) {
+    suspend fun saveKnownDevices(devices: List<KnownDevice>) = withContext(ioDispatcher) {
         store.updateData { it.copy(knownDevices = devices) }
+        Unit
     }
 
-    suspend fun reset() {
+    suspend fun reset() = withContext(ioDispatcher) {
         store.updateData { TrezorData() }
+        Unit
     }
 }
 

app/src/main/java/to/bitkit/data/serializers/TrezorDataSerializer.kt

@@ -9,13 +9,15 @@ import java.io.InputStream
 import java.io.OutputStream
 
 object TrezorDataSerializer : Serializer<TrezorData> {
+    private const val TAG = "TrezorDataSerializer"
+
     override val defaultValue: TrezorData = TrezorData()
 
     override suspend fun readFrom(input: InputStream): TrezorData {
         return try {
             json.decodeFromString(input.readBytes().decodeToString())
         } catch (e: SerializationException) {
-            Logger.error("Failed to deserialize: $e")
+            Logger.error("Deserialize Trezor data failed", e, context = TAG)
             defaultValue
         }
     }

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

@@ -1,6 +1,7 @@
 package to.bitkit.repositories
 
 import android.content.Context
+import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.Stable
 import com.synonym.bitkitcore.AccountInfoResult
 import com.synonym.bitkitcore.AccountType
@@ -21,6 +22,9 @@ import com.synonym.bitkitcore.TrezorSignedTx
 import com.synonym.bitkitcore.TrezorTransportType
 import com.synonym.bitkitcore.WalletParams
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -88,7 +92,7 @@ class TrezorRepo @Inject constructor(
             Logger.debug("Initializing Trezor with credential path: '$credentialPath'", context = TAG)
             trezorService.initialize(credentialPath)
             val known = loadKnownDevices()
-            _state.update { it.copy(isInitialized = true, knownDevices = known, error = null) }
+            _state.update { it.copy(isInitialized = true, knownDevices = known.toImmutableList(), error = null) }
         }.onFailure { e ->
             Logger.error("Trezor init failed", e, context = TAG)
             _state.update { it.copy(error = e.message) }
@@ -101,7 +105,7 @@ class TrezorRepo @Inject constructor(
             val devices = trezorService.scan()
             val knownIds = _state.value.knownDevices.map { it.id }.toSet()
             val nearby = devices.filter { it.id !in knownIds }
-            _state.update { it.copy(isScanning = false, nearbyDevices = nearby) }
+            _state.update { it.copy(isScanning = false, nearbyDevices = nearby.toImmutableList()) }
             devices
         }.onFailure { e ->
             Logger.error("Trezor scan failed", e, context = TAG)
@@ -114,7 +118,7 @@ class TrezorRepo @Inject constructor(
             val devices = trezorService.listDevices()
             val knownIds = _state.value.knownDevices.map { it.id }.toSet()
             val nearby = devices.filter { it.id !in knownIds }
-            _state.update { it.copy(nearbyDevices = nearby) }
+            _state.update { it.copy(nearbyDevices = nearby.toImmutableList()) }
             devices
         }.onFailure { e ->
             Logger.error("Trezor listDevices failed", e, context = TAG)
@@ -151,7 +155,7 @@ class TrezorRepo @Inject constructor(
                     isConnecting = false,
                     connectedDevice = features,
                     connectedDeviceId = deviceId,
-                    nearbyDevices = it.nearbyDevices.filter { d -> d.id != deviceId },
+                    nearbyDevices = it.nearbyDevices.filter { d -> d.id != deviceId }.toImmutableList(),
                 )
             }
             features
@@ -318,7 +322,7 @@ class TrezorRepo @Inject constructor(
     suspend fun disconnect(): Result<Unit> = withContext(ioDispatcher) {
         runCatching {
             TrezorDebugLog.log("DISCONNECT", "disconnect() called, connectedDeviceId=${_state.value.connectedDeviceId}")
-            runCatching { trezorService.disconnect() }
+            trezorService.disconnect()
             _state.update {
                 it.copy(connectedDevice = null, connectedDeviceId = null, lastAddress = null, lastPublicKey = null)
             }
@@ -386,7 +390,7 @@ class TrezorRepo @Inject constructor(
                 initialize(walletIndex).getOrThrow()
             }
             if (trezorService.isConnected()) {
-                _state.value.connectedDevice ?: error("Connected but no features")
+                _state.value.connectedDevice ?: throw AppError("Connected but no features")
             } else {
                 val scannedDevices = scan().getOrThrow()
                 val knownIds = knownDevices.map { it.id }.toSet()
@@ -396,7 +400,7 @@ class TrezorRepo @Inject constructor(
                 val idMatch = knownDevices.firstNotNullOfOrNull { known ->
                     scannedDevices.find { it.id == known.id }
                 }
-                val match = idMatch ?: usbDevice ?: error("No known device found nearby")
+                val match = idMatch ?: usbDevice ?: throw AppError("No known device found nearby")
                 connect(match.id).getOrThrow()
             }
         }.onSuccess {
@@ -436,7 +440,7 @@ class TrezorRepo @Inject constructor(
                 TrezorDebugLog.log("RECONNECT", "Preferring USB over BLE")
                 usbDevice
             } else {
-                exactMatch ?: error("Device not found nearby — is it powered on?")
+                exactMatch ?: 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...")
@@ -459,15 +463,15 @@ class TrezorRepo @Inject constructor(
         runCatching {
             TrezorDebugLog.log("FORGET", "forgetDevice called for: $deviceId")
             if (_state.value.connectedDeviceId == deviceId) {
-                runCatching { trezorService.disconnect() }
+                trezorService.disconnect()
                 _state.update { it.copy(connectedDevice = null, connectedDeviceId = null) }
             }
             TrezorDebugLog.log("FORGET", "Clearing credentials...")
             trezorTransport.clearDeviceCredential(deviceId)
-            runCatching { trezorService.clearCredentials(deviceId) }
+            trezorService.clearCredentials(deviceId)
             val updated = _state.value.knownDevices.filter { it.id != deviceId }
             saveKnownDevices(updated)
-            _state.update { it.copy(knownDevices = updated) }
+            _state.update { it.copy(knownDevices = updated.toImmutableList()) }
             TrezorDebugLog.log("FORGET", "Device forgotten successfully")
             Logger.info("Forgot device: '$deviceId'", context = TAG)
         }.onFailure { e ->
@@ -510,7 +514,7 @@ class TrezorRepo @Inject constructor(
         )
         val updated = existing.filter { it.id != known.id } + known
         saveKnownDevices(updated)
-        _state.update { it.copy(knownDevices = updated) }
+        _state.update { it.copy(knownDevices = updated.toImmutableList()) }
     }
 
     private suspend fun loadKnownDevices(): List<KnownDevice> = runCatching {
@@ -531,13 +535,13 @@ class TrezorRepo @Inject constructor(
         if (trezorService.isConnected()) return
         val deviceId = _state.value.connectedDeviceId
             ?: _state.value.knownDevices.firstOrNull()?.id
-            ?: error("No device to reconnect")
+            ?: throw AppError("No device to reconnect")
         if (!_state.value.isInitialized) {
             initialize().getOrThrow()
         }
         val devices = trezorService.scan()
         val device = devices.find { it.id == deviceId }
-            ?: error("Device not found during reconnect")
+            ?: throw AppError("Device not found during reconnect")
         val features = connectWithThpRetry(device.id)
         _state.update { it.copy(connectedDevice = features, connectedDeviceId = deviceId) }
     }
@@ -598,8 +602,8 @@ data class TrezorState(
     val isScanning: Boolean = false,
     val isConnecting: Boolean = false,
     val isAutoReconnecting: Boolean = false,
-    val knownDevices: List<KnownDevice> = emptyList(),
-    val nearbyDevices: List<TrezorDeviceInfo> = emptyList(),
+    val knownDevices: ImmutableList<KnownDevice> = persistentListOf(),
+    val nearbyDevices: ImmutableList<TrezorDeviceInfo> = persistentListOf(),
     val connectedDevice: TrezorFeatures? = null,
     val connectedDeviceId: String? = null,
     val lastAddress: TrezorAddressResponse? = null,
@@ -608,6 +612,7 @@ data class TrezorState(
 )
 
 @Serializable
+@Immutable
 data class KnownDevice(
     val id: String,
     val name: String?,

app/src/main/java/to/bitkit/services/TrezorDebugLog.kt

@@ -1,5 +1,8 @@
 package to.bitkit.services
 
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
@@ -10,8 +13,8 @@ import java.util.Locale
 
 object TrezorDebugLog {
     private const val MAX_LINES = 300
-    private val _lines = MutableStateFlow<List<String>>(emptyList())
-    val lines: StateFlow<List<String>> = _lines.asStateFlow()
+    private val _lines = MutableStateFlow<ImmutableList<String>>(persistentListOf())
+    val lines: StateFlow<ImmutableList<String>> = _lines.asStateFlow()
 
     private val fmt = SimpleDateFormat("HH:mm:ss.SSS", Locale.US)
 
@@ -20,11 +23,15 @@ object TrezorDebugLog {
         val line = "$ts [$tag] $msg"
         _lines.update { current ->
             val updated = current + line
-            if (updated.size > MAX_LINES) updated.takeLast(MAX_LINES) else updated
+            if (updated.size > MAX_LINES) {
+                updated.takeLast(MAX_LINES).toImmutableList()
+            } else {
+                updated.toImmutableList()
+            }
         }
     }
 
     fun clear() {
-        _lines.update { emptyList() }
+        _lines.update { persistentListOf() }
     }
 }

app/src/main/java/to/bitkit/services/TrezorTransport.kt

@@ -375,8 +375,12 @@ class TrezorTransport @Inject constructor(
 
             if (credentialJson.isEmpty()) {
                 val existed = file.exists()
-                file.delete()
+                val deleted = !existed || file.delete()
                 TrezorDebugLog.log("SAVE", "CLEARED credential (file existed=$existed)")
+                if (!deleted) {
+                    Logger.warn("Clear THP credential file failed for '${file.absolutePath}'", context = TAG)
+                    return false
+                }
                 Logger.info(
                     "Cleared THP credential for device: '$deviceId' (path='${file.absolutePath}')",
                     context = TAG,
@@ -395,6 +399,7 @@ class TrezorTransport @Inject constructor(
             )
             if (!verifyExists || verifySize == 0L) {
                 TrezorDebugLog.log("SAVE", "WARNING: File verification FAILED after write!")
+                return false
             }
 
             Logger.info(
@@ -856,7 +861,7 @@ class TrezorTransport @Inject constructor(
             ?: return TrezorTransportWriteResult(success = true, error = "")
 
         userInitiatedCloseSet.add(path)
-        try {
+        return try {
             val disconnectLatch = CountDownLatch(1)
             bleConnections[path] = connection.copy(disconnectLatch = disconnectLatch)
 
@@ -870,14 +875,14 @@ class TrezorTransport @Inject constructor(
             bleConnections.remove(path)
             connection.gatt.close()
             Thread.sleep(100)
+            Logger.info("BLE device closed: '$path'", context = TAG)
+            TrezorTransportWriteResult(success = true, error = "")
         } catch (e: Exception) {
             Logger.error("BLE close failed", e, context = TAG)
+            TrezorTransportWriteResult(success = false, error = e.message ?: "BLE close failed")
         } finally {
             userInitiatedCloseSet.remove(path)
         }
-
-        Logger.info("BLE device closed: '$path'", context = TAG)
-        return TrezorTransportWriteResult(success = true, error = "")
     }
 
     @Suppress("TooGenericExceptionCaught")
@@ -1004,6 +1009,17 @@ class TrezorTransport @Inject constructor(
             val path = "ble:${gatt.device.address}"
             val connection = bleConnections[path]
 
+            if (status != BluetoothGatt.GATT_SUCCESS) {
+                Logger.warn("BLE connection state changed with status '$status' for '$path'", context = TAG)
+                connection?.isConnected = false
+                connection?.connectionLatch?.countDown()
+                connection?.disconnectLatch?.countDown()
+                if (!userInitiatedCloseSet.remove(path)) {
+                    _externalDisconnect.tryEmit(path)
+                }
+                return
+            }
+
             when (newState) {
                 BluetoothProfile.STATE_CONNECTED -> {
                     Logger.debug("BLE connected, requesting MTU: '$path'", context = TAG)

app/src/main/java/to/bitkit/ui/screens/trezor/TrezorScreen.kt

@@ -45,6 +45,7 @@ import androidx.navigation.NavController
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.rememberMultiplePermissionsState
 import com.synonym.bitkitcore.CoinSelection
+import kotlinx.collections.immutable.toImmutableList
 import to.bitkit.R
 import to.bitkit.repositories.KnownDevice
 import to.bitkit.repositories.TrezorState
@@ -657,8 +658,8 @@ private fun PreviewWithDevices() {
         Content(
             trezorState = TrezorState(
                 isInitialized = true,
-                knownDevices = listOf(TrezorPreviewData.sampleKnownDevice),
-                nearbyDevices = listOf(TrezorPreviewData.sampleNearbyDevice),
+                knownDevices = listOf(TrezorPreviewData.sampleKnownDevice).toImmutableList(),
+                nearbyDevices = listOf(TrezorPreviewData.sampleNearbyDevice).toImmutableList(),
                 connectedDeviceId = TrezorPreviewData.sampleKnownDevice.id,
             ),
             uiState = TrezorUiState(),

app/src/main/java/to/bitkit/ui/screens/trezor/TrezorViewModel.kt

@@ -64,6 +64,7 @@ class TrezorViewModel @Inject constructor(
                     val label = it.label ?: it.model ?: "Trezor"
                     ToastEventBus.send(type = Toast.ToastType.INFO, title = "Reconnected to $label")
                 }
+                .onFailure { ToastEventBus.send(it) }
         }
     }
 
@@ -404,9 +405,8 @@ class TrezorViewModel @Inject constructor(
             val accountInfo = state.accountInfoResult ?: return@launch
             if (!validateComposeInputs(state)) return@launch
 
-            _uiState.update { it.copy(isComposing = true) }
-
             val feeRate = state.sendFeeRate.toFloatOrNull() ?: return@launch
+            _uiState.update { it.copy(isComposing = true) }
             TrezorDebugLog.log("COMPOSE", "=== composeTx START ===")
             TrezorDebugLog.log("COMPOSE", "address=${state.sendAddress}")
             TrezorDebugLog.log("COMPOSE", "amount=${state.sendAmountSats}, sendMax=${state.isSendMax}")

changelog.d/next/792.added.md

@@ -0,0 +1 @@
+Added Trezor hardware wallet support for connecting devices, signing messages, and managing on-chain transactions.