Updated on 2026-08-14

app/src/main/java/com/tangem/tap/common/redux/global/GlobalMidlleware.kt

@@ -15,6 +15,7 @@ import com.tangem.tap.currenciesRepository
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessagesManager
 import com.tangem.tap.features.send.redux.SendAction
 import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.network.exchangeServices.CardExchangeRules
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
 import com.tangem.tap.network.exchangeServices.mercuryo.MercuryoApi
 import com.tangem.tap.network.exchangeServices.mercuryo.MercuryoService
@@ -23,11 +24,11 @@ import com.tangem.tap.preferencesStorage
 import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.tap.tangemSdkManager
-import java.util.Locale
 import kotlinx.coroutines.launch
 import org.rekotlin.Action
 import org.rekotlin.DispatchFunction
 import org.rekotlin.Middleware
+import java.util.*
 
 class GlobalMiddleware {
     companion object {
@@ -62,9 +63,11 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
             }
         }
         is GlobalAction.RestoreAppCurrency -> {
-            store.dispatch(GlobalAction.RestoreAppCurrency.Success(
-                preferencesStorage.fiatCurrenciesPrefStorage.getAppCurrency()
-            ))
+            store.dispatch(
+                GlobalAction.RestoreAppCurrency.Success(
+                    preferencesStorage.fiatCurrenciesPrefStorage.getAppCurrency(),
+                ),
+            )
         }
         is GlobalAction.HideWarningMessage -> {
             store.state.globalState.warningManager?.let {
@@ -107,7 +110,13 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
                         secret = mercuryoSecret,
                     )
                     val sellService = MoonPayService(moonPayKey, moonPaySecretKey)
-                    val exchangeManager = CurrencyExchangeManager(buyService, sellService)
+                    val cardProvider = { store.state.globalState.scanResponse?.card }
+
+                    val exchangeManager = CurrencyExchangeManager(
+                        buyService = buyService,
+                        sellService = sellService,
+                        primaryRules = CardExchangeRules(cardProvider),
+                    )
                     store.dispatchOnMain(GlobalAction.ExchangeManager.Init.Success(exchangeManager))
                     store.dispatchOnMain(GlobalAction.ExchangeManager.Update)
                 }
@@ -127,7 +136,7 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
                     store.state.globalState.analyticsHandlers,
                     currenciesRepository,
                     action.additionalBlockchainsToDerive,
-                    action.messageResId
+                    action.messageResId,
                 )
                 withMainContext {
                     store.dispatch(GlobalAction.ScanFailsCounter.ChooseBehavior(result))
@@ -150,15 +159,15 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
                     is Result.Success -> {
                         store.dispatchOnMain(
                             GlobalAction.FetchUserCountry.Success(
-                                countryCode = result.data.code.lowercase()
-                            )
+                                countryCode = result.data.code.lowercase(),
+                            ),
                         )
                     }
                     is Result.Failure -> {
                         store.dispatchOnMain(
                             GlobalAction.FetchUserCountry.Success(
-                                countryCode = Locale.getDefault().country.lowercase()
-                            )
+                                countryCode = Locale.getDefault().country.lowercase(),
+                            ),
                         )
                     }
                 }

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

@@ -0,0 +1,54 @@
+package com.tangem.tap.network.exchangeServices
+
+import com.tangem.common.card.Card
+import com.tangem.domain.common.TapWorkarounds.isStart2Coin
+import com.tangem.tap.features.demo.isDemoCard
+import com.tangem.tap.features.wallet.models.Currency
+
+/**
+[REDACTED_AUTHOR]
+ */
+class CardExchangeRules(
+    val cardProvider: () -> Card?,
+) : ExchangeRules {
+
+    override fun isBuyAllowed(): Boolean {
+        val card = cardProvider() ?: return false
+
+        return when {
+            card.isDemoCard() -> false
+            card.isStart2Coin -> false
+            else -> true
+        }
+    }
+
+    override fun isSellAllowed(): Boolean {
+        val card = cardProvider() ?: return false
+
+        return when {
+            card.isDemoCard() -> false
+            card.isStart2Coin -> false
+            else -> true
+        }
+    }
+
+    override fun availableForBuy(currency: Currency): Boolean {
+        val card = cardProvider() ?: return false
+
+        return when {
+            card.isDemoCard() -> false
+            card.isStart2Coin -> false
+            else -> true
+        }
+    }
+
+    override fun availableForSell(currency: Currency): Boolean {
+        val card = cardProvider() ?: return false
+
+        return when {
+            card.isDemoCard() -> false
+            card.isStart2Coin -> false
+            else -> true
+        }
+    }
+}

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

@@ -23,6 +23,7 @@ import java.math.BigDecimal
 class CurrencyExchangeManager(
     private val buyService: ExchangeService,
     private val sellService: ExchangeService,
+    private val primaryRules: ExchangeRules,
 ) : ExchangeService, ExchangeUrlBuilder {
 
     override suspend fun update() {
@@ -30,10 +31,16 @@ class CurrencyExchangeManager(
         sellService.update()
     }
 
-    override fun isBuyAllowed(): Boolean = buyService.isBuyAllowed()
-    override fun isSellAllowed(): Boolean = sellService.isSellAllowed()
-    override fun availableForBuy(currency: Currency): Boolean = buyService.availableForBuy(currency)
-    override fun availableForSell(currency: Currency): Boolean = sellService.availableForSell(currency)
+    override fun isBuyAllowed(): Boolean = primaryRules.isBuyAllowed() && buyService.isBuyAllowed()
+    override fun isSellAllowed(): Boolean = primaryRules.isSellAllowed() && sellService.isSellAllowed()
+
+    override fun availableForBuy(currency: Currency): Boolean {
+        return primaryRules.availableForBuy(currency) && buyService.availableForBuy(currency)
+    }
+
+    override fun availableForSell(currency: Currency): Boolean {
+        return primaryRules.availableForSell(currency) && sellService.availableForSell(currency)
+    }
 
     override fun getUrl(
         action: Action,

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

@@ -3,8 +3,11 @@ package com.tangem.tap.network.exchangeServices
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.tap.features.wallet.models.Currency
 
-interface ExchangeService {
+interface ExchangeService: ExchangeRules {
     suspend fun update()
+}
+
+interface ExchangeRules {
     fun isBuyAllowed(): Boolean
     fun isSellAllowed(): Boolean
     fun availableForBuy(currency: Currency):Boolean