Updated on 2026-08-14

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

@@ -13,8 +13,9 @@ import com.tangem.common.extensions.toMapKey
 import com.tangem.common.map
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.domain.common.CardTypesResolver
-import com.tangem.domain.common.TapWorkarounds.derivationStyle
+import com.tangem.domain.common.DerivationStyleProvider
 import com.tangem.domain.common.TapWorkarounds.isTestCard
+import com.tangem.domain.common.extensions.derivationPath
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.KeyWalletPublicKey
 import com.tangem.operations.CommandResponse
@@ -56,6 +57,7 @@ private data class CreateWalletResponse(
 
 class CreateProductWalletTask(
     private val cardTypesResolver: CardTypesResolver,
+    private val derivationStyleProvider: DerivationStyleProvider,
     private val seed: ByteArray? = null,
 ) : CardSessionRunnable<CreateProductWalletTaskResponse> {
 
@@ -76,7 +78,7 @@ class CreateProductWalletTask(
             cardTypesResolver.isTangemTwins() ->
                 throw UnsupportedOperationException("Use the TwinCardsManager to create a wallet")
 
-            else -> CreateWalletTangemWallet(seed)
+            else -> CreateWalletTangemWallet(seed, derivationStyleProvider)
         }
         commandProcessor.proceed(cardDto, session) {
             when (it) {
@@ -133,6 +135,7 @@ private class CreateWalletTangemNote(private val cardTypesResolver: CardTypesRes
 
 private class CreateWalletTangemWallet(
     private val seed: ByteArray?,
+    private val derivationStyleProvider: DerivationStyleProvider,
 ) : ProductCommandProcessor<CreateProductWalletTaskResponse> {
 
     private var primaryCard: PrimaryCard? = null
@@ -242,9 +245,9 @@ private class CreateWalletTangemWallet(
             val blockchainsForCurve = getBlockchains(response.cardId, card).filter {
                 it.getSupportedCurves().contains(response.wallet.curve)
             }
-            val derivationPaths = blockchainsForCurve.mapNotNull {
+            val derivationPaths = blockchainsForCurve.mapNotNull { blockchain ->
                 isBlockchainsForCurvesExist = true
-                it.derivationPath(card.derivationStyle)
+                blockchain.derivationPath(derivationStyleProvider.getDerivationStyle())
             }
             if (derivationPaths.isNotEmpty()) {
                 map[response.wallet.publicKey.toMapKey()] = derivationPaths

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

@@ -14,6 +14,7 @@ import com.tangem.common.tlv.TlvDecoder
 import com.tangem.crypto.CryptoUtils
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.domain.common.BlockchainNetwork
+import com.tangem.domain.common.DerivationStyleProvider
 import com.tangem.domain.common.TapWorkarounds.isExcluded
 import com.tangem.domain.common.TapWorkarounds.isNotSupportedInThatRelease
 import com.tangem.domain.common.TapWorkarounds.isStart2Coin
@@ -21,6 +22,7 @@ import com.tangem.domain.common.TapWorkarounds.isTangemTwins
 import com.tangem.domain.common.TapWorkarounds.useOldStyleDerivation
 import com.tangem.domain.common.TwinsHelper
 import com.tangem.domain.common.extensions.getPrimaryCurve
+import com.tangem.domain.common.util.derivationStyleProvider
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ProductType
 import com.tangem.domain.models.scan.ScanResponse
@@ -208,31 +210,22 @@ private class ScanWalletProcessor(
     ) {
         val productType = ProductType.Wallet
         scope.launch {
-            val derivations = collectDerivations(card)
+            val scanResponse = ScanResponse(
+                card = card,
+                productType = productType,
+                walletData = session.environment.walletData,
+                primaryCard = primaryCard,
+            )
+            val derivations = collectDerivations(card, scanResponse.derivationStyleProvider)
             if (derivations.isEmpty() || !card.settings.isHDWalletAllowed) {
-                callback(
-                    CompletionResult.Success(
-                        ScanResponse(
-                            card = card,
-                            productType = productType,
-                            walletData = session.environment.walletData,
-                            primaryCard = primaryCard,
-                        ),
-                    ),
-                )
+                callback(CompletionResult.Success(scanResponse))
                 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,
-                        )
+                        val response = scanResponse.copy(derivedKeys = result.data.entries)
                         callback(CompletionResult.Success(response))
                     }
                     is CompletionResult.Failure -> callback(CompletionResult.Failure(result.error))
@@ -241,7 +234,10 @@ private class ScanWalletProcessor(
         }
     }
 
-    private suspend fun getBlockchainsToDerive(card: CardDTO): List<BlockchainNetwork> {
+    private suspend fun getBlockchainsToDerive(
+        card: CardDTO,
+        derivationStyleProvider: DerivationStyleProvider,
+    ): List<BlockchainNetwork> {
         val userTokensRepository = userTokensRepository ?: return emptyList()
         val blockchainsToDerive = userTokensRepository.loadBlockchainsToDerive(card)
             .toMutableList()
@@ -249,11 +245,11 @@ private class ScanWalletProcessor(
                 mutableListOf(
                     BlockchainNetwork(
                         blockchain = Blockchain.Bitcoin,
-                        card = card,
+                        derivationStyleProvider = derivationStyleProvider,
                     ),
                     BlockchainNetwork(
                         blockchain = Blockchain.Ethereum,
-                        card = card,
+                        derivationStyleProvider = derivationStyleProvider,
                     ),
                 )
             }
@@ -263,11 +259,11 @@ private class ScanWalletProcessor(
                 listOf(
                     BlockchainNetwork(
                         blockchain = Blockchain.Ethereum,
-                        card = card,
+                        derivationStyleProvider = derivationStyleProvider,
                     ),
                     BlockchainNetwork(
                         blockchain = Blockchain.EthereumTestnet,
-                        card = card,
+                        derivationStyleProvider = derivationStyleProvider,
                     ),
                 ),
             )
@@ -277,7 +273,7 @@ private class ScanWalletProcessor(
                 additionalBlockchainsToDerive.map {
                     BlockchainNetwork(
                         blockchain = it,
-                        card = card,
+                        derivationStyleProvider = derivationStyleProvider,
                     )
                 },
             )
@@ -293,7 +289,7 @@ private class ScanWalletProcessor(
                 ).map {
                     BlockchainNetwork(
                         blockchain = it,
-                        card = card,
+                        derivationStyleProvider = derivationStyleProvider,
                     )
                 },
             )
@@ -301,8 +297,11 @@ private class ScanWalletProcessor(
         return blockchainsToDerive.distinct()
     }
 
-    private suspend fun collectDerivations(card: CardDTO): Map<ByteArrayKey, List<DerivationPath>> {
-        val blockchains = getBlockchainsToDerive(card)
+    private suspend fun collectDerivations(
+        card: CardDTO,
+        derivationStyleProvider: DerivationStyleProvider,
+    ): Map<ByteArrayKey, List<DerivationPath>> {
+        val blockchains = getBlockchainsToDerive(card, derivationStyleProvider)
         val derivations = mutableMapOf<ByteArrayKey, List<DerivationPath>>()
 
         blockchains.forEach { blockchain ->