fix: delegate wallet ids to core

Author: ovitrif

app/src/main/java/to/bitkit/models/ActivityWalletType.kt

@@ -1,6 +1,5 @@
 package to.bitkit.models
 
-import java.security.MessageDigest
 import java.util.Locale
 
 enum class ActivityWalletType {
@@ -15,15 +14,6 @@ enum class ActivityWalletType {
 
     fun scopedId(value: String): String = "$prefix$value"
 
-    fun deriveId(keys: Collection<String>): String {
-        val normalizedKeys = keys.filter { it.isNotBlank() }
-        if (normalizedKeys.isEmpty()) return ""
-
-        val hash = MessageDigest.getInstance("SHA-256")
-            .digest(normalizedKeys.sorted().joinToString("\n").toByteArray(Charsets.UTF_8))
-        return scopedId(hash.joinToString("") { "%02x".format(it) })
-    }
-
     private val prefix: String
         get() = "$id:"
 }

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

@@ -38,7 +38,6 @@ import to.bitkit.ext.rawId
 import to.bitkit.ext.runSuspendCatching
 import to.bitkit.ext.scopedId
 import to.bitkit.ext.walletId
-import to.bitkit.models.ActivityWalletType
 import to.bitkit.models.HwFundingAccount
 import to.bitkit.models.HwFundingAddressType
 import to.bitkit.models.HwFundingBroadcastResult
@@ -415,7 +414,7 @@ class HwWalletRepo @Inject constructor(
     private fun List<KnownDevice>.toWatcherSpecs(watcherSettings: WatcherSettings): List<WatcherSpec> =
         flatMap { device ->
             val walletId = device.walletId.takeIf { it.isNotBlank() }
-                ?: ActivityWalletType.TREZOR.deriveId(device.xpubs.values)
+                ?: trezorRepo.deriveWalletId(device.xpubs.values)
             if (walletId.isBlank()) return@flatMap emptyList()
 
             device.xpubs

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

@@ -764,6 +764,12 @@ class TrezorRepo @Inject constructor(
         }
     }
 
+    fun deriveWalletId(xpubs: Collection<String>): String {
+        val xpubList = xpubs.toList()
+        if (xpubList.isEmpty() || xpubList.any { it.isBlank() }) return ""
+        return trezorService.deriveWalletId(ActivityWalletType.TREZOR.id, xpubList)
+    }
+
     suspend fun stopWatcher(watcherId: String): Result<Unit> = withContext(ioDispatcher) {
         runCatching {
             awaitSetup()
@@ -888,7 +894,7 @@ class TrezorRepo @Inject constructor(
             lastConnectedAt = clock.nowMs(),
             xpubs = xpubs,
             customLabel = previous?.customLabel,
-            walletId = knownDevices.findHardwareWalletId(deviceInfo.id, xpubs),
+            walletId = knownDevices.findHardwareWalletId(deviceInfo.id, xpubs, ::deriveWalletId),
         )
         val updated = knownDevices.filter { it.id != known.id } + known
         saveKnownDevices(updated)
@@ -918,7 +924,7 @@ class TrezorRepo @Inject constructor(
 
     private suspend fun loadKnownDevices(): List<KnownDevice> = runCatching {
         val devices = hwWalletStore.loadKnownDevices()
-        val migrated = devices.withHardwareWalletIds()
+        val migrated = devices.withHardwareWalletIds(::deriveWalletId)
         if (migrated != devices) {
             hwWalletStore.saveKnownDevices(migrated)
         }
@@ -1088,30 +1094,32 @@ private val KnownDevice.walletKey: String
 private fun walletKey(xpubs: Map<String, String>, fallback: String): String =
     xpubs.values.sorted().joinToString().ifEmpty { fallback }
 
-private fun List<KnownDevice>.findHardwareWalletId(deviceId: String, xpubs: Map<String, String>): String {
+private fun List<KnownDevice>.findHardwareWalletId(
+    deviceId: String,
+    xpubs: Map<String, String>,
+    deriveWalletId: (Collection<String>) -> String,
+): String {
     val walletKey = walletKey(xpubs, deviceId)
     firstOrNull { it.walletKey == walletKey }?.walletId?.takeIf { it.isNotBlank() }?.let { return it }
-    if (xpubs.values.any { it.isNotBlank() }) return deriveHardwareWalletId(xpubs)
+    if (xpubs.values.any { it.isNotBlank() }) return deriveWalletId(xpubs.values)
 
     return firstOrNull { it.id == deviceId }?.walletId?.takeIf { it.isNotBlank() }.orEmpty()
 }
 
-private fun List<KnownDevice>.withHardwareWalletIds(): List<KnownDevice> {
+private fun List<KnownDevice>.withHardwareWalletIds(
+    deriveWalletId: (Collection<String>) -> String,
+): List<KnownDevice> {
     val existingByWallet = filter { it.walletId.isNotBlank() }
         .associate { it.walletKey to it.walletId }
     val generatedByWallet = mutableMapOf<String, String>()
 
     return map {
         val walletId = existingByWallet[it.walletKey]
-            ?: generatedByWallet.getOrPut(it.walletKey) { deriveHardwareWalletId(it.xpubs) }
+            ?: generatedByWallet.getOrPut(it.walletKey) { deriveWalletId(it.xpubs.values) }
         if (it.walletId == walletId) it else it.copy(walletId = walletId)
     }
 }
 
-private fun deriveHardwareWalletId(xpubs: Map<String, String>): String {
-    return ActivityWalletType.TREZOR.deriveId(xpubs.values)
-}
-
 private const val DEFAULT_GAP_LIMIT = 20u
 
 private fun KnownDevice.toDeviceInfo() = TrezorDeviceInfo(

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

@@ -50,6 +50,7 @@ import to.bitkit.async.ServiceQueue
 import javax.inject.Inject
 import javax.inject.Singleton
 import com.synonym.bitkitcore.Network as BitkitCoreNetwork
+import com.synonym.bitkitcore.deriveWalletId as deriveCoreWalletId
 
 @Suppress("TooManyFunctions")
 @Singleton
@@ -301,4 +302,8 @@ class TrezorService @Inject constructor(
             onchainStopAllWatchers()
         }
     }
+
+    fun deriveWalletId(deviceType: String, xpubs: Collection<String>): String {
+        return deriveCoreWalletId(deviceType = deviceType, xpubs = xpubs.toList())
+    }
 }

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

@@ -25,7 +25,6 @@ import org.mockito.kotlin.never
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
-import org.mockito.kotlin.wheneverBlocking
 import to.bitkit.data.HwWalletData
 import to.bitkit.data.HwWalletStore
 import to.bitkit.data.SettingsData
@@ -84,11 +83,12 @@ class HwWalletRepoTest : BaseUnitTest() {
         whenever(settingsStore.data).thenReturn(settingsData)
         whenever(trezorRepo.state).thenReturn(trezorState)
         whenever(trezorRepo.watcherEvents).thenReturn(watcherEvents)
-        wheneverBlocking {
+        whenever(trezorRepo.deriveWalletId(any())).thenReturn(trezorWalletId)
+        whenever {
             trezorRepo.startWatcher(any(), any(), any(), any(), anyOrNull(), anyOrNull(), any())
         }.thenReturn(Result.success(Unit))
-        wheneverBlocking { activityRepo.persistHardwareActivities(any(), any()) }.thenReturn(Result.success(Unit))
-        wheneverBlocking { activityRepo.deleteActivitiesForWallet(any()) }.thenReturn(Result.success(Unit))
+        whenever { activityRepo.persistHardwareActivities(any(), any()) }.thenReturn(Result.success(Unit))
+        whenever { activityRepo.deleteActivitiesForWallet(any()) }.thenReturn(Result.success(Unit))
     }
 
     private fun createRepo() = HwWalletRepo(
@@ -180,7 +180,7 @@ class HwWalletRepoTest : BaseUnitTest() {
     @Test
     fun `transactions changed event is not exposed when persistence fails`() = test {
         val activity = onchainActivity(txid = "t1", amount = 10_562_411uL)
-        wheneverBlocking { activityRepo.persistHardwareActivities(listOf(activity), emptyList()) }
+        whenever { activityRepo.persistHardwareActivities(listOf(activity), emptyList()) }
             .thenReturn(Result.failure(AppError("persist failed")))
         val sut = createRepo()
 

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

@@ -102,6 +102,9 @@ class TrezorRepoTest : BaseUnitTest() {
         whenever(settingsStore.data).thenReturn(settingsData)
         whenever(context.filesDir).thenReturn(tempFolder.root)
         whenever { hwWalletStore.loadKnownDevices() }.thenReturn(emptyList())
+        whenever(trezorService.deriveWalletId(any(), any())).thenAnswer {
+            walletIdFor(*it.getArgument<Collection<String>>(1).toTypedArray())
+        }
     }
 
     private fun createSut(): TrezorRepo = TrezorRepo(
@@ -115,6 +118,9 @@ class TrezorRepoTest : BaseUnitTest() {
         ioDispatcher = testDispatcher,
     )
 
+    private fun walletIdFor(vararg xpubs: String): String =
+        ActivityWalletType.TREZOR.scopedId(xpubs.sorted().joinToString("|"))
+
     @Suppress("LongParameterList")
     private fun mockDeviceInfo(
         id: String = DEVICE_ID,
@@ -208,7 +214,8 @@ class TrezorRepoTest : BaseUnitTest() {
         val saved = savedCaptor.firstValue.single()
         assertEquals(knownDevice.id, saved.id)
         assertTrue(ActivityWalletType.TREZOR.owns(saved.walletId))
-        assertEquals(ActivityWalletType.TREZOR.deriveId(listOf("zpubNS")), saved.walletId)
+        assertEquals(walletIdFor("zpubNS"), saved.walletId)
+        verify(trezorService).deriveWalletId(ActivityWalletType.TREZOR.id, listOf("zpubNS"))
         assertEquals(listOf(saved), sut.state.value.knownDevices)
     }
 
@@ -625,7 +632,8 @@ class TrezorRepoTest : BaseUnitTest() {
         val captor = argumentCaptor<List<KnownDevice>>()
         verify(hwWalletStore).saveKnownDevices(captor.capture())
         val saved = captor.firstValue.single()
-        assertEquals(ActivityWalletType.TREZOR.deriveId(listOf("captured-native-xpub")), saved.walletId)
+        assertEquals(walletIdFor("captured-native-xpub"), saved.walletId)
+        verify(trezorService).deriveWalletId(ActivityWalletType.TREZOR.id, listOf("captured-native-xpub"))
     }
 
     @Test
@@ -671,8 +679,8 @@ class TrezorRepoTest : BaseUnitTest() {
 
     @Test
     fun `connect derives new wallet id when same device id has different xpub identity`() = test {
-        val oldWalletId = ActivityWalletType.TREZOR.deriveId(listOf("old-native-xpub"))
-        val newWalletId = ActivityWalletType.TREZOR.deriveId(listOf("new-native-xpub"))
+        val oldWalletId = walletIdFor("old-native-xpub")
+        val newWalletId = walletIdFor("new-native-xpub")
         val nativeSegwitPath = "m/84'/1'/0'"
         val previousDevice = mockKnownDevice(
             id = DEVICE_ID,