Merge branch 'master' into feature/MOBILE-685

Resolve Trezor EVM signer conflicts for USB support: personal_sign (verify
wallet) now signs on-device over USB via trezor-kit 1.1.1 (signEthereumMessage),
reusing the recovery-id/address check; eth_sign and typed data stay unsupported.
Wire EvmSignerFactory to ITrezorClient and route EVM signer construction through
it; bump trezor-kit to 1.1.1.

Author: oleonov

app/build.gradle

@@ -15,6 +15,7 @@ plugins {
     id 'com.google.gms.google-services'
     id 'org.jetbrains.kotlin.plugin.serialization'
     id 'androidx.navigation.safeargs.kotlin'
+    id 'io.github.takahirom.roborazzi' version '1.65.0'
     id 'androidx.baselineprofile'
 }
 
@@ -241,8 +242,11 @@ android {
 
     testOptions {
         unitTests.returnDefaultValues = true
+        unitTests.includeAndroidResources = true
         unitTests.all {
             useJUnitPlatform()
+            maxHeapSize = "2g"
+            forkEvery = 80
         }
     }
 
@@ -515,6 +519,18 @@ dependencies {
     testRuntimeOnly libs.spek.runner.junit5
     testRuntimeOnly libs.kotlin.reflect
 
+    // Roborazzi — JVM screenshot rendering of @Preview composables (no emulator)
+    testImplementation platform(libs.compose.bom)
+    testImplementation libs.roborazzi
+    testImplementation libs.roborazzi.compose
+    testImplementation libs.roborazzi.preview.scanner.support
+    testImplementation libs.composable.preview.scanner.android
+    testImplementation libs.robolectric
+    testImplementation libs.compose.ui.test.junit4
+    // Robolectric runners are JUnit4; the module runs tests on the JUnit Platform,
+    // so the vintage engine is required to discover and run them.
+    testRuntimeOnly 'org.junit.vintage:junit-vintage-engine'
+
     //Android Tor
     implementation libs.tor.android
 
@@ -568,6 +584,19 @@ tasks.register('cleanMacOsMetadata') {
 }
 preBuild.dependsOn cleanMacOsMetadata
 
+// Roborazzi preview screenshots are a local design-review tool, not a CI gate.
+// Robolectric renders differently across OSes (fonts/colors), so running them on
+// CI (Linux) would be flaky against images recorded elsewhere. Keep them out of the
+// normal unit-test run (including CI's :app:testDebugUnitTest) unless explicitly
+// opted in with -Pscreenshots (used by the record/verify commands).
+tasks.withType(Test).configureEach {
+    if (!project.hasProperty('screenshots')) {
+        filter {
+            excludeTestsMatching 'cash.p.terminal.screenshots.*'
+        }
+    }
+}
+
 // Single entry point. Runs one generation journey on the DISPOSABLE
 // cash.p.terminal.baseline sandbox (onboarding → create wallet → tabs → search →
 // cold restart with wallet → second wallet + switch) and copies the resulting

app/src/main/java/cash/p/terminal/core/MarketKitExtensions.kt

@@ -269,14 +269,13 @@ val BlockchainType.isEvm: Boolean
             -> false
     }
 
-val BlockchainType.isUtxoBased: Boolean
+val BlockchainType.isBtcLike: Boolean
     get() = when (this) {
         BlockchainType.Bitcoin,
         BlockchainType.BitcoinCash,
         BlockchainType.Dash,
         BlockchainType.ECash,
         BlockchainType.Litecoin,
-        BlockchainType.Zcash,
         BlockchainType.Dogecoin,
         BlockchainType.PirateCash,
         BlockchainType.Cosanta
@@ -297,10 +296,14 @@ val BlockchainType.isUtxoBased: Boolean
         BlockchainType.Ton,
         BlockchainType.Tron,
         is BlockchainType.Unsupported,
+        BlockchainType.Zcash,
         BlockchainType.Monero
             -> false
     }
 
+val BlockchainType.isUtxoBased: Boolean
+    get() = isBtcLike || this == BlockchainType.Zcash
+
 
 fun BlockchainType.supports(accountType: AccountType): Boolean {
     return when (accountType) {

app/src/main/java/cash/p/terminal/core/adapters/zcash/ZcashAdapter.kt

@@ -120,6 +120,8 @@ class ZcashAdapter(
     private val backgroundManager: BackgroundManager,
     private val singleUseAddressManager: ZcashSingleUseAddressManager,
     private val dispatcherProvider: DispatcherProvider,
+    private val restartBaseDelayMs: Long = 15_000,
+    private val restartMaxDelayMs: Long = 120_000,
 ) : IAdapter, IBalanceAdapter, IReceiveAdapter, ITransactionsAdapter, ISendZcashAdapter,
     OneTimeReceiveAdapter {
     private var accountBirthday = 0L
@@ -161,6 +163,8 @@ class ZcashAdapter(
 
     private var startJob: Job? = null
     private var statusJob: Job? = null
+    private var restartJob: Job? = null
+    private var restartAttempt = 0
     private var subscriberScope: CoroutineScope? = null
     override val isMainNet: Boolean = true
     private val scope = CoroutineScope(Dispatchers.IO)
@@ -309,9 +313,13 @@ class ZcashAdapter(
         scope.launch {
             backgroundManager.stateFlow.collect { state ->
                 when (state) {
-                    BackgroundManagerState.EnterForeground -> start()
+                    BackgroundManagerState.EnterForeground -> {
+                        // Cancel a pending self-heal restart so it doesn't race with this one.
+                        resetRestart()
+                        start()
+                    }
                     BackgroundManagerState.EnterBackground -> {
-                        if (pollingSessionCount.get() == 0 && !backgroundKeepAliveManager.isKeepAlive(BlockchainType.Zcash)) {
+                        if (!hasActiveBackgroundSession()) {
                             pauseSynchronizer()
                         } else {
                             Timber.tag("TxPoller").d("ZcashAdapter staying alive")
@@ -435,6 +443,10 @@ class ZcashAdapter(
     }
 
     override fun start() {
+        // Corruption recovery owns the whole lifecycle: it closes, erases, and recreates the
+        // synchronizer itself, so every other restart trigger (foreground, polling, self-heal)
+        // must stay out of the way while it is in flight.
+        if (recovering.get()) return
         importUfvkError?.let {
             syncState = AdapterState.NotSynced(it)
             return
@@ -878,6 +890,36 @@ class ZcashAdapter(
 
     private fun onChainError(errorHeight: BlockHeight, rewindHeight: BlockHeight) = Unit
 
+    // ZEC is intentionally kept running in the background during an active polling session or
+    // realtime keep-alive (see EnterBackground above), so self-heal must be allowed in those
+    // cases too, not just while the app is in the foreground.
+    private fun hasActiveBackgroundSession(): Boolean =
+        pollingSessionCount.get() > 0 || backgroundKeepAliveManager.isKeepAlive(BlockchainType.Zcash)
+
+    private fun scheduleRestart() {
+        if (recovering.get()) return
+        if (!backgroundManager.inForeground && !hasActiveBackgroundSession()) return
+        if (restartJob?.isActive == true) return
+        val delayMs = zcashRestartDelayFor(restartAttempt, restartBaseDelayMs, restartMaxDelayMs)
+        restartAttempt++
+        restartJob = scope.launch {
+            delay(delayMs)
+            // No syncState re-check here: resetRestart() already cancels this job the moment
+            // SYNCING/SYNCED is observed, so reaching this point means the restart is still due.
+            // (syncState itself is unreliable at this point - subscribe()'s eager resubscription
+            // to the progress/processorInfo flows can transiently flip it back to Syncing.)
+            if (backgroundManager.inForeground || hasActiveBackgroundSession()) {
+                start()
+            }
+        }
+    }
+
+    private fun resetRestart() {
+        restartAttempt = 0
+        restartJob?.cancel()
+        restartJob = null
+    }
+
     private fun onStatus(status: Synchronizer.Status) {
         syncState = when (status) {
             Synchronizer.Status.STOPPED -> AdapterState.NotSynced(Exception("stopped"))
@@ -886,6 +928,14 @@ class ZcashAdapter(
             Synchronizer.Status.SYNCED -> AdapterState.Synced
             else -> syncState
         }
+        // Self-heal on terminal STOPPED; reset backoff once syncing resumes. DISCONNECTED and
+        // PREPARING are left to the SDK's own reconnect loop.
+        when (status) {
+            Synchronizer.Status.STOPPED -> scheduleRestart()
+            Synchronizer.Status.SYNCING,
+            Synchronizer.Status.SYNCED -> resetRestart()
+            else -> {}
+        }
     }
 
     private fun startOneTimeAddressBalanceCheck() {
@@ -1056,6 +1106,9 @@ internal fun WalletBalance.toBalanceData(decimalCount: Int) = BalanceData(
     pending = pending.convertZatoshiToZec(decimalCount)
 )
 
+internal fun zcashRestartDelayFor(attempt: Int, baseMs: Long, maxMs: Long): Long =
+    (baseMs shl attempt.coerceAtMost(3)).coerceAtMost(maxMs)
+
 object ZcashAddressValidator {
     fun validate(address: String): Boolean {
         return isValidZcashAddress(address)

app/src/main/java/cash/p/terminal/core/managers/AdapterManager.kt

@@ -13,12 +13,12 @@ import cash.p.terminal.wallet.Wallet
 import cash.p.terminal.wallet.entities.BalanceData
 import cash.p.terminal.wallet.entities.TokenType
 import cash.p.terminal.wallet.litecoinMwebAccountIds
+import io.horizontalsystems.core.DispatcherProvider
 import io.horizontalsystems.core.entities.BlockchainType
 import io.reactivex.BackpressureStrategy
 import io.reactivex.Flowable
 import io.reactivex.subjects.PublishSubject
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.channels.BufferOverflow
@@ -57,11 +57,12 @@ class AdapterManager(
     private val moneroKitManager: MoneroKitManager,
     private val stellarKitManager: StellarKitManager,
     private val pendingBalanceCalculator: PendingBalanceCalculator,
-    private val fallbackAddressProvider: FallbackAddressProvider
+    private val fallbackAddressProvider: FallbackAddressProvider,
+    dispatcherProvider: DispatcherProvider
 ) : IAdapterManager, HandlerThread("A") {
 
     private val mutex = Mutex()
-    private val coroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private val coroutineScope = CoroutineScope(dispatcherProvider.io + SupervisorJob())
 
     private val adaptersReadySubject = PublishSubject.create<Map<Wallet, IAdapter>>()
     private val adaptersMap = ConcurrentHashMap<Wallet, IAdapter>()

app/src/main/java/cash/p/terminal/core/managers/EvmKitManager.kt

@@ -7,23 +7,15 @@ import cash.p.terminal.core.onPollingStarted
 import cash.p.terminal.core.onPollingStopped
 import cash.p.terminal.core.UnsupportedAccountException
 import cash.p.terminal.core.providers.AppConfigProvider
-import cash.p.terminal.tangem.common.CustomXPubKeyAddressParser
-import cash.p.terminal.tangem.domain.model.AddressBytesWithPublicKey
-import cash.p.terminal.tangem.signer.HardwareWalletEvmSigner
-import cash.p.terminal.trezorkit.client.ITrezorClient
 import cash.p.terminal.trezor.signer.TrezorEvmSigner
 import cash.p.terminal.wallet.Account
 import cash.p.terminal.wallet.AccountOrigin
-import cash.p.terminal.wallet.AccountType
-import cash.p.terminal.wallet.IHardwarePublicKeyStorage
-import cash.p.terminal.wallet.entities.HardwarePublicKey
 import io.horizontalsystems.core.BackgroundManager
 import io.horizontalsystems.core.BackgroundManagerState
 import io.horizontalsystems.core.entities.BlockchainType
 import io.horizontalsystems.erc20kit.core.Erc20Kit
 import io.horizontalsystems.ethereumkit.core.EthereumKit
 import io.horizontalsystems.ethereumkit.core.signer.Signer
-import io.horizontalsystems.ethereumkit.models.Address
 import io.horizontalsystems.ethereumkit.models.Chain
 import io.horizontalsystems.ethereumkit.models.FullTransaction
 import io.horizontalsystems.ethereumkit.models.GasPrice
@@ -62,10 +54,8 @@ class EvmKitManager(
     private val syncSourceManager: EvmSyncSourceManager,
     private val backgroundKeepAliveManager: BackgroundKeepAliveManager
 ) {
-    private val hardwarePublicKeyStorage: IHardwarePublicKeyStorage
-            by inject(IHardwarePublicKeyStorage::class.java)
-    private val trezorClient: ITrezorClient
-            by inject(ITrezorClient::class.java)
+    private val evmSignerFactory: EvmSignerFactory
+            by inject(EvmSignerFactory::class.java)
 
     private val lifecycleMutex = Mutex()
     private val pollingSessionCount = AtomicInteger(0)
@@ -118,9 +108,7 @@ class EvmKitManager(
         }
 
         if (this.evmKitWrapper == null) {
-            val accountType = account.type
             evmKitWrapper = createKitInstance(
-                accountType = accountType,
                 account = account,
                 blockchainType = blockchainType
             )
@@ -133,55 +121,14 @@ class EvmKitManager(
     }
 
     private fun createKitInstance(
-        accountType: AccountType,
         account: Account,
         blockchainType: BlockchainType
     ): EvmKitWrapper {
         val syncSource = syncSourceManager.getSyncSource(blockchainType)
 
-        val address: Address
-        var signer: Signer? = null
-
-        when (accountType) {
-            is AccountType.Mnemonic -> {
-                val seed: ByteArray = accountType.seed
-                address = Signer.address(seed, chain)
-                signer = Signer.getInstance(seed, chain)
-            }
-
-            is AccountType.EvmPrivateKey -> {
-                address = Signer.address(accountType.key)
-                signer = Signer.getInstance(accountType.key, chain)
-            }
-
-            is AccountType.HardwareCard -> {
-                val (publicKey, addressWithPublicKey) = resolveHardwareAddress(account.id, blockchainType)
-                address = Address(addressWithPublicKey.addressBytes)
-                signer = HardwareWalletEvmSigner(
-                    address = address,
-                    publicKey = publicKey,
-                    chain = chain,
-                    expectedPublicKeyBytes = addressWithPublicKey.publicKey
-                )
-            }
-
-            is AccountType.TrezorDevice -> {
-                val (publicKey, addressWithPublicKey) = resolveHardwareAddress(account.id, blockchainType)
-                address = Address(addressWithPublicKey.addressBytes)
-                signer = TrezorEvmSigner(
-                    address = address,
-                    chain = chain,
-                    derivationPath = publicKey.derivationPath,
-                    trezorClient = trezorClient
-                )
-            }
-
-            is AccountType.EvmAddress -> {
-                address = Address(accountType.address)
-            }
-
-            else -> throw UnsupportedAccountException()
-        }
+        val address = runBlocking { evmSignerFactory.resolveAddress(account, blockchainType, chain) }
+            ?: throw UnsupportedAccountException()
+        val signer = runBlocking { evmSignerFactory.createSigner(account, blockchainType, chain) }
 
         val evmKit = EthereumKit.getInstance(
             application = App.instance,
@@ -247,19 +194,6 @@ class EvmKitManager(
         )
     }
 
-    private fun resolveHardwareAddress(
-        accountId: String,
-        blockchainType: BlockchainType
-    ): Pair<HardwarePublicKey, AddressBytesWithPublicKey> {
-        val publicKey = runBlocking {
-            requireNotNull(
-                hardwarePublicKeyStorage.getKeyByBlockchain(accountId, blockchainType)
-            )
-        }
-        val addressWithPublicKey = CustomXPubKeyAddressParser.parse(publicKey.key.value)
-        return Pair(publicKey, addressWithPublicKey)
-    }
-
     suspend fun unlink(account: Account) = lifecycleMutex.withLock {
         if (account == currentAccount) {
             useCount.decrementAndGet()

app/src/main/java/cash/p/terminal/core/managers/EvmMessageSigning.kt

@@ -0,0 +1,32 @@
+package cash.p.terminal.core.managers
+
+import cash.p.terminal.tangem.signer.HardwareWalletEvmSigner
+import cash.p.terminal.trezor.signer.TrezorEvmSigner
+import io.horizontalsystems.ethereumkit.core.signer.Signer
+
+/**
+ * Single dispatch point for EVM message signing. The base [Signer] exposes only non-suspend,
+ * final `signByteArray*`/`signTypedData` methods signed with a mock key for hardware wallets
+ * (see [HardwareWalletEvmSigner]/[TrezorEvmSigner]), so hardware signers expose their own
+ * suspend counterparts that must be routed here instead of calling the base methods directly.
+ */
+object EvmMessageSigning {
+
+    suspend fun signPersonalMessage(signer: Signer, message: ByteArray): ByteArray = when (signer) {
+        is HardwareWalletEvmSigner -> signer.signPersonalMessage(message)
+        is TrezorEvmSigner -> signer.signPersonalMessage(message)
+        else -> signer.signByteArray(message)
+    }
+
+    suspend fun signLegacyHash(signer: Signer, hash: ByteArray): ByteArray = when (signer) {
+        is HardwareWalletEvmSigner -> signer.signLegacyHash(hash)
+        is TrezorEvmSigner -> signer.signLegacyHash(hash)
+        else -> signer.signByteArrayLegacy(hash)
+    }
+
+    suspend fun signTypedData(signer: Signer, rawJson: String): ByteArray = when (signer) {
+        is HardwareWalletEvmSigner -> signer.signTypedDataMessage(rawJson)
+        is TrezorEvmSigner -> signer.signTypedDataMessage(rawJson)
+        else -> signer.signTypedData(rawJson)
+    }
+}