Updated on 2026-08-14

app/src/main/assets/tangem-app-config

@@ -1 +1 @@
-Subproject commit cf6ea50867477f97655da9da47ff94987e8f3354
+Subproject commit c8f577f2ab48e0d6c49f79b6cff21eabe67cd63e

app/src/main/java/com/tangem/tap/domain/tasks/product/ScanProductTask.kt

@@ -36,6 +36,8 @@ import com.tangem.tap.domain.extensions.isMultiwalletAllowed
 import com.tangem.tap.domain.tokens.UserTokensRepository
 import com.tangem.tap.domain.tokens.models.BlockchainNetwork
 import com.tangem.tap.preferencesStorage
+import com.tangem.tap.scope
+import kotlinx.coroutines.launch
 
 class ScanProductTask(
     val card: Card? = null,
@@ -183,43 +185,45 @@ private class ScanWalletProcessor(
         session: CardSession,
         callback: (result: CompletionResult<ScanResponse>) -> Unit,
     ) {
-        val productType = when(card.isSaltPay){
+        val productType = when (card.isSaltPay) {
             true -> ProductType.SaltPay
             else -> ProductType.Wallet
         }
-        val derivations = collectDerivations(card)
-        if (derivations.isEmpty() || !card.settings.isHDWalletAllowed) {
-            callback(
-                CompletionResult.Success(
-                    ScanResponse(
-                        card = card,
-                        productType = productType,
-                        walletData = session.environment.walletData,
-                        primaryCard = primaryCard,
+        scope.launch {
+            val derivations = collectDerivations(card)
+            if (derivations.isEmpty() || !card.settings.isHDWalletAllowed) {
+                callback(
+                    CompletionResult.Success(
+                        ScanResponse(
+                            card = card,
+                            productType = productType,
+                            walletData = session.environment.walletData,
+                            primaryCard = primaryCard,
+                        ),
                     ),
-                ),
-            )
-            return
-        }
+                )
+                return@launch
+            }
 
-        DeriveMultipleWalletPublicKeysTask(derivations).run(session) { result ->
-            when (result) {
-                is CompletionResult.Success -> {
-                    val response = ScanResponse(
-                        card = card,
-                        productType = productType,
-                        walletData = session.environment.walletData,
-                        derivedKeys = result.data.entries,
-                        primaryCard = primaryCard,
-                    )
-                    callback(CompletionResult.Success(response))
+            DeriveMultipleWalletPublicKeysTask(derivations).run(session) { result ->
+                when (result) {
+                    is CompletionResult.Success -> {
+                        val response = ScanResponse(
+                            card = card,
+                            productType = productType,
+                            walletData = session.environment.walletData,
+                            derivedKeys = result.data.entries,
+                            primaryCard = primaryCard,
+                        )
+                        callback(CompletionResult.Success(response))
+                    }
+                    is CompletionResult.Failure -> callback(CompletionResult.Failure(result.error))
                 }
-                is CompletionResult.Failure -> callback(CompletionResult.Failure(result.error))
             }
         }
     }
 
-    private fun getBlockchainsToDerive(card: Card): List<BlockchainNetwork> {
+    private suspend fun getBlockchainsToDerive(card: Card): List<BlockchainNetwork> {
         val userTokensRepository = userTokensRepository ?: return emptyList()
         val blockchainsToDerive = userTokensRepository.loadBlockchainsToDerive(card).toMutableList().ifEmpty {
             mutableListOf(
@@ -253,7 +257,7 @@ private class ScanWalletProcessor(
         return blockchainsToDerive.distinct()
     }
 
-    private fun collectDerivations(card: Card): Map<ByteArrayKey, List<DerivationPath>> {
+    private suspend fun collectDerivations(card: Card): Map<ByteArrayKey, List<DerivationPath>> {
         val blockchains = getBlockchainsToDerive(card)
         val derivations = mutableMapOf<ByteArrayKey, List<DerivationPath>>()
 

app/src/main/java/com/tangem/tap/domain/tokens/UserTokensRepository.kt

@@ -36,9 +36,9 @@ class UserTokensRepository(
 
         return when (val networkResult = networkService.getUserTokens(userId)) {
             is Result.Success -> {
-                val tokens = networkResult.data.tokens.map { Currency.fromTokenResponse(it) }
+                val tokens = networkResult.data.tokens.mapNotNull { Currency.fromTokenResponse(it) }
                 storageService.saveUserTokens(card.getUserId(), tokens.toUserTokensResponse())
-                tokens
+                tokens.distinct()
             }
             is Result.Failure -> {
                 handleGetUserTokensFailure(card = card, userId = userId, error = networkResult.error)
@@ -67,8 +67,10 @@ class UserTokensRepository(
         )
     }
 
-    fun loadBlockchainsToDerive(card: Card): List<BlockchainNetwork> {
-        return storageService.getUserTokens(card.getUserId())?.toBlockchainNetworks() ?: emptyList()
+    suspend fun loadBlockchainsToDerive(card: Card): List<BlockchainNetwork> {
+        return storageService.getUserTokens(card.getUserId())?.toBlockchainNetworks() ?: storageService.getUserTokens(
+            card,
+        ).toBlockchainNetworks()
     }
 
     private fun loadDemoCurrencies(): List<Currency> {
@@ -95,7 +97,7 @@ class UserTokensRepository(
             }
             else -> {
                 val tokens = storageService.getUserTokens(userId) ?: storageService.getUserTokens(card)
-                tokens
+                tokens.distinct()
             }
         }
     }

app/src/main/java/com/tangem/tap/domain/tokens/UserTokensStorageService.kt

@@ -20,7 +20,7 @@ class UserTokensStorageService(
     fun getUserTokens(userId: String): List<Currency>? {
         return try {
             val json = fileReader.readFile(getFileNameForUserTokens(userId))
-            userTokensAdapter.fromJson(json)?.tokens?.map { Currency.fromTokenResponse(it) }
+            userTokensAdapter.fromJson(json)?.tokens?.mapNotNull { Currency.fromTokenResponse(it) }
         } catch (exception: Exception) {
             Log.error { exception.stackTraceToString() }
             null

app/src/main/java/com/tangem/tap/features/wallet/models/Currency.kt

@@ -110,7 +110,9 @@ sealed interface Currency {
             )
         }
 
-        fun fromTokenResponse(tokenResponse: TokenResponse): Currency {
+        fun fromTokenResponse(tokenResponse: TokenResponse): Currency? {
+            val blockchain = com.tangem.blockchain.common.Blockchain.fromNetworkId(tokenResponse.networkId)
+                ?: return null
             return when {
                 tokenResponse.contractAddress != null -> Token(
                     com.tangem.blockchain.common.Token(
@@ -120,11 +122,11 @@ sealed interface Currency {
                         decimals = tokenResponse.decimals,
                         id = tokenResponse.id,
                     ),
-                    blockchain = com.tangem.blockchain.common.Blockchain.fromNetworkId(tokenResponse.networkId)!!,
+                    blockchain = blockchain,
                     derivationPath = tokenResponse.derivationPath,
                 )
                 else -> Blockchain(
-                    blockchain = com.tangem.blockchain.common.Blockchain.fromNetworkId(tokenResponse.networkId)!!,
+                    blockchain = blockchain,
                     derivationPath = tokenResponse.derivationPath,
                 )
             }