Updated on 2026-08-14

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

@@ -31,6 +31,7 @@ internal class DefaultCardCryptoCurrencyFactory(
     private val excludedBlockchains: ExcludedBlockchains,
     private val userWalletsStore: UserWalletsStore,
     private val userTokensResponseStore: UserTokensResponseStore,
+    private val responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
 ) : CardCryptoCurrencyFactory {
 
     private val cryptoCurrencyFactory by lazy { CryptoCurrencyFactory(excludedBlockchains) }
@@ -142,9 +143,7 @@ internal class DefaultCardCryptoCurrencyFactory(
         val response = userTokensResponseStore.getSyncOrNull(userWalletId = userWallet.walletId)
             ?: return emptyMap()
 
-        val responseCurrenciesFactory = ResponseCryptoCurrenciesFactory(excludedBlockchains)
-
-        return responseCurrenciesFactory.createCurrencies(
+        return responseCryptoCurrenciesFactory.createCurrencies(
             tokens = response.tokens.filter { token ->
                 networks.any { it.backendId == token.networkId && it.derivationPath.value == token.derivationPath }
             },
@@ -160,11 +159,9 @@ internal class DefaultCardCryptoCurrencyFactory(
         val response = userTokensResponseStore.getSyncOrNull(userWalletId = userWallet.walletId)
             ?: return emptyMap()
 
-        val responseCurrenciesFactory = ResponseCryptoCurrenciesFactory(excludedBlockchains)
-
         val networkIds = rawIds.map { it.toBlockchain().toNetworkId() }
 
-        return responseCurrenciesFactory.createCurrencies(
+        return responseCryptoCurrenciesFactory.createCurrencies(
             tokens = response.tokens.filter { token -> token.networkId in networkIds },
             scanResponse = userWallet.requireColdWallet().scanResponse, // TODO [REDACTED_TASK_KEY]
         )

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

@@ -2,7 +2,6 @@ package com.tangem.data.common.currency
 
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.Token
-import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.blockchainsdk.utils.fromNetworkId
 import com.tangem.blockchainsdk.utils.toCoinId
 import com.tangem.data.common.network.NetworkFactory
@@ -11,11 +10,12 @@ import com.tangem.domain.common.util.cardTypesResolver
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.scan.ScanResponse
 import timber.log.Timber
+import javax.inject.Inject
 import com.tangem.blockchain.common.Token as SdkToken
 
-class ResponseCryptoCurrenciesFactory(excludedBlockchains: ExcludedBlockchains) {
-
-    private val networkFactory by lazy(LazyThreadSafetyMode.NONE) { NetworkFactory(excludedBlockchains) }
+class ResponseCryptoCurrenciesFactory @Inject constructor(
+    private val networkFactory: NetworkFactory,
+) {
 
     fun createCurrency(currencyId: String, response: UserTokensResponse, scanResponse: ScanResponse): CryptoCurrency {
         return response.tokens
@@ -25,11 +25,7 @@ class ResponseCryptoCurrenciesFactory(excludedBlockchains: ExcludedBlockchains)
     }
 
     fun createCurrencies(response: UserTokensResponse, scanResponse: ScanResponse): List<CryptoCurrency> {
-        return response.tokens
-            .asSequence()
-            .mapNotNull { createCurrency(it, scanResponse) }
-            .distinctBy { it.id }
-            .toList()
+        return createCurrencies(tokens = response.tokens, scanResponse = scanResponse)
     }
 
     fun createCurrencies(tokens: List<UserTokensResponse.Token>, scanResponse: ScanResponse): List<CryptoCurrency> {

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

@@ -1,10 +1,7 @@
 package com.tangem.data.common.di
 
 import com.tangem.blockchainsdk.utils.ExcludedBlockchains
-import com.tangem.data.common.currency.CardCryptoCurrencyFactory
-import com.tangem.data.common.currency.DefaultCardCryptoCurrencyFactory
-import com.tangem.data.common.currency.UserTokensResponseAddressesEnricher
-import com.tangem.data.common.currency.UserTokensSaver
+import com.tangem.data.common.currency.*
 import com.tangem.data.common.quote.DefaultQuotesFetcher
 import com.tangem.data.common.quote.QuotesFetcher
 import com.tangem.datasource.api.tangemTech.TangemTechApi
@@ -31,12 +28,14 @@ internal object DataCommonModule {
         excludedBlockchains: ExcludedBlockchains,
         userWalletsStore: UserWalletsStore,
         userTokensResponseStore: UserTokensResponseStore,
+        responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
     ): CardCryptoCurrencyFactory {
         return DefaultCardCryptoCurrencyFactory(
             demoConfig = DemoConfig(),
             excludedBlockchains = excludedBlockchains,
             userWalletsStore = userWalletsStore,
             userTokensResponseStore = userTokensResponseStore,
+            responseCryptoCurrenciesFactory = responseCryptoCurrenciesFactory,
         )
     }
 

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

@@ -8,6 +8,7 @@ import com.tangem.common.card.WalletData
 import com.tangem.common.test.domain.card.MockScanResponseFactory
 import com.tangem.common.test.domain.token.MockCryptoCurrencyFactory
 import com.tangem.common.test.utils.ProvideTestModels
+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
@@ -34,12 +35,16 @@ internal class DefaultCardCryptoCurrencyFactoryTest {
 
     private val userWalletsStore: UserWalletsStore = mockk()
     private val userTokensResponseStore: UserTokensResponseStore = mockk()
+    private val excludedBlockchains = ExcludedBlockchains()
 
     private val factory = DefaultCardCryptoCurrencyFactory(
         demoConfig = DemoConfig(),
-        excludedBlockchains = ExcludedBlockchains(),
+        excludedBlockchains = excludedBlockchains,
         userWalletsStore = userWalletsStore,
         userTokensResponseStore = userTokensResponseStore,
+        responseCryptoCurrenciesFactory = ResponseCryptoCurrenciesFactory(
+            networkFactory = NetworkFactory(excludedBlockchains = excludedBlockchains),
+        ),
     )
 
     private val cryptoCurrencyFactory = MockCryptoCurrencyFactory()

data/swap/src/main/java/com/tangem/data/swap/DefaultSwapTransactionRepository.kt

@@ -1,6 +1,6 @@
 package com.tangem.data.swap
 
-import com.tangem.blockchainsdk.utils.ExcludedBlockchains
+import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.data.common.currency.UserTokensResponseFactory
 import com.tangem.data.swap.converter.transaction.SavedSwapStatusConverter
 import com.tangem.data.swap.converter.transaction.SavedSwapTransactionConverter
@@ -31,15 +31,15 @@ import kotlinx.coroutines.withContext
 
 internal class DefaultSwapTransactionRepository(
     private val appPreferencesStore: AppPreferencesStore,
+    private val responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
     private val dispatchers: CoroutineDispatcherProvider,
-    excludedBlockchains: ExcludedBlockchains,
 ) : SwapTransactionRepository {
 
     private val listConverter by lazy(LazyThreadSafetyMode.NONE) {
-        SavedSwapTransactionListConverter(excludedBlockchains)
+        SavedSwapTransactionListConverter(responseCryptoCurrenciesFactory = responseCryptoCurrenciesFactory)
     }
     private val converter by lazy(LazyThreadSafetyMode.NONE) {
-        SavedSwapTransactionConverter(excludedBlockchains)
+        SavedSwapTransactionConverter(responseCryptoCurrenciesFactory = responseCryptoCurrenciesFactory)
     }
     private val savedStatusConverter by lazy(LazyThreadSafetyMode.NONE) {
         SavedSwapStatusConverter()

data/swap/src/main/java/com/tangem/data/swap/converter/transaction/SavedSwapTransactionConverter.kt

@@ -1,6 +1,5 @@
 package com.tangem.data.swap.converter.transaction
 
-import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.data.swap.models.SwapStatusDTO
 import com.tangem.data.swap.models.SwapTransactionDTO
@@ -9,9 +8,9 @@ import com.tangem.domain.swap.models.SwapTransactionModel
 import com.tangem.utils.converter.TwoWayConverter
 
 internal class SavedSwapTransactionConverter(
-    excludedBlockchains: ExcludedBlockchains,
+    private val responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
 ) : TwoWayConverter<SwapTransactionModel, SwapTransactionDTO> {
-    private val responseCryptoCurrenciesFactory = ResponseCryptoCurrenciesFactory(excludedBlockchains)
+
     private val statusConverter by lazy(LazyThreadSafetyMode.NONE) {
         SavedSwapStatusConverter()
     }

data/swap/src/main/java/com/tangem/data/swap/converter/transaction/SavedSwapTransactionListConverter.kt

@@ -1,6 +1,5 @@
 package com.tangem.data.swap.converter.transaction
 
-import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.data.common.currency.UserTokensResponseFactory
 import com.tangem.data.swap.models.SwapStatusDTO
@@ -13,13 +12,12 @@ import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.utils.converter.Converter
 
 internal class SavedSwapTransactionListConverter(
-    excludedBlockchains: ExcludedBlockchains,
+    private val responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
 ) : Converter<SwapTransactionListModel, SwapTransactionListDTO> {
 
-    private val responseCryptoCurrenciesFactory = ResponseCryptoCurrenciesFactory(excludedBlockchains)
     private val userTokensResponseFactory = UserTokensResponseFactory()
     private val savedSwapTransactionConverter by lazy(LazyThreadSafetyMode.NONE) {
-        SavedSwapTransactionConverter(excludedBlockchains)
+        SavedSwapTransactionConverter(responseCryptoCurrenciesFactory = responseCryptoCurrenciesFactory)
     }
 
     override fun convert(value: SwapTransactionListModel) = SwapTransactionListDTO(

data/swap/src/main/java/com/tangem/data/swap/di/SwapDataModule.kt

@@ -1,7 +1,7 @@
 package com.tangem.data.swap.di
 
 import com.squareup.moshi.Moshi
-import com.tangem.blockchainsdk.utils.ExcludedBlockchains
+import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.data.express.converter.ExpressErrorConverter
 import com.tangem.data.swap.DefaultSwapErrorResolver
 import com.tangem.data.swap.DefaultSwapRepositoryV2
@@ -56,14 +56,14 @@ internal object SwapDataModule {
     @Provides
     @Singleton
     fun provideSwapTransactionRepository(
-        coroutineDispatcher: CoroutineDispatcherProvider,
         appPreferencesStore: AppPreferencesStore,
-        excludedBlockchains: ExcludedBlockchains,
+        responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
+        dispatchers: CoroutineDispatcherProvider,
     ): SwapTransactionRepository {
         return DefaultSwapTransactionRepository(
             appPreferencesStore = appPreferencesStore,
-            dispatchers = coroutineDispatcher,
-            excludedBlockchains = excludedBlockchains,
+            responseCryptoCurrenciesFactory = responseCryptoCurrenciesFactory,
+            dispatchers = dispatchers,
         )
     }
 }

data/tokens/src/main/kotlin/com/tangem/data/tokens/di/TokensDataModule.kt

@@ -3,6 +3,7 @@ package com.tangem.data.tokens.di
 import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.data.common.cache.CacheRegistry
 import com.tangem.data.common.currency.CardCryptoCurrencyFactory
+import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.data.common.currency.UserTokensSaver
 import com.tangem.data.tokens.repository.DefaultCurrenciesRepository
 import com.tangem.data.tokens.repository.DefaultCurrencyChecksRepository
@@ -40,6 +41,7 @@ internal object TokensDataModule {
         excludedBlockchains: ExcludedBlockchains,
         cardCryptoCurrencyFactory: CardCryptoCurrencyFactory,
         tokensSaver: UserTokensSaver,
+        responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
     ): CurrenciesRepository {
         return DefaultCurrenciesRepository(
             tangemTechApi = tangemTechApi,
@@ -52,6 +54,7 @@ internal object TokensDataModule {
             excludedBlockchains = excludedBlockchains,
             cardCryptoCurrencyFactory = cardCryptoCurrencyFactory,
             userTokensSaver = tokensSaver,
+            responseCryptoCurrenciesFactory = responseCryptoCurrenciesFactory,
         )
     }
 

data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/DefaultCurrenciesRepository.kt

@@ -43,11 +43,11 @@ internal class DefaultCurrenciesRepository(
     private val cardCryptoCurrencyFactory: CardCryptoCurrencyFactory,
     private val userTokensSaver: UserTokensSaver,
     private val userTokensResponseStore: UserTokensResponseStore,
+    private val responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
     excludedBlockchains: ExcludedBlockchains,
 ) : CurrenciesRepository {
 
     private val demoConfig = DemoConfig()
-    private val responseCurrenciesFactory = ResponseCryptoCurrenciesFactory(excludedBlockchains)
     private val cryptoCurrencyFactory = CryptoCurrencyFactory(excludedBlockchains)
     private val userTokensResponseFactory = UserTokensResponseFactory()
     private val customTokensMerger = CustomTokensMerger(
@@ -314,7 +314,7 @@ internal class DefaultCurrenciesRepository(
             },
         )
 
-        responseCurrenciesFactory.createCurrencies(storedTokens, userWallet.requireColdWallet().scanResponse)
+        responseCryptoCurrenciesFactory.createCurrencies(storedTokens, userWallet.requireColdWallet().scanResponse)
     }
 
     override suspend fun getMultiCurrencyWalletCachedCurrenciesSync(userWalletId: UserWalletId) =
@@ -329,7 +329,7 @@ internal class DefaultCurrenciesRepository(
                 },
             )
 
-            responseCurrenciesFactory.createCurrencies(storedTokens, userWallet.requireColdWallet().scanResponse)
+            responseCryptoCurrenciesFactory.createCurrencies(storedTokens, userWallet.requireColdWallet().scanResponse)
         }
 
     override suspend fun getMultiCurrencyWalletCurrency(
@@ -351,7 +351,7 @@ internal class DefaultCurrenciesRepository(
                 },
             )
 
-            responseCurrenciesFactory.createCurrency(
+            responseCryptoCurrenciesFactory.createCurrency(
                 currencyId = id,
                 response = response,
                 scanResponse = userWallet.requireColdWallet().scanResponse,
@@ -386,7 +386,10 @@ internal class DefaultCurrenciesRepository(
                         it.derivationPath == derivationPath.value
                 } ?: error("Coin in this network $networkId not found")
 
-            val coin = responseCurrenciesFactory.createCurrency(storedCoin, userWallet.requireColdWallet().scanResponse)
+            val coin = responseCryptoCurrenciesFactory.createCurrency(
+                responseToken = storedCoin,
+                scanResponse = userWallet.requireColdWallet().scanResponse,
+            )
 
             coin as? CryptoCurrency.Coin ?: error("Unable to create currency")
         }
@@ -526,7 +529,7 @@ internal class DefaultCurrenciesRepository(
                                 getL2CompatibilityTokenComparison(it, currencyRawId.value)
                             }
 
-                            responseCurrenciesFactory.createCurrencies(
+                            responseCryptoCurrenciesFactory.createCurrencies(
                                 response = storedTokens.copy(tokens = filterResponse),
                                 scanResponse = userWallet.requireColdWallet().scanResponse,
                             )
@@ -572,7 +575,7 @@ internal class DefaultCurrenciesRepository(
 
     private fun getMultiCurrencyWalletCurrencies(userWallet: UserWallet): Flow<List<CryptoCurrency>> {
         return getSavedUserTokensResponse(userWallet.walletId).map { storedTokens ->
-            responseCurrenciesFactory.createCurrencies(
+            responseCryptoCurrenciesFactory.createCurrencies(
                 response = storedTokens,
                 scanResponse = userWallet.requireColdWallet().scanResponse,
             )

features/swap/data/src/main/java/com/tangem/feature/swap/DefaultSwapTransactionRepository.kt

@@ -1,6 +1,6 @@
 package com.tangem.feature.swap
 
-import com.tangem.blockchainsdk.utils.ExcludedBlockchains
+import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.data.common.currency.UserTokensResponseFactory
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.datasource.local.preferences.PreferencesKeys
@@ -24,10 +24,12 @@ import kotlinx.coroutines.withContext
 internal class DefaultSwapTransactionRepository(
     private val appPreferencesStore: AppPreferencesStore,
     private val dispatchers: CoroutineDispatcherProvider,
-    excludedBlockchains: ExcludedBlockchains,
+    responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
 ) : SwapTransactionRepository {
 
-    private val converter = SavedSwapTransactionListConverter(excludedBlockchains)
+    private val converter by lazy(LazyThreadSafetyMode.NONE) {
+        SavedSwapTransactionListConverter(responseCryptoCurrenciesFactory = responseCryptoCurrenciesFactory)
+    }
     private val userTokensResponseFactory = UserTokensResponseFactory()
 
     override suspend fun storeTransaction(

features/swap/data/src/main/java/com/tangem/feature/swap/converters/SavedSwapTransactionListConverter.kt

@@ -1,6 +1,5 @@
 package com.tangem.feature.swap.converters
 
-import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.data.common.currency.UserTokensResponseFactory
 import com.tangem.domain.models.currency.CryptoCurrency
@@ -13,10 +12,9 @@ import com.tangem.feature.swap.domain.models.domain.SavedSwapTransactionModel
 import com.tangem.utils.converter.Converter
 
 internal class SavedSwapTransactionListConverter(
-    excludedBlockchains: ExcludedBlockchains,
+    private val responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
 ) : Converter<SavedSwapTransactionListModel, SavedSwapTransactionListModelInner> {
 
-    private val responseCryptoCurrenciesFactory = ResponseCryptoCurrenciesFactory(excludedBlockchains)
     private val userTokensResponseFactory = UserTokensResponseFactory()
 
     override fun convert(value: SavedSwapTransactionListModel) = SavedSwapTransactionListModelInner(

features/swap/data/src/main/java/com/tangem/feature/swap/di/SwapDataModule.kt

@@ -2,6 +2,7 @@ package com.tangem.feature.swap.di
 
 import com.squareup.moshi.Moshi
 import com.tangem.blockchainsdk.utils.ExcludedBlockchains
+import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.datasource.api.express.TangemExpressApi
 import com.tangem.datasource.api.express.models.response.ExpressErrorResponse
 import com.tangem.datasource.crypto.DataSignatureVerifier
@@ -55,13 +56,13 @@ internal class SwapDataModule {
     @Singleton
     fun provideSwapTransactionRepository(
         appPreferencesStore: AppPreferencesStore,
+        responseCryptoCurrenciesFactory: ResponseCryptoCurrenciesFactory,
         dispatcherProvider: CoroutineDispatcherProvider,
-        excludedBlockchains: ExcludedBlockchains,
     ): SwapTransactionRepository {
         return DefaultSwapTransactionRepository(
             appPreferencesStore = appPreferencesStore,
+            responseCryptoCurrenciesFactory = responseCryptoCurrenciesFactory,
             dispatchers = dispatcherProvider,
-            excludedBlockchains = excludedBlockchains,
         )
     }