Updated on 2026-08-14

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

@@ -22,6 +22,15 @@ interface CardCryptoCurrencyFactory {
     @Throws
     suspend fun create(userWalletId: UserWalletId, network: Network): List<CryptoCurrency>
 
+    /**
+     * Universal method for creating list of [CryptoCurrency] in [network] for any card
+     *
+     * @param userWalletId user wallet id that determines type of card
+     * @param network      network
+     */
+    @Throws
+    suspend fun createByRawId(userWalletId: UserWalletId, network: Network.RawID): List<CryptoCurrency>
+
     /**
      * Create currencies for multi currency card
      *

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

@@ -3,6 +3,8 @@ package com.tangem.data.common.currency
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.blockchainsdk.utils.fromNetworkId
+import com.tangem.blockchainsdk.utils.toBlockchain
+import com.tangem.blockchainsdk.utils.toNetworkId
 import com.tangem.datasource.local.token.UserTokensResponseStore
 import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.domain.common.TapWorkarounds.isTestCard
@@ -54,6 +56,32 @@ internal class DefaultCardCryptoCurrencyFactory(
         return createPrimaryCurrencyForSingleCurrencyCard(userWallet.scanResponse).let(::listOf)
     }
 
+    override suspend fun createByRawId(userWalletId: UserWalletId, networkRawId: Network.RawID): List<CryptoCurrency> {
+        val userWallet = userWalletsStore.getSyncStrict(key = userWalletId)
+
+        val blockchain = networkRawId.toBlockchain()
+
+        // multi-currency wallet
+        if (userWallet.isMultiCurrency) {
+            return getMultiWalletCurrenciesByRawId(
+                userWallet = userWallet,
+                rawIds = setOf(networkRawId),
+            )[networkRawId].orEmpty()
+        }
+
+        // check if the blockchain of single-currency wallet is the same as network
+        val cardBlockchain = userWallet.scanResponse.cardTypesResolver.getBlockchain()
+        if (cardBlockchain != blockchain) return emptyList()
+
+        // single-currency wallet with token (NODL)
+        if (userWallet.scanResponse.cardTypesResolver.isSingleWalletWithToken()) {
+            return createCurrenciesForSingleCurrencyCardWithToken(userWallet.scanResponse)
+        }
+
+        // single-currency wallet
+        return createPrimaryCurrencyForSingleCurrencyCard(userWallet.scanResponse).let(::listOf)
+    }
+
     override suspend fun createCurrenciesForMultiCurrencyCard(
         userWallet: UserWallet,
         networks: Set<Network>,
@@ -123,6 +151,24 @@ internal class DefaultCardCryptoCurrencyFactory(
             .groupBy(CryptoCurrency::network)
     }
 
+    private suspend fun getMultiWalletCurrenciesByRawId(
+        userWallet: UserWallet,
+        rawIds: Set<Network.RawID>,
+    ): Map<Network.RawID, List<CryptoCurrency>> {
+        val response = userTokensResponseStore.getSyncOrNull(userWalletId = userWallet.walletId)
+            ?: return emptyMap()
+
+        val responseCurrenciesFactory = ResponseCryptoCurrenciesFactory(excludedBlockchains)
+
+        val networkIds = rawIds.map { it.toBlockchain().toNetworkId() }
+
+        return responseCurrenciesFactory.createCurrencies(
+            tokens = response.tokens.filter { token -> token.networkId in networkIds },
+            scanResponse = userWallet.scanResponse,
+        )
+            .groupBy { it.network.id.rawId }
+    }
+
     private fun getSingleWalletCurrencies(scanResponse: ScanResponse): SingleWalletCurrencies {
         val resolver = scanResponse.cardTypesResolver
         val blockchain = resolver.getBlockchain()

data/networks/src/main/java/com/tangem/data/networks/repository/DefaultNetworksRepository.kt

@@ -62,6 +62,23 @@ internal class DefaultNetworksRepository(
             }
     }
 
+    override suspend fun getNetworkAddresses(
+        userWalletId: UserWalletId,
+        network: Network.RawID,
+    ): List<CryptoCurrencyAddress> {
+        return runCatching { cardCryptoCurrencyFactory.createByRawId(userWalletId = userWalletId, network = network) }
+            .getOrElse {
+                Timber.e(it, "Unable to create wallet currencies")
+                return emptyList()
+            }
+            .map { currency ->
+                CryptoCurrencyAddress(
+                    cryptoCurrency = currency,
+                    address = getDefaultAddress(userWalletId, currency.network),
+                )
+            }
+    }
+
     private suspend fun fetchPendingTransactions(
         userWalletId: UserWalletId,
         network: Network,