Updated on 2026-08-14

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

@@ -2,44 +2,14 @@ package com.tangem.tap.network.exchangeServices
 
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.Token
-import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.blockchainsdk.utils.toBlockchain
-import com.tangem.data.common.currency.CryptoCurrencyFactory
 import com.tangem.domain.models.currency.CryptoCurrency
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.tap.common.extensions.inject
 import com.tangem.tap.domain.model.Currency
-import com.tangem.tap.proxy.redux.DaggerGraphState
-import com.tangem.tap.store
-import com.tangem.utils.converter.TwoWayConverter
+import com.tangem.utils.converter.Converter
 
-internal class CryptoCurrencyConverter(
-    private val excludedBlockchains: ExcludedBlockchains,
-) : TwoWayConverter<Currency, CryptoCurrency> {
+internal object CryptoCurrencyConverter : Converter<CryptoCurrency, Currency> {
 
-    private val cryptoCurrencyFactory by lazy { CryptoCurrencyFactory(excludedBlockchains) }
-
-    override fun convert(value: Currency): CryptoCurrency {
-        return when (value) {
-            is Currency.Blockchain -> requireNotNull(
-                cryptoCurrencyFactory.createCoin(
-                    blockchain = value.blockchain,
-                    extraDerivationPath = value.derivationPath,
-                    userWallet = getSelectedWallet(),
-                ),
-            )
-            is Currency.Token -> requireNotNull(
-                cryptoCurrencyFactory.createToken(
-                    sdkToken = value.token,
-                    blockchain = value.blockchain,
-                    extraDerivationPath = value.derivationPath,
-                    userWallet = getSelectedWallet(),
-                ),
-            )
-        }
-    }
-
-    override fun convertBack(value: CryptoCurrency): Currency {
+    override fun convert(value: CryptoCurrency): Currency {
         val blockchain = value.network.toBlockchain()
         if (blockchain == Blockchain.Unknown) error("CryptoCurrencyConverter convertBack Unknown blockchain")
         return when (value) {
@@ -60,15 +30,4 @@ internal class CryptoCurrencyConverter(
             )
         }
     }
-
-    fun getSelectedWallet(): UserWallet {
-        val userWalletListManager = store.inject(DaggerGraphState::generalUserWalletsListManager)
-        val userWalletsListRepository = store.inject(DaggerGraphState::userWalletsListRepository)
-        val hotWalletFeatureToggles = store.inject(DaggerGraphState::hotWalletFeatureToggles)
-        return if (hotWalletFeatureToggles.isHotWalletEnabled) {
-            requireNotNull(userWalletsListRepository.selectedUserWallet.value)
-        } else {
-            requireNotNull(userWalletListManager.selectedUserWalletSync)
-        }
-    }
 }

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

@@ -5,13 +5,11 @@ import arrow.core.raise.catch
 import arrow.core.raise.either
 import arrow.core.raise.ensure
 import arrow.core.right
-import com.tangem.blockchainsdk.utils.ExcludedBlockchains
-import com.tangem.datasource.api.express.models.TangemExpressValues.EMPTY_CONTRACT_ADDRESS_VALUE
-import com.tangem.datasource.api.express.models.response.Asset
-import com.tangem.datasource.exchangeservice.swap.ExpressServiceLoader
 import com.tangem.domain.core.lce.Lce
 import com.tangem.domain.exchange.ExpressAvailabilityState
 import com.tangem.domain.exchange.RampStateManager
+import com.tangem.domain.express.ExpressServiceFetcher
+import com.tangem.domain.express.models.ExpressAsset
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.currency.CryptoCurrencyStatus
 import com.tangem.domain.models.wallet.UserWallet
@@ -26,17 +24,13 @@ import com.tangem.utils.isNullOrZero
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.firstOrNull
 
-@Suppress("LongParameterList")
 internal class DefaultRampManager(
-    private val sellService: Provider<ExchangeService>,
-    private val expressServiceLoader: ExpressServiceLoader,
+    private val sellService: Provider<SellService>,
+    private val expressServiceFetcher: ExpressServiceFetcher,
     private val currenciesRepository: CurrenciesRepository,
     private val dispatchers: CoroutineDispatcherProvider,
-    excludedBlockchains: ExcludedBlockchains,
 ) : RampStateManager {
 
-    private val cryptoCurrencyConverter = CryptoCurrencyConverter(excludedBlockchains)
-
     override suspend fun availableForBuy(
         userWallet: UserWallet,
         cryptoCurrency: CryptoCurrency,
@@ -56,7 +50,7 @@ internal class DefaultRampManager(
         return either {
             val isSellSupportedByService = catch(
                 block = {
-                    val serviceCurrency = cryptoCurrencyConverter.convertBack(status.currency)
+                    val serviceCurrency = CryptoCurrencyConverter.convert(status.currency)
 
                     sellService().availableForSell(currency = serviceCurrency)
                 },
@@ -96,7 +90,7 @@ internal class DefaultRampManager(
         return availabilityState.toReason(cryptoCurrency.name)
     }
 
-    override fun getSellInitializationStatus(): Flow<ExchangeServiceInitializationStatus> {
+    override fun getSellInitializationStatus(): Flow<SellServiceInitializationStatus> {
         return sellService.invoke().initializationStatus
     }
 
@@ -106,8 +100,8 @@ internal class DefaultRampManager(
         }
     }
 
-    override fun getExpressInitializationStatus(userWalletId: UserWalletId): Flow<ExchangeServiceInitializationStatus> {
-        return expressServiceLoader.getInitializationStatus(userWalletId)
+    override fun getExpressInitializationStatus(userWalletId: UserWalletId): Flow<SellServiceInitializationStatus> {
+        return expressServiceFetcher.getInitializationStatus(userWalletId)
     }
 
     override suspend fun getSendUnavailabilityReason(
@@ -151,14 +145,14 @@ internal class DefaultRampManager(
         userWalletId: UserWalletId,
         cryptoCurrency: CryptoCurrency,
     ): ExpressAvailabilityState {
-        val asset = expressServiceLoader.getInitializationStatus(userWalletId).firstOrNull()
+        val asset = expressServiceFetcher.getInitializationStatus(userWalletId).firstOrNull()
             ?: return ExpressAvailabilityState.Loading
         return when (asset) {
             is Lce.Error -> ExpressAvailabilityState.Error
             is Lce.Loading -> ExpressAvailabilityState.Loading
             is Lce.Content -> {
-                val foundAsset = asset.getOrNull()?.find { cryptoCurrency.findAssetPredicate(it) }
-                foundAsset?.exchangeAvailable?.toSwapAvailabilityState()
+                val foundAsset = asset.getOrNull()?.find { cryptoCurrency.findAssetPredicate(assetId = it.id) }
+                foundAsset?.isExchangeAvailable?.toSwapAvailabilityState()
                     ?: ExpressAvailabilityState.AssetNotFound
             }
         }
@@ -168,15 +162,15 @@ internal class DefaultRampManager(
         userWalletId: UserWalletId,
         cryptoCurrency: CryptoCurrency,
     ): ExpressAvailabilityState {
-        val asset = expressServiceLoader.getInitializationStatus(userWalletId).firstOrNull()
+        val asset = expressServiceFetcher.getInitializationStatus(userWalletId).firstOrNull()
             ?: return ExpressAvailabilityState.Loading
 
         return when (asset) {
             is Lce.Error -> ExpressAvailabilityState.Error
             is Lce.Loading -> ExpressAvailabilityState.Loading
             is Lce.Content -> {
-                val foundAsset = asset.getOrNull()?.find { cryptoCurrency.findAssetPredicate(it) }
-                foundAsset?.onrampAvailable?.toOnrampAvailabilityState()
+                val foundAsset = asset.getOrNull()?.find { cryptoCurrency.findAssetPredicate(assetId = it.id) }
+                foundAsset?.isOnrampAvailable?.toOnrampAvailabilityState()
                     ?: ExpressAvailabilityState.AssetNotFound
             }
         }
@@ -211,8 +205,13 @@ internal class DefaultRampManager(
         }
     }
 
-    private fun CryptoCurrency.findAssetPredicate(asset: Asset): Boolean {
-        val contractAddress = (this as? CryptoCurrency.Token)?.contractAddress ?: EMPTY_CONTRACT_ADDRESS_VALUE
-        return asset.network == network.backendId && asset.contractAddress.equals(contractAddress, ignoreCase = true)
+    private fun CryptoCurrency.findAssetPredicate(assetId: ExpressAsset.ID): Boolean {
+        val currencyAssedId = ExpressAsset.ID(
+            networkId = this.network.backendId,
+            contractAddress = (this as? CryptoCurrency.Token)?.contractAddress,
+        )
+
+        return assetId.networkId == currencyAssedId.networkId &&
+            assetId.contractAddress.equals(currencyAssedId.contractAddress, ignoreCase = true)
     }
 }

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

@@ -5,11 +5,11 @@ import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.tap.domain.model.Currency
 import kotlinx.coroutines.flow.StateFlow
 
-typealias ExchangeServiceInitializationStatus = Lce<Throwable, Any>
+typealias SellServiceInitializationStatus = Lce<Throwable, Any>
 
-interface ExchangeService {
+interface SellService {
 
-    val initializationStatus: StateFlow<ExchangeServiceInitializationStatus>
+    val initializationStatus: StateFlow<SellServiceInitializationStatus>
 
     suspend fun update()
 

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

@@ -1,54 +0,0 @@
-package com.tangem.tap.network.exchangeServices.moonpay
-
-import com.squareup.moshi.Json
-import com.squareup.moshi.JsonClass
-import retrofit2.http.GET
-import retrofit2.http.Query
-
-interface MoonPayApi {
-
-    @GET(MOOONPAY_IP_ADDRESS_REQUEST_URL)
-    suspend fun getUserStatus(@Query("apiKey") moonPayApiKey: String): MoonPayUserStatus
-
-    @GET(MOOONPAY_CURRENCIES_REQUEST_URL)
-    suspend fun getCurrencies(@Query("apiKey") moonPayApiKey: String): List<MoonPayCurrencies>
-
-    companion object {
-        const val MOOONPAY_BASE_URL = "https://api.moonpay.com/"
-        const val MOOONPAY_IP_ADDRESS_REQUEST_URL = "v4/ip_address/"
-        const val MOOONPAY_CURRENCIES_REQUEST_URL = "v3/currencies/"
-    }
-}
-
-@JsonClass(generateAdapter = true)
-data class MoonPayUserStatus(
-    @Json(name = "isBuyAllowed")
-    val isBuyAllowed: Boolean,
-    @Json(name = "isSellAllowed")
-    val isSellAllowed: Boolean,
-    @Json(name = "isAllowed")
-    val isMoonpayAllowed: Boolean,
-    @Json(name = "alpha3")
-    val countryCode: String,
-    @Json(name = "state")
-    val stateCode: String,
-)
-
-@Suppress("BooleanPropertyNaming")
-@JsonClass(generateAdapter = true)
-data class MoonPayCurrencies(
-    @Json(name = "type") val type: String,
-    @Json(name = "code") val code: String,
-    @Json(name = "supportsLiveMode") val supportsLiveMode: Boolean = false,
-    @Json(name = "isSuspended") val isSuspended: Boolean = true,
-    @Json(name = "isSupportedInUS") val isSupportedInUS: Boolean = false,
-    @Json(name = "isSellSupported") val isSellSupported: Boolean = false,
-    @Json(name = "notAllowedUSStates") val notAllowedUSStates: List<String> = emptyList(),
-    @Json(name = "metadata") val metadata: MoonPayCurrenciesMetadata? = null,
-)
-
-@JsonClass(generateAdapter = true)
-data class MoonPayCurrenciesMetadata(
-    @Json(name = "contractAddress") val contractAddress: String?,
-    @Json(name = "networkCode") val networkCode: String?,
-)

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

@@ -5,7 +5,9 @@ import android.util.Base64
 import com.tangem.blockchainsdk.utils.toBlockchain
 import com.tangem.common.services.Result
 import com.tangem.common.services.performRequest
-import com.tangem.datasource.api.common.createRetrofitInstance
+import com.tangem.datasource.api.moonpay.MoonPayApi
+import com.tangem.datasource.api.moonpay.MoonPayCurrencies
+import com.tangem.datasource.api.moonpay.MoonPayUserStatus
 import com.tangem.domain.card.common.TapWorkarounds.isStart2Coin
 import com.tangem.domain.common.extensions.withIOContext
 import com.tangem.domain.core.utils.lceContent
@@ -14,9 +16,10 @@ import com.tangem.domain.core.utils.lceLoading
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.tap.domain.model.Currency
-import com.tangem.tap.network.exchangeServices.ExchangeService
-import com.tangem.tap.network.exchangeServices.ExchangeServiceInitializationStatus
+import com.tangem.tap.network.exchangeServices.SellService
+import com.tangem.tap.network.exchangeServices.SellServiceInitializationStatus
 import com.tangem.tap.network.exchangeServices.moonpay.models.MoonPayAvailableCurrency
+import com.tangem.utils.Provider
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import timber.log.Timber
@@ -24,25 +27,18 @@ import javax.crypto.Mac
 import javax.crypto.spec.SecretKeySpec
 
 class MoonPayService(
-    private val apiKey: String,
-    private val secretKey: String,
-    private val isLogEnabled: Boolean,
+    private val api: MoonPayApi,
+    private val apiKeyProvider: Provider<String>,
+    private val secretKeyProvider: Provider<String>,
     private val userWalletProvider: () -> UserWallet?,
-) : ExchangeService {
+) : SellService {
 
-    override val initializationStatus: StateFlow<ExchangeServiceInitializationStatus>
+    override val initializationStatus: StateFlow<SellServiceInitializationStatus>
         get() = _initializationStatus
 
-    private val _initializationStatus: MutableStateFlow<ExchangeServiceInitializationStatus> =
+    private val _initializationStatus: MutableStateFlow<SellServiceInitializationStatus> =
         MutableStateFlow(value = lceLoading())
 
-    private val api: MoonPayApi by lazy {
-        createRetrofitInstance(
-            baseUrl = MoonPayApi.MOOONPAY_BASE_URL,
-            logEnabled = isLogEnabled,
-        ).create(MoonPayApi::class.java)
-    }
-
     private var status: MoonPayStatus? = null
 
     override suspend fun update() {
@@ -51,7 +47,7 @@ class MoonPayService(
             _initializationStatus.value = lceLoading()
 
             performRequest {
-                val userStatus = when (val result = performRequest { api.getUserStatus(apiKey) }) {
+                val userStatus = when (val result = performRequest { api.getUserStatus(apiKeyProvider()) }) {
                     is Result.Failure -> {
                         Timber.e("Failed to load user status", result.error)
                         _initializationStatus.value = result.error.lceError()
@@ -60,7 +56,7 @@ class MoonPayService(
                     is Result.Success -> result.data
                 }
 
-                val currencies = when (val result = performRequest { api.getCurrencies(apiKey) }) {
+                val currencies = when (val result = performRequest { api.getCurrencies(apiKeyProvider()) }) {
                     is Result.Failure -> {
                         Timber.e("Failed to load currencies", result.error)
                         _initializationStatus.value = result.error.lceError()
@@ -78,7 +74,7 @@ class MoonPayService(
                         MoonPayAvailableCurrency(
                             currencyCode = currency.code,
                             networkCode = currency.metadata?.networkCode ?: return@mapNotNull null,
-                            contractAddress = currency.metadata.contractAddress,
+                            contractAddress = currency.metadata?.contractAddress,
                         )
                     }
 
@@ -167,7 +163,7 @@ class MoonPayService(
         val uri = Uri.Builder()
             .scheme(SCHEME)
             .authority(URL_SELL)
-            .appendQueryParameter("apiKey", apiKey)
+            .appendQueryParameter("apiKey", apiKeyProvider())
             .appendQueryParameter("baseCurrencyCode", moonpayCurrency.currencyCode.uppercase())
             .appendQueryParameter("refundWalletAddress", walletAddress)
             .appendQueryParameter("redirectURL", "tangem://redirect_sell?currency_id=${cryptoCurrency.id.value}")
@@ -191,7 +187,7 @@ class MoonPayService(
 
     private fun createSignature(data: String): String {
         val sha256Hmac = Mac.getInstance("HmacSHA256")
-        val secretKey = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
+        val secretKey = SecretKeySpec(secretKeyProvider().toByteArray(), "HmacSHA256")
         sha256Hmac.init(secretKey)
         val sha256encoded = sha256Hmac.doFinal("?$data".toByteArray())
         return Base64.encodeToString(sha256encoded, Base64.NO_WRAP)

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

@@ -160,6 +160,6 @@ internal val Blockchain.moonPaySupportedCurrency: MoonPaySupportedCurrency?
         Pepecoin, PepecoinTestnet -> null
         Hyperliquid, HyperliquidTestnet -> null
         Quai, QuaiTestnet -> null
-        // Linea, LineaTestnet -> null
-        // ArbitrumNova -> null
+        Linea, LineaTestnet -> null
+        ArbitrumNova -> null
     }