Updated on 2026-08-14

data/common/src/main/kotlin/com/tangem/data/common/account/WalletAccountsFetcher.kt

@@ -1,5 +1,6 @@
 package com.tangem.data.common.account
 
+import com.tangem.datasource.api.tangemTech.models.account.GetWalletAccountsResponse
 import com.tangem.domain.models.wallet.UserWalletId
 
 /**
@@ -11,5 +12,8 @@ interface WalletAccountsFetcher {
 
     /** Fetch wallet accounts by [userWalletId] */
     @Throws
-    suspend fun fetch(userWalletId: UserWalletId)
+    suspend fun fetch(userWalletId: UserWalletId): GetWalletAccountsResponse
+
+    /** Get saved wallet accounts by [userWalletId] */
+    suspend fun getSaved(userWalletId: UserWalletId): GetWalletAccountsResponse?
 }

data/common/src/main/kotlin/com/tangem/data/common/currency/CryptoCurrencyFactory.kt

@@ -7,6 +7,7 @@ import com.tangem.blockchainsdk.utils.fromNetworkId
 import com.tangem.blockchainsdk.utils.toBlockchain
 import com.tangem.blockchainsdk.utils.toCoinId
 import com.tangem.data.common.network.NetworkFactory
+import com.tangem.domain.models.account.DerivationIndex
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.network.Network
 import com.tangem.domain.models.wallet.UserWallet
@@ -18,7 +19,7 @@ class CryptoCurrencyFactory(
     private val excludedBlockchains: ExcludedBlockchains,
 ) {
 
-    private val networkFactory by lazy(LazyThreadSafetyMode.NONE) { NetworkFactory(excludedBlockchains) }
+    val networkFactory by lazy(LazyThreadSafetyMode.NONE) { NetworkFactory(excludedBlockchains) }
 
     @Suppress("LongParameterList") // Yep, it's long
     fun createToken(
@@ -48,6 +49,7 @@ class CryptoCurrencyFactory(
         blockchain: Blockchain,
         extraDerivationPath: String?,
         userWallet: UserWallet,
+        accountIndex: DerivationIndex? = null,
     ): CryptoCurrency.Token? {
         if (blockchain == Blockchain.Unknown) {
             Timber.e("Unable to map the SDK token to the domain token with Unknown blockchain")
@@ -58,6 +60,7 @@ class CryptoCurrencyFactory(
             blockchain = blockchain,
             extraDerivationPath = extraDerivationPath,
             userWallet = userWallet,
+            accountIndex = accountIndex,
         ) ?: return null
 
         val id = getTokenId(network, sdkToken)
@@ -74,11 +77,16 @@ class CryptoCurrencyFactory(
         )
     }
 
-    fun createCoin(chainId: Int, extraDerivationPath: String?, userWallet: UserWallet): CryptoCurrency.Coin? {
+    fun createCoin(
+        chainId: Int,
+        extraDerivationPath: String?,
+        userWallet: UserWallet,
+        accountIndex: DerivationIndex? = null,
+    ): CryptoCurrency.Coin? {
         val blockchain: Blockchain? = Chain.entries.find { it.id == chainId }?.blockchain
 
         return if (blockchain != null) {
-            createCoin(blockchain, extraDerivationPath, userWallet)
+            createCoin(blockchain, extraDerivationPath, userWallet, accountIndex)
         } else {
             Timber.e("Unable to get blockchain from chainId == $chainId")
             null
@@ -89,6 +97,7 @@ class CryptoCurrencyFactory(
         blockchain: Blockchain,
         extraDerivationPath: String?,
         userWallet: UserWallet,
+        accountIndex: DerivationIndex? = null,
     ): CryptoCurrency.Coin? {
         if (blockchain == Blockchain.Unknown) {
             Timber.e("Unable to map the SDK token to the domain token with Unknown blockchain")
@@ -99,6 +108,7 @@ class CryptoCurrencyFactory(
             blockchain = blockchain,
             extraDerivationPath = extraDerivationPath,
             userWallet = userWallet,
+            accountIndex = accountIndex,
         ) ?: return null
 
         return createCoin(network)

data/common/src/main/kotlin/com/tangem/data/common/currency/DefaultCardCryptoCurrencyFactory.kt

@@ -1,14 +1,16 @@
 package com.tangem.data.common.currency
 
-import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.blockchainsdk.utils.toBlockchain
 import com.tangem.blockchainsdk.utils.toNetworkId
+import com.tangem.data.common.account.WalletAccountsFetcher
+import com.tangem.data.common.tokens.getDefaultWalletBlockchains
 import com.tangem.datasource.local.token.UserTokensResponseStore
 import com.tangem.datasource.local.userwallet.UserWalletsStore
-import com.tangem.domain.card.common.TapWorkarounds.isTestCard
+import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
 import com.tangem.domain.card.common.util.cardTypesResolver
 import com.tangem.domain.demo.models.DemoConfig
+import com.tangem.domain.models.account.DerivationIndex
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.network.Network
 import com.tangem.domain.models.wallet.UserWallet
@@ -23,10 +25,13 @@ import com.tangem.domain.models.wallet.isMultiCurrency
  * @property userWalletsStore        user wallets store
  * @property userTokensResponseStore user tokens response store
  */
+@Suppress("LongParameterList")
 internal class DefaultCardCryptoCurrencyFactory(
     private val demoConfig: DemoConfig,
     private val excludedBlockchains: ExcludedBlockchains,
     private val userWalletsStore: UserWalletsStore,
+    private val accountsFeatureToggles: AccountsFeatureToggles,
+    private val walletAccountsFetcher: WalletAccountsFetcher,
     private val userTokensResponseStore: UserTokensResponseStore,
     private val responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
 ) : CardCryptoCurrencyFactory {
@@ -99,25 +104,7 @@ internal class DefaultCardCryptoCurrencyFactory(
     override fun createDefaultCoinsForMultiCurrencyWallet(userWallet: UserWallet): List<CryptoCurrency.Coin> {
         require(userWallet.isMultiCurrency) { "It isn't multi-currency wallet" }
 
-        val blockchains = when (userWallet) {
-            is UserWallet.Cold -> {
-                val card = userWallet.scanResponse.card
-
-                var blockchainsInternal = if (demoConfig.isDemoCardId(card.cardId)) {
-                    demoConfig.demoBlockchains
-                } else {
-                    listOf(Blockchain.Bitcoin, Blockchain.Ethereum)
-                }
-
-                if (card.isTestCard) {
-                    blockchainsInternal = blockchainsInternal.mapNotNull { it.getTestnetVersion() }
-                }
-
-                blockchainsInternal
-            }
-
-            is UserWallet.Hot -> listOf(Blockchain.Bitcoin, Blockchain.Ethereum)
-        }
+        val blockchains = getDefaultWalletBlockchains(userWallet, demoConfig)
 
         return blockchains.mapNotNull {
             cryptoCurrencyFactory.createCoin(
@@ -152,15 +139,32 @@ internal class DefaultCardCryptoCurrencyFactory(
         userWallet: UserWallet,
         networks: Set<Network>,
     ): Map<Network, List<CryptoCurrency>> {
-        val response = userTokensResponseStore.getSyncOrNull(userWalletId = userWallet.walletId)
-            ?: return emptyMap()
+        val existingNetworkWithCurrencies = if (accountsFeatureToggles.isFeatureEnabled) {
+            val response = walletAccountsFetcher.getSaved(userWallet.walletId)
+                ?: return emptyMap()
 
-        val existingNetworkWithCurrencies = responseCryptoCurrenciesFactory.createCurrencies(
-            tokens = response.tokens.filter { token ->
-                networks.any { it.backendId == token.networkId && it.derivationPath.value == token.derivationPath }
-            },
-            userWallet = userWallet,
-        )
+            response.accounts.flatMapTo(hashSetOf()) { accountDTO ->
+                responseCryptoCurrenciesFactory.createCurrencies(
+                    tokens = accountDTO.tokens.orEmpty().filter { token ->
+                        networks.any {
+                            it.backendId == token.networkId && it.derivationPath.value == token.derivationPath
+                        }
+                    },
+                    userWallet = userWallet,
+                    accountIndex = DerivationIndex(accountDTO.derivationIndex).getOrNull(),
+                )
+            }
+        } else {
+            val response = userTokensResponseStore.getSyncOrNull(userWalletId = userWallet.walletId)
+                ?: return emptyMap()
+
+            responseCryptoCurrenciesFactory.createCurrencies(
+                tokens = response.tokens.filter { token ->
+                    networks.any { it.backendId == token.networkId && it.derivationPath.value == token.derivationPath }
+                },
+                userWallet = userWallet,
+            )
+        }
             .groupBy(CryptoCurrency::network)
 
         return networks.associateWith { emptyList<CryptoCurrency>() } + existingNetworkWithCurrencies
@@ -170,15 +174,28 @@ internal class DefaultCardCryptoCurrencyFactory(
         userWallet: UserWallet,
         rawIds: Set<Network.RawID>,
     ): Map<Network.RawID, List<CryptoCurrency>> {
-        val response = userTokensResponseStore.getSyncOrNull(userWalletId = userWallet.walletId)
-            ?: return emptyMap()
-
         val networkIds = rawIds.map { it.toBlockchain().toNetworkId() }
 
-        return responseCryptoCurrenciesFactory.createCurrencies(
-            tokens = response.tokens.filter { token -> token.networkId in networkIds },
-            userWallet = userWallet,
-        )
+        return if (accountsFeatureToggles.isFeatureEnabled) {
+            val response = walletAccountsFetcher.getSaved(userWallet.walletId)
+                ?: return emptyMap()
+
+            response.accounts.flatMapTo(hashSetOf()) { accountDTO ->
+                responseCryptoCurrenciesFactory.createCurrencies(
+                    tokens = accountDTO.tokens.orEmpty().filter { token -> token.networkId in networkIds },
+                    userWallet = userWallet,
+                    accountIndex = DerivationIndex(accountDTO.derivationIndex).getOrNull(),
+                )
+            }
+        } else {
+            val response = userTokensResponseStore.getSyncOrNull(userWalletId = userWallet.walletId)
+                ?: return emptyMap()
+
+            responseCryptoCurrenciesFactory.createCurrencies(
+                tokens = response.tokens.filter { token -> token.networkId in networkIds },
+                userWallet = userWallet,
+            )
+        }
             .groupBy { it.network.id.rawId }
     }
 

data/common/src/main/kotlin/com/tangem/data/common/currency/ResponseCryptoCurrenciesFactory.kt

@@ -7,6 +7,7 @@ import com.tangem.blockchainsdk.utils.toCoinId
 import com.tangem.data.common.network.NetworkFactory
 import com.tangem.datasource.api.tangemTech.models.UserTokensResponse
 import com.tangem.domain.card.common.util.cardTypesResolver
+import com.tangem.domain.models.account.DerivationIndex
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.network.Network
 import com.tangem.domain.models.wallet.UserWallet
@@ -18,26 +19,31 @@ class ResponseCryptoCurrenciesFactory @Inject constructor(
     private val networkFactory: NetworkFactory,
 ) {
 
-    fun createCurrency(currencyId: String, response: UserTokensResponse, userWallet: UserWallet): CryptoCurrency {
-        return response.tokens
-            .asSequence()
-            .mapNotNull { createCurrency(it, userWallet) }
-            .first { it.id.value == currencyId }
+    fun createCurrencies(
+        response: UserTokensResponse,
+        userWallet: UserWallet,
+        accountIndex: DerivationIndex? = null,
+    ): List<CryptoCurrency> {
+        return createCurrencies(tokens = response.tokens, userWallet = userWallet, accountIndex = accountIndex)
     }
 
-    fun createCurrencies(response: UserTokensResponse, userWallet: UserWallet): List<CryptoCurrency> {
-        return createCurrencies(tokens = response.tokens, userWallet = userWallet)
-    }
-
-    fun createCurrencies(tokens: List<UserTokensResponse.Token>, userWallet: UserWallet): List<CryptoCurrency> {
+    fun createCurrencies(
+        tokens: List<UserTokensResponse.Token>,
+        userWallet: UserWallet,
+        accountIndex: DerivationIndex? = null,
+    ): List<CryptoCurrency> {
         return tokens
             .asSequence()
-            .mapNotNull { createCurrency(it, userWallet) }
+            .mapNotNull { createCurrency(it, userWallet, accountIndex) }
             .distinctBy(CryptoCurrency::id)
             .toList()
     }
 
-    fun createCurrency(responseToken: UserTokensResponse.Token, userWallet: UserWallet): CryptoCurrency? {
+    fun createCurrency(
+        responseToken: UserTokensResponse.Token,
+        userWallet: UserWallet,
+        accountIndex: DerivationIndex? = null,
+    ): CryptoCurrency? {
         var blockchain = Blockchain.fromNetworkId(responseToken.networkId)
         if (blockchain == null || blockchain == Blockchain.Unknown) {
             Timber.e("Unable to find a blockchain with the network ID: ${responseToken.networkId}")
@@ -52,6 +58,7 @@ class ResponseCryptoCurrenciesFactory @Inject constructor(
             blockchain = blockchain,
             extraDerivationPath = responseToken.derivationPath,
             userWallet = userWallet,
+            accountIndex = accountIndex,
         ) ?: return null
 
         return createCurrency(responseToken = responseToken, userWallet = userWallet, network = network)
@@ -61,6 +68,7 @@ class ResponseCryptoCurrenciesFactory @Inject constructor(
         responseToken: UserTokensResponse.Token,
         userWallet: UserWallet,
         network: Network,
+        accountIndex: DerivationIndex? = null,
     ): CryptoCurrency? {
         var blockchain = Blockchain.fromNetworkId(responseToken.networkId)
         if (blockchain == null || blockchain == Blockchain.Unknown) {
@@ -74,7 +82,7 @@ class ResponseCryptoCurrenciesFactory @Inject constructor(
 
         val sdkToken = createSdkToken(responseToken)
         return if (sdkToken == null) {
-            createCoin(blockchain, responseToken, network)
+            createCoin(blockchain, responseToken, network, accountIndex)
         } else {
             createToken(blockchain, sdkToken, network)
         }

data/common/src/main/kotlin/com/tangem/data/common/currency/UserTokensResponseFactory.kt

@@ -1,11 +1,17 @@
 package com.tangem.data.common.currency
 
+import com.tangem.blockchainsdk.utils.toCoinId
+import com.tangem.blockchainsdk.utils.toNetworkId
+import com.tangem.data.common.network.NetworkFactory
+import com.tangem.data.common.tokens.getDefaultWalletBlockchains
 import com.tangem.datasource.api.tangemTech.models.UserTokensResponse
+import com.tangem.domain.demo.models.DemoConfig
 import com.tangem.domain.models.account.AccountId
 import com.tangem.domain.models.currency.CryptoCurrency
+import com.tangem.domain.models.wallet.UserWallet
+import com.tangem.domain.wallets.derivations.derivationStyleProvider
 import javax.inject.Inject
 
-// TODO: [REDACTED_JIRA]
 class UserTokensResponseFactory @Inject constructor() {
 
     fun createUserTokensResponse(
@@ -43,4 +49,38 @@ class UserTokensResponseFactory @Inject constructor() {
             )
         }
     }
+
+    fun createDefaultResponse(
+        userWallet: UserWallet?,
+        networkFactory: NetworkFactory,
+        accountId: AccountId?,
+    ): UserTokensResponse {
+        val tokens = userWallet?.let {
+            getDefaultWalletBlockchains(userWallet = it, demoConfig = DemoConfig())
+                .map { blockchain ->
+                    val derivationPath = networkFactory.createDerivationPath(
+                        blockchain = blockchain,
+                        extraDerivationPath = null,
+                        cardDerivationStyleProvider = userWallet.derivationStyleProvider,
+                    ).value
+
+                    UserTokensResponse.Token(
+                        id = blockchain.toCoinId(),
+                        accountId = accountId?.value,
+                        networkId = blockchain.toNetworkId(),
+                        derivationPath = derivationPath,
+                        name = blockchain.getCoinName(),
+                        symbol = blockchain.currency,
+                        decimals = blockchain.decimals(),
+                        contractAddress = null,
+                    )
+                }
+        }
+
+        return UserTokensResponse(
+            group = UserTokensResponse.GroupType.NONE,
+            sort = UserTokensResponse.SortType.MANUAL,
+            tokens = tokens.orEmpty(),
+        )
+    }
 }

data/common/src/main/kotlin/com/tangem/data/common/di/DataCommonModule.kt

@@ -1,6 +1,7 @@
 package com.tangem.data.common.di
 
 import com.tangem.blockchainsdk.utils.ExcludedBlockchains
+import com.tangem.data.common.account.WalletAccountsFetcher
 import com.tangem.data.common.cache.etag.DefaultETagsStore
 import com.tangem.data.common.cache.etag.ETagsStore
 import com.tangem.data.common.currency.*
@@ -30,6 +31,8 @@ internal object DataCommonModule {
     fun provideCardCryptoCurrencyFactory(
         excludedBlockchains: ExcludedBlockchains,
         userWalletsStore: UserWalletsStore,
+        accountsFeatureToggles: AccountsFeatureToggles,
+        walletAccountsFetcher: WalletAccountsFetcher,
         userTokensResponseStore: UserTokensResponseStore,
         responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
     ): CardCryptoCurrencyFactory {
@@ -37,6 +40,8 @@ internal object DataCommonModule {
             demoConfig = DemoConfig(),
             excludedBlockchains = excludedBlockchains,
             userWalletsStore = userWalletsStore,
+            accountsFeatureToggles = accountsFeatureToggles,
+            walletAccountsFetcher = walletAccountsFetcher,
             userTokensResponseStore = userTokensResponseStore,
             responseCryptoCurrenciesFactory = responseCryptoCurrenciesFactory,
         )

data/common/src/main/kotlin/com/tangem/data/common/network/NetworkFactory.kt

@@ -7,10 +7,12 @@ import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.blockchainsdk.utils.toBlockchain
 import com.tangem.blockchainsdk.utils.toNetworkId
 import com.tangem.domain.card.common.extensions.canHandleToken
-import com.tangem.domain.wallets.derivations.derivationStyleProvider
+import com.tangem.domain.models.account.DerivationIndex
 import com.tangem.domain.models.network.Network
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.wallets.derivations.DerivationStyleProvider
+import com.tangem.domain.wallets.derivations.derivationStyleProvider
+import com.tangem.lib.crypto.derivation.toMutable
 import timber.log.Timber
 import javax.inject.Inject
 
@@ -21,6 +23,7 @@ import javax.inject.Inject
  *
 [REDACTED_AUTHOR]
  */
+@Suppress("LargeClass")
 class NetworkFactory @Inject constructor(
     private val excludedBlockchains: ExcludedBlockchains,
 ) {
@@ -32,13 +35,19 @@ class NetworkFactory @Inject constructor(
      * @param extraDerivationPath extra derivation path
      * @param userWallet          user wallet
      */
-    fun create(blockchain: Blockchain, extraDerivationPath: String?, userWallet: UserWallet): Network? {
+    fun create(
+        blockchain: Blockchain,
+        extraDerivationPath: String?,
+        userWallet: UserWallet,
+        accountIndex: DerivationIndex? = null,
+    ): Network? {
         return create(
             blockchain = blockchain,
             derivationPath = createDerivationPath(
                 blockchain = blockchain,
                 extraDerivationPath = extraDerivationPath,
                 cardDerivationStyleProvider = userWallet.derivationStyleProvider,
+                accountIndex = accountIndex,
             ),
             canHandleTokens = userWallet.canHandleToken(
                 blockchain = blockchain,
@@ -98,6 +107,7 @@ class NetworkFactory @Inject constructor(
         extraDerivationPath: String?,
         derivationStyleProvider: DerivationStyleProvider?,
         canHandleTokens: Boolean,
+        accountIndex: DerivationIndex? = null,
     ): Network? {
         return create(
             blockchain = blockchain,
@@ -105,6 +115,7 @@ class NetworkFactory @Inject constructor(
                 blockchain = blockchain,
                 extraDerivationPath = extraDerivationPath,
                 cardDerivationStyleProvider = derivationStyleProvider,
+                accountIndex = accountIndex,
             ),
             canHandleTokens = canHandleTokens,
         )
@@ -148,14 +159,15 @@ class NetworkFactory @Inject constructor(
         return true
     }
 
-    private fun createDerivationPath(
+    fun createDerivationPath(
         blockchain: Blockchain,
         extraDerivationPath: String?,
         cardDerivationStyleProvider: DerivationStyleProvider?,
+        accountIndex: DerivationIndex? = null,
     ): Network.DerivationPath {
         if (cardDerivationStyleProvider == null) return Network.DerivationPath.None
 
-        val defaultDerivationPath = getDefaultDerivationPath(blockchain, cardDerivationStyleProvider)
+        val defaultDerivationPath = getDefaultDerivationPath(blockchain, cardDerivationStyleProvider, accountIndex)
 
         return if (extraDerivationPath.isNullOrBlank()) {
             if (defaultDerivationPath.isNullOrBlank()) {
@@ -164,10 +176,11 @@ class NetworkFactory @Inject constructor(
                 Network.DerivationPath.Card(defaultDerivationPath)
             }
         } else {
-            if (extraDerivationPath == defaultDerivationPath) {
-                Network.DerivationPath.Card(defaultDerivationPath)
-            } else {
+            val isMainIndexOrNull = accountIndex == null || accountIndex == DerivationIndex.Main
+            if (extraDerivationPath != defaultDerivationPath && isMainIndexOrNull) {
                 Network.DerivationPath.Custom(extraDerivationPath)
+            } else {
+                Network.DerivationPath.Card(extraDerivationPath)
             }
         }
     }
@@ -175,8 +188,19 @@ class NetworkFactory @Inject constructor(
     private fun getDefaultDerivationPath(
         blockchain: Blockchain,
         derivationStyleProvider: DerivationStyleProvider,
+        accountIndex: DerivationIndex?,
     ): String? {
-        return blockchain.derivationPath(derivationStyleProvider.getDerivationStyle())?.rawPath
+        val default = blockchain.derivationPath(derivationStyleProvider.getDerivationStyle())
+            ?: return null
+
+        return if (accountIndex == null || accountIndex == DerivationIndex.Main) {
+            default
+        } else {
+            default.toMutable()
+                .replaceAccountNode(value = accountIndex.value.toLong(), blockchain = blockchain)
+                .apply()
+        }
+            .rawPath
     }
 
     private fun getNetworkStandardType(blockchain: Blockchain): Network.StandardType {
@@ -344,8 +368,8 @@ class NetworkFactory @Inject constructor(
             Blockchain.Pepecoin, Blockchain.PepecoinTestnet,
             Blockchain.Hyperliquid, Blockchain.HyperliquidTestnet,
             Blockchain.Quai, Blockchain.QuaiTestnet,
-            // Blockchain.Linea, Blockchain.LineaTestnet,
-            // Blockchain.ArbitrumNova,
+            Blockchain.Linea, Blockchain.LineaTestnet,
+            Blockchain.ArbitrumNova,
             -> Network.TransactionExtrasType.NONE
             // endregion
         }

data/common/src/main/kotlin/com/tangem/data/common/tokens/DefaultWalletBlockchains.kt

@@ -0,0 +1,33 @@
+package com.tangem.data.common.tokens
+
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.domain.card.common.TapWorkarounds.isTestCard
+import com.tangem.domain.demo.models.DemoConfig
+import com.tangem.domain.models.wallet.UserWallet
+
+/**
+ * Returns the default blockchains for the multi-currency wallet.
+ *
+ * @param userWallet The user's wallet, which can be either a cold or hot wallet.
+ * @param demoConfig Configuration for demo cards, which may specify different default blockchains.
+ */
+fun getDefaultWalletBlockchains(userWallet: UserWallet, demoConfig: DemoConfig): Collection<Blockchain> {
+    return when (userWallet) {
+        is UserWallet.Cold -> {
+            val card = userWallet.scanResponse.card
+
+            var blockchainsInternal = if (demoConfig.isDemoCardId(card.cardId)) {
+                demoConfig.demoBlockchains
+            } else {
+                listOf(Blockchain.Bitcoin, Blockchain.Ethereum)
+            }
+
+            if (card.isTestCard) {
+                blockchainsInternal = blockchainsInternal.mapNotNull { it.getTestnetVersion() }
+            }
+
+            blockchainsInternal
+        }
+        is UserWallet.Hot -> listOf(Blockchain.Bitcoin, Blockchain.Ethereum)
+    }
+}

data/common/src/test/kotlin/com/tangem/data/common/currency/DefaultCardCryptoCurrencyFactoryTest.kt

@@ -9,10 +9,12 @@ import com.tangem.common.test.domain.card.MockScanResponseFactory
 import com.tangem.common.test.domain.token.MockCryptoCurrencyFactory
 import com.tangem.common.test.domain.wallet.MockUserWalletFactory
 import com.tangem.common.test.utils.ProvideTestModels
+import com.tangem.data.common.account.WalletAccountsFetcher
 import com.tangem.data.common.network.NetworkFactory
 import com.tangem.datasource.api.tangemTech.models.UserTokensResponse
 import com.tangem.datasource.local.token.UserTokensResponseStore
 import com.tangem.datasource.local.userwallet.UserWalletsStore
+import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
 import com.tangem.domain.card.common.util.cardTypesResolver
 import com.tangem.domain.card.configs.GenericCardConfig
 import com.tangem.domain.demo.models.DemoConfig
@@ -37,6 +39,8 @@ internal class DefaultCardCryptoCurrencyFactoryTest {
     private val userWalletsStore: UserWalletsStore = mockk()
     private val userTokensResponseStore: UserTokensResponseStore = mockk()
     private val excludedBlockchains = ExcludedBlockchains()
+    private val accountsFeatureToggles = mockk<AccountsFeatureToggles>()
+    private val walletAccountsFetcher = mockk<WalletAccountsFetcher>()
 
     private val factory = DefaultCardCryptoCurrencyFactory(
         demoConfig = DemoConfig(),
@@ -46,6 +50,8 @@ internal class DefaultCardCryptoCurrencyFactoryTest {
         responseCryptoCurrenciesFactory = ResponseCryptoCurrenciesFactory(
             networkFactory = NetworkFactory(excludedBlockchains = excludedBlockchains),
         ),
+        accountsFeatureToggles = accountsFeatureToggles,
+        walletAccountsFetcher = walletAccountsFetcher,
     )
 
     private val cryptoCurrencyFactory = MockCryptoCurrencyFactory()
@@ -57,7 +63,7 @@ internal class DefaultCardCryptoCurrencyFactoryTest {
 
     @BeforeEach
     fun init() {
-        clearMocks(userWalletsStore, userTokensResponseStore, iconUri)
+        clearMocks(userWalletsStore, userTokensResponseStore, accountsFeatureToggles, walletAccountsFetcher, iconUri)
 
         mockkStatic(Uri::class)
         every { Uri.parse(any()) } returns iconUri
@@ -75,6 +81,7 @@ internal class DefaultCardCryptoCurrencyFactoryTest {
             val userTokensResponse = model.userTokensResponse
             val network = ethereum.network
 
+            every { accountsFeatureToggles.isFeatureEnabled } returns false
             coEvery { userWalletsStore.getSyncStrict(key = userWallet.walletId) } returns userWallet
             coEvery { userTokensResponseStore.getSyncOrNull(userWallet.walletId) } returns userTokensResponse
 
@@ -236,6 +243,7 @@ internal class DefaultCardCryptoCurrencyFactoryTest {
                 val networks = setOf(ethereum.network, bitcoin.network)
                 val userTokensResponse = model.userTokensResponse
 
+                every { accountsFeatureToggles.isFeatureEnabled } returns false
                 coEvery { userTokensResponseStore.getSyncOrNull(userWallet.walletId) } returns userTokensResponse
 
                 // Act