Updated on 2026-08-14

app/src/main/java/com/tangem/tap/domain/sdk/impl/DefaultTangemSdkManager.kt

@@ -53,11 +53,7 @@ import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.sdk.api.visa.VisaCardActivationResponse
 import com.tangem.sdk.api.visa.VisaCardActivationTaskMode
 import com.tangem.tap.common.analytics.events.TangemSdkErrorEvent
-import com.tangem.tap.derivationsFinder
-import com.tangem.tap.domain.tasks.product.CreateProductWalletTask
-import com.tangem.tap.domain.tasks.product.ResetBackupCardTask
-import com.tangem.tap.domain.tasks.product.ResetToFactorySettingsTask
-import com.tangem.tap.domain.tasks.product.ScanProductTask
+import com.tangem.tap.domain.tasks.product.*
 import com.tangem.tap.domain.tasks.visa.TangemPayGenerateAddressAndSignChallengeTask
 import com.tangem.tap.domain.tasks.visa.TangemPaySignWithdrawalHashTask
 import com.tangem.tap.domain.tasks.visa.VisaCardActivationTask
@@ -85,6 +81,7 @@ internal class DefaultTangemSdkManager(
     private val appFinisher: AppFinisher,
     private val sendFeedbackEmailUseCase: SendFeedbackEmailUseCase,
     private val analyticsExceptionHandler: AnalyticsExceptionHandler,
+    private val blockchainToDeriveFinder: BlockchainToDeriveFinder,
     dispatchers: CoroutineDispatcherProvider,
 ) : TangemSdkManager {
 
@@ -172,7 +169,7 @@ internal class DefaultTangemSdkManager(
             runTaskAsyncReturnOnMain(
                 runnable = ScanProductTask(
                     card = null,
-                    derivationsFinder = derivationsFinder,
+                    blockchainToDeriveFinder = blockchainToDeriveFinder,
                     allowsRequestAccessCodeFromRepository = allowsRequestAccessCodeFromRepository,
                     visaCardScanHandler = visaCardScanHandler,
                     visaCoroutineScope = this,

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

@@ -0,0 +1,74 @@
+package com.tangem.tap.domain.tasks.product
+
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.derivation.DerivationStyle
+import com.tangem.blockchainsdk.utils.fromNetworkId
+import com.tangem.crypto.hdWallet.DerivationPath
+import com.tangem.data.common.account.WalletAccountsFetcher
+import com.tangem.data.wallets.derivations.BlockchainToDerive
+import com.tangem.domain.models.scan.CardDTO
+import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.wallets.builder.UserWalletIdBuilder
+import com.tangem.domain.wallets.derivations.derivationStyleProvider
+import com.tangem.tap.features.demo.DemoHelper
+import javax.inject.Inject
+
+/**
+ * Finder of blockchains to derive.
+ * Returns only saved, default or demo blockchains without any additional logic
+ * (no cardano/ethereum additions or unnecessary blockchain removals).
+ */
+class BlockchainToDeriveFinder @Inject constructor(
+    private val walletAccountsFetcher: WalletAccountsFetcher,
+) {
+
+    suspend fun find(card: CardDTO): Set<BlockchainToDerive> {
+        if (!card.settings.isHDWalletAllowed || card.wallets.isEmpty()) return emptySet()
+        val userWalletId = UserWalletIdBuilder.card(card).build() ?: return emptySet()
+
+        val derivationStyle = card.derivationStyleProvider.getDerivationStyle()
+
+        val blockchains = getBlockchains(userWalletId).ifEmpty {
+            if (DemoHelper.isDemoCardId(card.cardId)) {
+                getDemoBlockchains(derivationStyle, card.cardId)
+            } else {
+                getDefaultBlockchains(derivationStyle)
+            }
+        }
+
+        return blockchains
+    }
+
+    private suspend fun getBlockchains(userWalletId: UserWalletId): Set<BlockchainToDerive> {
+        return walletAccountsFetcher.getSaved(userWalletId)?.accounts.orEmpty()
+            .flatMap { accountDTO ->
+                accountDTO.tokens.orEmpty()
+                    .filter { it.contractAddress == null }
+            }
+            .mapNotNull { coin ->
+                val blockchain = Blockchain.fromNetworkId(coin.networkId) ?: return@mapNotNull null
+                val derivationPath = coin.derivationPath?.let(::DerivationPath) ?: return@mapNotNull null
+
+                BlockchainToDerive(blockchain, derivationPath)
+            }
+            .toSet()
+    }
+
+    private fun getDemoBlockchains(derivationStyle: DerivationStyle?, cardId: String): Set<BlockchainToDerive> {
+        return DemoHelper.config.getDemoBlockchains(cardId).mapToBlockchainsWithDerivations(derivationStyle)
+    }
+
+    private fun getDefaultBlockchains(derivationStyle: DerivationStyle?): Set<BlockchainToDerive> {
+        val defaultBlockchains = setOf(Blockchain.Bitcoin, Blockchain.Ethereum)
+        return defaultBlockchains.mapToBlockchainsWithDerivations(derivationStyle)
+    }
+
+    private fun Set<Blockchain>.mapToBlockchainsWithDerivations(
+        derivationStyle: DerivationStyle?,
+    ): Set<BlockchainToDerive> {
+        return mapNotNullTo(hashSetOf()) { blockchain ->
+            val derivationPath = blockchain.derivationPath(derivationStyle) ?: return@mapNotNullTo null
+            BlockchainToDerive(blockchain, derivationPath)
+        }
+    }
+}

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

@@ -1,131 +0,0 @@
-package com.tangem.tap.domain.tasks.product
-
-import com.tangem.blockchain.blockchains.cardano.CardanoUtils
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.blockchain.common.derivation.DerivationStyle
-import com.tangem.blockchainsdk.utils.fromNetworkId
-import com.tangem.crypto.hdWallet.DerivationPath
-import com.tangem.datasource.local.token.UserTokensResponseStore
-import com.tangem.domain.wallets.derivations.DerivationStyleProvider
-import com.tangem.domain.card.common.TapWorkarounds.hasOldStyleDerivation
-import com.tangem.domain.models.scan.CardDTO
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.wallets.builder.UserWalletIdBuilder
-import com.tangem.tap.features.demo.DemoHelper
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.coroutines.withContext
-
-internal data class BlockchainToDerive(
-    val blockchain: Blockchain,
-    val derivationPath: DerivationPath?,
-)
-
-// FIXME: May be move to DI, currently unnecessary
-internal class DerivationsFinder(
-    private val userTokensResponseStore: UserTokensResponseStore,
-    private val dispatchers: CoroutineDispatcherProvider,
-) {
-
-    suspend fun findBlockchainsToDerive(
-        card: CardDTO,
-        derivationStyleProvider: DerivationStyleProvider,
-    ): Set<BlockchainToDerive> {
-        if (!card.settings.isHDWalletAllowed || card.wallets.isEmpty()) return emptySet()
-        val userWalletId = UserWalletIdBuilder.card(card).build() ?: return emptySet()
-        val derivationStyle = derivationStyleProvider.getDerivationStyle()
-
-        val blockchains = withContext(dispatchers.io) {
-            getBlockchains(userWalletId)
-        }.ifEmpty {
-            if (DemoHelper.isDemoCardId(card.cardId)) {
-                getDemoBlockchains(derivationStyle, card.cardId)
-            } else {
-                getDefaultBlockchains(derivationStyle)
-            }
-        }
-
-        // we should generate second key for cardano
-        // because cardano address generation for wallet2 requires keys from 2 derivations
-        // https://developers.cardano.org/docs/get-started/cardano-serialization-lib/generating-keys/
-        blockchains.addSecondCardanoDerivationIfPresent()
-
-        if (card.settings.isHDWalletAllowed) {
-            blockchains.addEthereumBlockchains(derivationStyle)
-        }
-
-        // pay attention to this
-        if (!card.hasOldStyleDerivation) {
-            blockchains.removeUnnecessaryBlockchains()
-        }
-
-        return blockchains
-    }
-
-    private suspend fun getBlockchains(userWalletId: UserWalletId): MutableSet<BlockchainToDerive> {
-        val responseTokens = userTokensResponseStore.getSyncOrNull(userWalletId = userWalletId)?.tokens
-            ?: return hashSetOf()
-
-        return responseTokens.asSequence()
-            .filter { it.contractAddress == null }
-            .mapNotNull { coin ->
-                val blockchain = Blockchain.fromNetworkId(coin.networkId) ?: return@mapNotNull null
-                val derivationPath = coin.derivationPath?.let(::DerivationPath)
-
-                BlockchainToDerive(blockchain, derivationPath)
-            }
-            .toMutableSet()
-    }
-
-    // TODO: Move to user wallet config
-    private fun getDemoBlockchains(derivationStyle: DerivationStyle?, cardId: String): MutableSet<BlockchainToDerive> {
-        return DemoHelper.config.getDemoBlockchains(cardId).mapToBlockchainsWithDerivations(derivationStyle)
-    }
-
-    // TODO: Move to user wallet config
-    private fun getDefaultBlockchains(derivationStyle: DerivationStyle?): MutableSet<BlockchainToDerive> {
-        val defaultBlockchains = setOf(Blockchain.Bitcoin, Blockchain.Ethereum)
-
-        return defaultBlockchains.mapToBlockchainsWithDerivations(derivationStyle)
-    }
-}
-
-private fun MutableSet<BlockchainToDerive>.addEthereumBlockchains(derivationStyle: DerivationStyle?) {
-    val ethereumBlockchains = setOf(Blockchain.Ethereum, Blockchain.EthereumTestnet)
-        .mapToBlockchainsWithDerivations(derivationStyle)
-
-    addAll(ethereumBlockchains)
-}
-
-private fun MutableSet<BlockchainToDerive>.removeUnnecessaryBlockchains() {
-    val unnecessaryBlockchains = listOf(
-        Blockchain.BSC, Blockchain.BSCTestnet,
-        Blockchain.Polygon, Blockchain.PolygonTestnet,
-        Blockchain.RSK,
-        Blockchain.Fantom, Blockchain.FantomTestnet,
-        Blockchain.Avalanche, Blockchain.AvalancheTestnet,
-    )
-
-    removeAll { it.blockchain in unnecessaryBlockchains }
-}
-
-private fun MutableSet<BlockchainToDerive>.addSecondCardanoDerivationIfPresent() {
-    val cardanoDerivation = this
-        .firstOrNull { it.blockchain == Blockchain.Cardano }
-        ?.derivationPath
-        ?: return
-
-    val secondCardanoBlockchain = BlockchainToDerive(
-        blockchain = Blockchain.Cardano,
-        derivationPath = CardanoUtils.extendedDerivationPath(cardanoDerivation),
-    )
-
-    add(secondCardanoBlockchain)
-}
-
-private fun Set<Blockchain>.mapToBlockchainsWithDerivations(
-    derivationStyle: DerivationStyle?,
-): MutableSet<BlockchainToDerive> {
-    return mapTo(hashSetOf()) { blockchain ->
-        BlockchainToDerive(blockchain, blockchain.derivationPath(derivationStyle))
-    }
-}

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

@@ -13,16 +13,14 @@ import com.tangem.common.tlv.Tlv
 import com.tangem.common.tlv.TlvDecoder
 import com.tangem.crypto.CryptoUtils
 import com.tangem.crypto.hdWallet.DerivationPath
-import com.tangem.domain.wallets.derivations.DerivationStyleProvider
+import com.tangem.data.wallets.derivations.MissedDerivationsFinder
 import com.tangem.domain.card.common.TapWorkarounds.isExcluded
 import com.tangem.domain.card.common.TapWorkarounds.isNotSupportedInThatRelease
 import com.tangem.domain.card.common.TapWorkarounds.isStart2Coin
 import com.tangem.domain.card.common.TapWorkarounds.isTangemTwins
 import com.tangem.domain.card.common.TapWorkarounds.isVisa
 import com.tangem.domain.card.common.TwinsHelper
-import com.tangem.domain.wallets.derivations.derivationStyleProvider
 import com.tangem.domain.card.common.visa.VisaUtilities
-import com.tangem.domain.card.configs.CardConfig
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.CardDTO.Companion.RING_BATCH_IDS
 import com.tangem.domain.models.scan.CardDTO.Companion.RING_BATCH_PREFIX
@@ -45,11 +43,10 @@ import com.tangem.tap.scope
 import com.tangem.tap.store
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
-import kotlin.collections.set
 
 internal class ScanProductTask(
     private val card: Card?,
-    private val derivationsFinder: DerivationsFinder?,
+    private val blockchainToDeriveFinder: BlockchainToDeriveFinder?,
     private val visaCardScanHandler: VisaCardScanHandler?,
     private val visaCoroutineScope: CoroutineScope?,
     private val onboardingV2FeatureToggles: OnboardingV2FeatureToggles?,
@@ -81,7 +78,7 @@ internal class ScanProductTask(
             readVisaCard(
                 session = session,
                 cardDto = cardDto,
-                scanWalletProcessor = ScanWalletProcessor(derivationsFinder),
+                scanWalletProcessor = ScanWalletProcessor(blockchainToDeriveFinder),
                 callback = callback,
             )
             return
@@ -89,7 +86,7 @@ internal class ScanProductTask(
 
         val commandProcessor = when {
             cardDto.isTangemTwins -> ScanTwinProcessor()
-            else -> ScanWalletProcessor(derivationsFinder)
+            else -> ScanWalletProcessor(blockchainToDeriveFinder)
         }
         commandProcessor.proceed(cardDto, session) { processorResult ->
             when (processorResult) {
@@ -170,7 +167,7 @@ internal class ScanProductTask(
 }
 
 private class ScanWalletProcessor(
-    private val derivationsFinder: DerivationsFinder?,
+    private val blockchainToDeriveFinder: BlockchainToDeriveFinder?,
 ) : ProductCommandProcessor<ScanResponse> {
 
     var primaryCard: PrimaryCard? = null
@@ -293,7 +290,6 @@ private class ScanWalletProcessor(
         callback: (result: CompletionResult<ScanResponse>) -> Unit,
     ) {
         val productType = getWalletProductType(card)
-        val config = CardConfig.createConfig(card)
         scope.launch {
             val scanResponse = ScanResponse(
                 card = card,
@@ -301,8 +297,7 @@ private class ScanWalletProcessor(
                 walletData = session.environment.walletData,
                 primaryCard = primaryCard,
             )
-            val derivations =
-                collectDerivations(card, config, scanResponse.derivationStyleProvider)
+            val derivations = collectDerivations(card, scanResponse)
             if (derivations.isEmpty() || !card.settings.isHDWalletAllowed) {
                 callback(CompletionResult.Success(scanResponse))
                 return@launch
@@ -332,32 +327,13 @@ private class ScanWalletProcessor(
 
     private suspend fun collectDerivations(
         card: CardDTO,
-        config: CardConfig,
-        derivationStyleProvider: DerivationStyleProvider,
+        scanResponse: ScanResponse,
     ): Map<ByteArrayKey, List<DerivationPath>> {
-        val derivations = mutableMapOf<ByteArrayKey, List<DerivationPath>>()
-        val blockchains = derivationsFinder
-            ?.findBlockchainsToDerive(card, derivationStyleProvider)
-            ?: return derivations
+        val blockchains = blockchainToDeriveFinder
+            ?.find(card)
+            ?: return emptyMap()
 
-        blockchains.forEach { blockchain ->
-            val curve = config.primaryCurve(blockchain.blockchain)
-            val wallet = card.wallets.firstOrNull { it.curve == curve } ?: return@forEach
-            if (wallet.chainCode == null) return@forEach
-
-            val key = wallet.publicKey.toMapKey()
-            val path = blockchain.derivationPath
-            if (path != null) {
-                val addedDerivations = derivations[key]
-                if (addedDerivations != null) {
-                    derivations[key] = addedDerivations + path
-                } else {
-                    derivations[key] = listOf(path)
-                }
-            }
-        }
-
-        return derivations
+        return MissedDerivationsFinder(scanResponse).findByBlockchainsToDerive(blockchains)
     }
 }
 

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

@@ -4,5 +4,9 @@ import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 import com.tangem.domain.tokens.TokensFeatureToggles
 
 internal class DefaultTokensFeatureToggles(
-    @Suppress("UnusedPrivateMember") private val featureTogglesManager: FeatureTogglesManager,
-) : TokensFeatureToggles
+    private val featureTogglesManager: FeatureTogglesManager,
+) : TokensFeatureToggles {
+
+    override val isMultiAddressUtxoEnabled: Boolean
+        get() = featureTogglesManager.isFeatureEnabled("MULTI_ADDRESS_UTXO_ENABLED")
+}

app/src/main/java/com/tangem/tap/domain/twins/FinalizeTwinTask.kt

@@ -28,7 +28,7 @@ class FinalizeTwinTask(
                             is CompletionResult.Success ->
                                 ScanProductTask(
                                     card = readResult.data,
-                                    derivationsFinder = null,
+                                    blockchainToDeriveFinder = null,
                                     visaCardScanHandler = null,
                                     visaCoroutineScope = null,
                                     shouldCheckIsAlreadyActivated = false,

app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt

@@ -88,7 +88,7 @@ internal class DefaultUserWalletsListRepository(
                         .map { wallets.updateWith(it) }
                 }
                 .doOnSuccess { loadedWallets ->
-                    userWallets.update { toUpdate ->
+                    userWallets.update { _ ->
                         val selectedUserWalletId = selectedUserWalletRepository.get()
                         selectedUserWallet.value = loadedWallets.firstOrNull { it.walletId == selectedUserWalletId }
                             ?: loadedWallets.firstOrNull()?.also {
@@ -240,7 +240,7 @@ internal class DefaultUserWalletsListRepository(
         }
     }
 
-    @Suppress("CyclomaticComplexMethod")
+    @Suppress("CyclomaticComplexMethod", "LongMethod")
     override suspend fun unlock(
         userWalletId: UserWalletId,
         unlockMethod: UserWalletsListRepository.UnlockMethod,
@@ -315,7 +315,13 @@ internal class DefaultUserWalletsListRepository(
 
                 sensitiveInformationRepository.getAll(listOf(encryptionKey))
                     .doOnSuccess { sensitiveInfo ->
-                        updateWallets { it?.updateWith(sensitiveInfo) }
+                        updateWallets { wallets ->
+                            // It is necessary to update derivations because when scanning we obtain the missing keys
+                            wallets?.updateWith(
+                                walletIdToSensitiveInformation = sensitiveInfo,
+                                walletIdToDerivedKeys = mapOf(userWallet.walletId to scanResponse.derivedKeys),
+                            )
+                        }
                         trackSignInEvent(userWallet, Basic.SignedIn.SignInType.Card)
                     }
                     .doOnFailure { error -> raise(UnlockWalletError.UnableToUnlock.RawException(error)) }

app/src/main/java/com/tangem/tap/domain/userWalletList/utils/Mapper.kt

@@ -1,8 +1,10 @@
 package com.tangem.tap.domain.userWalletList.utils
 
+import com.tangem.domain.models.scan.KeyWalletPublicKey
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.domain.models.wallet.isMultiCurrency
+import com.tangem.operations.derivation.ExtendedPublicKeysMap
 import com.tangem.tap.domain.userWalletList.model.UserWalletPublicInformation
 import com.tangem.tap.domain.userWalletList.model.UserWalletSensitiveInformation
 
@@ -72,7 +74,10 @@ internal fun List<UserWalletPublicInformation>.toUserWallets(): List<UserWallet>
     return this.map { it.toUserWallet() }
 }
 
-internal fun UserWallet.updateWith(sensitiveInformation: UserWalletSensitiveInformation): UserWallet {
+internal fun UserWallet.updateWith(
+    sensitiveInformation: UserWalletSensitiveInformation,
+    derivedKeys: Map<KeyWalletPublicKey, ExtendedPublicKeysMap>?,
+): UserWallet {
     return when (this) {
         is UserWallet.Cold -> {
             copy(
@@ -80,6 +85,7 @@ internal fun UserWallet.updateWith(sensitiveInformation: UserWalletSensitiveInfo
                     card = scanResponse.card.copy(
                         wallets = requireNotNull(sensitiveInformation.wallets),
                     ),
+                    derivedKeys = derivedKeys ?: scanResponse.derivedKeys,
                     // visaCardActivationStatus = sensitiveInformation.visaCardActivationStatus,
                 ),
             )
@@ -92,14 +98,20 @@ internal fun UserWallet.updateWith(sensitiveInformation: UserWalletSensitiveInfo
 
 internal fun List<UserWallet>.updateWith(
     walletIdToSensitiveInformation: Map<UserWalletId, UserWalletSensitiveInformation>,
+    walletIdToDerivedKeys: Map<UserWalletId, Map<KeyWalletPublicKey, ExtendedPublicKeysMap>>? = null,
 ): List<UserWallet> {
     return if (walletIdToSensitiveInformation.isEmpty()) {
         this
     } else {
         this.map { wallet ->
-            walletIdToSensitiveInformation[wallet.walletId]
-                ?.let(wallet::updateWith)
-                ?: wallet
+            val sensitiveInformation = walletIdToSensitiveInformation[wallet.walletId]
+            val derivedKeys = walletIdToDerivedKeys?.get(wallet.walletId)
+
+            if (sensitiveInformation != null) {
+                wallet.updateWith(sensitiveInformation, derivedKeys)
+            } else {
+                wallet
+            }
         }
     }
 }