Updated on 2026-08-14

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

@@ -9,6 +9,8 @@ import com.tangem.data.tokens.utils.CryptoCurrencyFactory
 import com.tangem.datasource.api.common.response.getOrThrow
 import com.tangem.datasource.api.express.TangemExpressApi
 import com.tangem.datasource.api.express.models.request.PairsRequestBody
+import com.tangem.datasource.api.express.models.response.SwapPair
+import com.tangem.datasource.api.express.models.response.SwapPairsWithProviders
 import com.tangem.datasource.api.oneinch.OneInchApi
 import com.tangem.datasource.api.oneinch.OneInchApiFactory
 import com.tangem.datasource.api.oneinch.OneInchErrorsHandler
@@ -50,7 +52,6 @@ internal class SwapRepositoryImpl @Inject constructor(
     private val swapConverter = SwapConverter()
     private val leastTokenInfoConverter = LeastTokenInfoConverter()
     private val swapPairInfoConverter = SwapPairInfoConverter()
-    private val swapProviderConverter = SwapProviderConverter()
     private val cryptoCurrencyFactory = CryptoCurrencyFactory()
 
     override suspend fun getPairs(
@@ -78,34 +79,29 @@ internal class SwapRepositoryImpl @Inject constructor(
                 )
             }
 
-            pairs.await() + reversedPairs.await()
-        }
-    }
+            val allPairs = pairs.await() + reversedPairs.await()
 
-    override suspend fun getProvidersDetails(providers: Set<SwapProvider>): List<SwapProvider> {
-        val providersMap = providers.associateBy { it.providerId }
-        return tangemExpressApi.getProviders().getOrThrow().mapNotNull {
-            val provider = providersMap[it.id]
-            if (provider != null) {
-                swapProviderConverter.convert(it).copy(rateTypes = provider.rateTypes)
-            } else {
-                null
-            }
+            val providers = tangemExpressApi.getProviders().getOrThrow()
+
+            return@withContext swapPairInfoConverter.convert(
+                SwapPairsWithProviders(
+                    swapPair = allPairs,
+                    providers = providers,
+                ),
+            )
         }
     }
 
     private suspend fun getPairsInternal(
         from: List<NetworkLeastTokenInfo>,
         to: List<NetworkLeastTokenInfo>,
-    ): List<SwapPairLeast> {
+    ): List<SwapPair> {
         return tangemExpressApi.getPairs(
             PairsRequestBody(
                 from = from,
                 to = to,
             ),
-        )
-            .getOrThrow()
-            .map { swapPairInfoConverter.convert(it) }
+        ).getOrThrow()
     }
 
     override suspend fun getRates(currencyId: String, tokenIds: List<String>): Map<String, Double> {

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

@@ -1,36 +1,53 @@
 package com.tangem.feature.swap.converters
 
-import com.tangem.datasource.api.express.models.response.SwapPair
-import com.tangem.datasource.api.express.models.response.SwapPairProvider
+import com.tangem.datasource.api.express.models.response.*
 import com.tangem.feature.swap.domain.models.domain.LeastTokenInfo
+import com.tangem.utils.converter.Converter
+import com.tangem.feature.swap.domain.models.domain.ExchangeProviderType as ExchangeProviderTypeDomain
 import com.tangem.feature.swap.domain.models.domain.SwapPairLeast as SwapPairDomain
 import com.tangem.feature.swap.domain.models.domain.SwapProvider as SwapPairProviderDomain
-import com.tangem.utils.converter.Converter
 
-class SwapPairInfoConverter : Converter<SwapPair, SwapPairDomain> {
+class SwapPairInfoConverter : Converter<SwapPairsWithProviders, List<SwapPairDomain>> {
 
     private val rateTypeConverter = RateTypeConverter()
 
-    override fun convert(value: SwapPair): SwapPairDomain {
-        return SwapPairDomain(
-            from = LeastTokenInfo(
-                contractAddress = value.from.contractAddress,
-                network = value.from.network,
-            ),
-            to = LeastTokenInfo(
-                contractAddress = value.to.contractAddress,
-                network = value.to.network,
-            ),
-            providers = value.providers.map {
-                convertProvider(it)
-            },
-        )
+    override fun convert(value: SwapPairsWithProviders): List<SwapPairDomain> {
+        val providersAdditionalMap = value.providers.associateBy { it.id }
+        return value.swapPair.map { pair ->
+            SwapPairDomain(
+                from = LeastTokenInfo(
+                    contractAddress = pair.from.contractAddress,
+                    network = pair.from.network,
+                ),
+                to = LeastTokenInfo(
+                    contractAddress = pair.to.contractAddress,
+                    network = pair.to.network,
+                ),
+                providers = pair.providers.mapNotNull {
+                    convertProvider(it, providersAdditionalMap)
+                },
+            )
+        }
     }
 
-    private fun convertProvider(swapPairProvider: SwapPairProvider): SwapPairProviderDomain {
+    private fun convertProvider(
+        swapPairProvider: SwapPairProvider,
+        providerAdditional: Map<String, ExchangeProvider>,
+    ): SwapPairProviderDomain? {
+        val additionalProvider = providerAdditional[swapPairProvider.providerId] ?: return null
         return SwapPairProviderDomain(
             providerId = swapPairProvider.providerId,
             rateTypes = swapPairProvider.rateTypes.map { rateTypeConverter.convert(it) },
+            name = additionalProvider.name,
+            type = convertExchangeType(additionalProvider.type),
+            imageLarge = additionalProvider.imageLargeUrl,
         )
     }
+
+    private fun convertExchangeType(type: ExchangeProviderType): ExchangeProviderTypeDomain {
+        return when (type) {
+            ExchangeProviderType.DEX -> ExchangeProviderTypeDomain.DEX
+            ExchangeProviderType.CEX -> ExchangeProviderTypeDomain.CEX
+        }
+    }
 }

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

@@ -1,25 +0,0 @@
-package com.tangem.feature.swap.converters
-
-import com.tangem.datasource.api.express.models.response.ExchangeProvider
-import com.tangem.datasource.api.express.models.response.ExchangeProviderType
-import com.tangem.feature.swap.domain.models.domain.SwapProvider
-import com.tangem.utils.converter.Converter
-import com.tangem.feature.swap.domain.models.domain.ExchangeProviderType as ExchangeProviderTypeDomain
-
-class SwapProviderConverter : Converter<ExchangeProvider, SwapProvider> {
-    override fun convert(value: ExchangeProvider): SwapProvider {
-        return SwapProvider(
-            providerId = value.id,
-            name = value.name,
-            type = convertExchangeType(value.type),
-            imageLarge = value.imageLargeUrl,
-        )
-    }
-
-    private fun convertExchangeType(type: ExchangeProviderType): ExchangeProviderTypeDomain {
-        return when (type) {
-            ExchangeProviderType.DEX -> ExchangeProviderTypeDomain.DEX
-            ExchangeProviderType.CEX -> ExchangeProviderTypeDomain.CEX
-        }
-    }
-}