Updated on 2026-08-14

app/src/main/java/com/tangem/tap/di/ActivityModule.kt

@@ -1,17 +1,18 @@
 package com.tangem.tap.di
 
+import com.tangem.datasource.exchangeservice.swap.SwapServiceLoader
 import com.tangem.domain.card.ScanCardUseCase
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.exchange.RampStateManager
 import com.tangem.domain.tokens.GetPolkadotCheckHasImmortalUseCase
 import com.tangem.domain.tokens.GetPolkadotCheckHasResetUseCase
-import com.tangem.domain.tokens.repository.MarketCryptoCurrencyRepository
 import com.tangem.domain.tokens.repository.PolkadotAccountHealthCheckRepository
 import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.tap.domain.scanCard.repository.DefaultScanCardRepository
 import com.tangem.tap.network.exchangeServices.DefaultRampManager
 import com.tangem.tap.proxy.AppStateHolder
 import com.tangem.utils.Provider
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -43,13 +44,15 @@ internal object ActivityModule {
     @Singleton
     fun provideDefaultRampManager(
         appStateHolder: AppStateHolder,
-        marketCryptoCurrencyRepository: MarketCryptoCurrencyRepository,
+        swapServiceLoader: SwapServiceLoader,
+        dispatchers: CoroutineDispatcherProvider,
     ): RampStateManager {
         return DefaultRampManager(
             exchangeService = appStateHolder.exchangeService,
             buyService = Provider { requireNotNull(appStateHolder.buyService) },
             sellService = Provider { requireNotNull(appStateHolder.sellService) },
-            marketsCryptoCurrencyRepository = marketCryptoCurrencyRepository,
+            swapServiceLoader = swapServiceLoader,
+            dispatchers = dispatchers,
         )
     }
 

app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt

@@ -118,26 +118,26 @@ internal object TokensDomainModule {
         currenciesRepository: CurrenciesRepository,
         quotesRepository: QuotesRepository,
         networksRepository: NetworksRepository,
-        marketCryptoCurrencyRepository: MarketCryptoCurrencyRepository,
         swapRepository: SwapRepository,
         currencyChecksRepository: CurrencyChecksRepository,
         showSwapPromoTokenUseCase: ShouldShowSwapPromoTokenUseCase,
         promoRepository: PromoRepository,
         stakingRepository: StakingRepository,
         dispatchers: CoroutineDispatcherProvider,
+        rampStateManager: RampStateManager,
     ): GetCurrencyWarningsUseCase {
         return GetCurrencyWarningsUseCase(
             walletManagersFacade = walletManagersFacade,
             currenciesRepository = currenciesRepository,
             quotesRepository = quotesRepository,
             networksRepository = networksRepository,
-            marketCryptoCurrencyRepository = marketCryptoCurrencyRepository,
             currencyChecksRepository = currencyChecksRepository,
             swapRepository = swapRepository,
             showSwapPromoTokenUseCase = showSwapPromoTokenUseCase,
             promoRepository = promoRepository,
             stakingRepository = stakingRepository,
             dispatchers = dispatchers,
+            rampStateManager = rampStateManager,
         )
     }
 
@@ -215,7 +215,6 @@ internal object TokensDomainModule {
     fun provideGetCryptoCurrencyActionsUseCase(
         rampStateManager: RampStateManager,
         walletManagersFacade: WalletManagersFacade,
-        marketCryptoCurrencyRepository: MarketCryptoCurrencyRepository,
         currenciesRepository: CurrenciesRepository,
         quotesRepository: QuotesRepository,
         networksRepository: NetworksRepository,
@@ -225,7 +224,6 @@ internal object TokensDomainModule {
         return GetCryptoCurrencyActionsUseCase(
             rampManager = rampStateManager,
             walletManagersFacade = walletManagersFacade,
-            marketCryptoCurrencyRepository = marketCryptoCurrencyRepository,
             currenciesRepository = currenciesRepository,
             quotesRepository = quotesRepository,
             networksRepository = networksRepository,

app/src/main/java/com/tangem/tap/network/exchangeServices/DefaultRampManager.kt

@@ -1,25 +1,29 @@
 package com.tangem.tap.network.exchangeServices
 
+import com.tangem.datasource.api.express.models.TangemExpressValues.EMPTY_CONTRACT_ADDRESS_VALUE
+import com.tangem.datasource.exchangeservice.swap.SwapServiceLoader
 import com.tangem.domain.exchange.RampStateManager
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.tokens.model.CryptoCurrency
-import com.tangem.domain.tokens.repository.MarketCryptoCurrencyRepository
 import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.utils.Provider
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
 
-class DefaultRampManager(
+internal class DefaultRampManager(
     private val exchangeService: ExchangeService?,
     private val buyService: Provider<ExchangeService>,
     private val sellService: Provider<ExchangeService>,
-    private val marketsCryptoCurrencyRepository: MarketCryptoCurrencyRepository,
+    private val swapServiceLoader: SwapServiceLoader,
+    private val dispatchers: CoroutineDispatcherProvider,
 ) : RampStateManager {
 
     private val cryptoCurrencyConverter = CryptoCurrencyConverter()
 
     override fun availableForBuy(scanResponse: ScanResponse, cryptoCurrency: CryptoCurrency): Boolean {
         return exchangeService?.availableForBuy(
-            scanResponse,
+            scanResponse = scanResponse,
             currency = cryptoCurrencyConverter.convertBack(cryptoCurrency),
         ) ?: false
     }
@@ -31,14 +35,44 @@ class DefaultRampManager(
     }
 
     override suspend fun availableForSwap(userWalletId: UserWalletId, cryptoCurrency: CryptoCurrency): Boolean {
-        return marketsCryptoCurrencyRepository.isExchangeable(userWalletId, cryptoCurrency)
+        return getExchangeableFlag(userWalletId, cryptoCurrency) && !cryptoCurrency.isCustom
     }
 
     override fun getBuyInitializationStatus(): Flow<ExchangeServiceInitializationStatus> {
         return buyService.invoke().initializationStatus
     }
 
+    override suspend fun fetchBuyServiceData() {
+        withContext(dispatchers.io) {
+            buyService.invoke().update()
+        }
+    }
+
     override fun getSellInitializationStatus(): Flow<ExchangeServiceInitializationStatus> {
         return sellService.invoke().initializationStatus
     }
+
+    override suspend fun fetchSellServiceData() {
+        withContext(dispatchers.io) {
+            sellService.invoke().update()
+        }
+    }
+
+    override fun getSwapInitializationStatus(userWalletId: UserWalletId): Flow<ExchangeServiceInitializationStatus> {
+        return swapServiceLoader.getInitializationStatus(userWalletId)
+    }
+
+    private suspend fun getExchangeableFlag(userWalletId: UserWalletId, cryptoCurrency: CryptoCurrency): Boolean {
+        return withContext(dispatchers.io) {
+            val contractAddress = (cryptoCurrency as? CryptoCurrency.Token)?.contractAddress
+                ?: EMPTY_CONTRACT_ADDRESS_VALUE
+
+            val asset = swapServiceLoader.getInitializationStatus(userWalletId).value.getOrNull()?.find {
+                it.network == cryptoCurrency.network.backendId &&
+                    it.contractAddress.equals(contractAddress, ignoreCase = true)
+            }
+
+            asset?.exchangeAvailable ?: false
+        }
+    }
 }