Updated on 2026-08-14

app/src/main/java/com/tangem/tap/common/DialogManager.kt

@@ -133,6 +133,8 @@ class DialogManager : StoreSubscriber<GlobalState> {
                 primaryButtonRes = state.dialog.primaryButtonRes,
                 primaryButtonAction = state.dialog.onOk
             )
+            is WalletDialog.RussianCardholdersWarningDialog ->
+                RussianCardholdersWarningBottomSheetDialog(context)
             is DetailsDialog.ConfirmDisablingSaving -> {
                 val messageRes = when (state.dialog.setting) {
                     PrivacySetting.SAVE_CARDS -> R.string.security_and_privacy_save_card_disable_warning

app/src/main/java/com/tangem/tap/common/extensions/WalletManager.kt

@@ -49,11 +49,11 @@ suspend fun WalletManager.safeUpdate(): Result<Wallet> = try {
 
 fun WalletManager?.getToUpUrl(): String? {
     val globalState = store.state.globalState
-    val currencyExchangeManager = globalState.currencyExchangeManager ?: return null
+    val exchangeManager = globalState.exchangeManager ?: return null
     val wallet = this?.wallet ?: return null
 
     val defaultAddress = wallet.address
-    return currencyExchangeManager.getUrl(
+    return exchangeManager.getUrl(
         action = CurrencyExchangeManager.Action.Buy,
         blockchain = wallet.blockchain,
         cryptoCurrencyName = wallet.blockchain.currency,

app/src/main/java/com/tangem/tap/common/feedback/AdditionalFeedbackInfo.kt

@@ -0,0 +1,127 @@
+package com.tangem.tap.common.feedback
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import com.tangem.blockchain.common.Amount
+import com.tangem.blockchain.common.AmountType
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.Token
+import com.tangem.blockchain.common.Wallet
+import com.tangem.blockchain.common.WalletManager
+import com.tangem.domain.common.ScanResponse
+import com.tangem.tap.common.extensions.stripZeroPlainString
+
+class AdditionalFeedbackInfo {
+    class EmailWalletInfo(
+        var blockchain: Blockchain = Blockchain.Unknown,
+        var address: String = "",
+        var explorerLink: String = "",
+        var host: String = "",
+        var derivationPath: String = "",
+    )
+
+    var appVersion: String = ""
+
+    // card
+    var cardId: String = ""
+    var cardFirmwareVersion: String = ""
+    var cardIssuer: String = ""
+    var cardBlockchain: String = ""
+
+    // wallets
+    internal val walletsInfo = mutableListOf<EmailWalletInfo>()
+    internal val tokens = mutableMapOf<Blockchain, Collection<Token>>()
+    internal var onSendErrorWalletInfo: EmailWalletInfo? = null
+    var signedHashesCount: String = ""
+
+    // device
+    var phoneModel: String = Build.MODEL
+    var osVersion: String = Build.VERSION.SDK_INT.toString()
+
+    // send error
+    var destinationAddress: String = ""
+    var amount: String = ""
+    var fee: String = ""
+    var token: String = ""
+
+    fun setAppVersion(context: Context) {
+        try {
+            val pInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+            appVersion = pInfo.versionName
+        } catch (e: PackageManager.NameNotFoundException) {
+            e.printStackTrace()
+        }
+    }
+
+    fun setCardInfo(data: ScanResponse) {
+        cardId = data.card.cardId
+        cardBlockchain = data.walletData?.blockchain ?: ""
+        cardFirmwareVersion = data.card.firmwareVersion.stringValue
+        cardIssuer = data.card.issuer.name
+        signedHashesCount = data.card.wallets
+            .joinToString("; ") { "${it.curve.curve} - ${it.totalSignedHashes}" }
+    }
+
+    fun setWalletsInfo(walletManagers: List<WalletManager>) {
+        walletsInfo.clear()
+        tokens.clear()
+        walletManagers.forEach { manager ->
+            walletsInfo.add(
+                EmailWalletInfo(
+                    blockchain = manager.wallet.blockchain,
+                    address = getAddress(manager.wallet),
+                    explorerLink = getExploreUri(manager.wallet),
+                    host = manager.currentHost,
+                    derivationPath = manager.wallet.publicKey.derivationPath?.rawPath ?: ""
+                )
+            )
+            if (manager.cardTokens.isNotEmpty()) {
+                tokens[manager.wallet.blockchain] = manager.cardTokens
+            }
+        }
+    }
+
+    fun updateOnSendError(
+        wallet: Wallet,
+        host: String,
+        amountToSend: Amount,
+        feeAmount: Amount,
+        destinationAddress: String,
+    ) {
+        onSendErrorWalletInfo = EmailWalletInfo(
+            blockchain = wallet.blockchain,
+            address = getAddress(wallet),
+            explorerLink = getExploreUri(wallet),
+            host = host,
+            derivationPath = wallet.publicKey.derivationPath?.rawPath ?: ""
+        )
+
+        this.destinationAddress = destinationAddress
+        amount = amountToSend.value?.stripZeroPlainString() ?: "0"
+        fee = feeAmount.value?.stripZeroPlainString() ?: "0"
+        token = if (amountToSend.type is AmountType.Token) amountToSend.currencySymbol else ""
+    }
+
+    private fun getAddress(wallet: Wallet): String {
+        return if (wallet.addresses.size == 1) {
+            wallet.address
+        } else {
+            val addresses = wallet.addresses.joinToString(", ") {
+                "${it.type.javaClass.simpleName} - ${it.value}"
+            }
+            "Multiple address: $addresses"
+        }
+    }
+
+    private fun getExploreUri(wallet: Wallet): String {
+        return if (wallet.addresses.size == 1) {
+            wallet.getExploreUrl(wallet.address)
+        } else {
+            val links = wallet.addresses.joinToString(", ") {
+                "${it.type.javaClass.simpleName} - ${wallet.getExploreUrl(it.value)}"
+            }
+            "Multiple explorers links: $links"
+        }
+    }
+}

app/src/main/java/com/tangem/tap/common/feedback/FeedbackData.kt

@@ -0,0 +1,108 @@
+package com.tangem.tap.common.feedback
+
+import android.content.Context
+import com.tangem.domain.common.TapWorkarounds
+import com.tangem.wallet.R
+
+interface FeedbackData {
+    val subjectResId: Int
+    val mainMessageResId: Int
+
+    fun getDataCollectionMessageResId(): Int = R.string.feedback_data_collection_message
+
+    fun prepare(infoHolder: AdditionalFeedbackInfo) {}
+
+    fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String
+
+    fun joinTogether(context: Context, infoHolder: AdditionalFeedbackInfo): String {
+        return StringBuilder().apply {
+            append(context.getString(mainMessageResId))
+            appendLine(3)
+            append(context.getString(getDataCollectionMessageResId()))
+            appendLine()
+            append(createOptionalMessage(infoHolder))
+        }.toString()
+    }
+}
+
+class RateCanBeBetterEmail : FeedbackData {
+    override val subjectResId: Int = R.string.feedback_subject_rate_negative
+    override val mainMessageResId: Int = R.string.feedback_preface_rate_negative
+
+    override fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String = FeedbackDataBuilder(infoHolder)
+        .appendCardInfo()
+        .appendLine()
+        .appendPhoneInfo()
+        .build()
+}
+
+class ScanFailsEmail : FeedbackData {
+
+    override val subjectResId: Int = R.string.feedback_subject_scan_failed
+    override val mainMessageResId: Int = R.string.feedback_preface_scan_failed
+
+    override fun joinTogether(context: Context, infoHolder: AdditionalFeedbackInfo): String = StringBuilder().apply {
+        append(context.getString(mainMessageResId))
+        appendLine(4)
+        append(createOptionalMessage(infoHolder))
+    }.toString()
+
+    override fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String = FeedbackDataBuilder(infoHolder)
+        .appendPhoneInfo()
+        .build()
+}
+
+class SendTransactionFailedEmail(
+    val error: String
+) : FeedbackData {
+
+    override val subjectResId: Int = R.string.feedback_subject_tx_failed
+    override val mainMessageResId: Int = R.string.feedback_preface_tx_failed
+
+    override fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String = FeedbackDataBuilder(infoHolder)
+        .appendCardInfo()
+        .appendDelimiter()
+        .appendTxFailedBlockchainInfo(error)
+        .appendLine()
+        .appendPhoneInfo()
+        .build()
+}
+
+class FeedbackEmail : FeedbackData {
+    override val subjectResId: Int
+        get() = if (isS2CCard) s2cSubject else tangemSubject
+    override val mainMessageResId: Int
+        get() = if (isS2CCard) s2cMainMessage else tangemMainMessage
+
+    private val tangemSubject: Int = R.string.feedback_subject_support_tangem
+    private val tangemMainMessage: Int = R.string.feedback_preface_support
+
+    private val s2cSubject: Int = R.string.feedback_subject_support
+    private val s2cMainMessage: Int = R.string.feedback_preface_support
+
+    private var isS2CCard = false
+
+    override fun prepare(infoHolder: AdditionalFeedbackInfo) {
+        isS2CCard = TapWorkarounds.isStart2CoinIssuer(infoHolder.cardIssuer)
+    }
+
+    override fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String = FeedbackDataBuilder(infoHolder)
+        .appendCardInfo()
+        .appendWalletsInfo()
+        .appendLine()
+        .appendPhoneInfo()
+        .build()
+}
+
+class SupportInfo : FeedbackData {
+    override val subjectResId: Int = R.string.details_ask_a_question
+    override val mainMessageResId: Int = R.string.details_ask_a_question
+
+    override fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String {
+        return FeedbackDataBuilder(infoHolder)
+            .appendCardInfo()
+            .appendDelimiter()
+            .appendPhoneInfo()
+            .build()
+    }
+}

app/src/main/java/com/tangem/tap/common/feedback/FeedbackDataBuilder.kt

@@ -0,0 +1,81 @@
+package com.tangem.tap.common.feedback
+
+class FeedbackDataBuilder(
+    private val infoHolder: AdditionalFeedbackInfo
+) {
+    val builder = StringBuilder()
+
+    fun appendDelimiter(): FeedbackDataBuilder {
+        builder.appendDelimiter()
+        return this
+    }
+
+    fun appendLine(count: Int = 1): FeedbackDataBuilder {
+        builder.appendLine(count)
+        return this
+    }
+
+    fun appendCardInfo(): FeedbackDataBuilder {
+        builder.appendKeyValue("Card ID", infoHolder.cardId)
+        builder.appendKeyValue("Firmware version", infoHolder.cardFirmwareVersion)
+        builder.appendKeyValue("Card Blockchain", infoHolder.cardBlockchain)
+        builder.appendKeyValue("Signed hashes", infoHolder.signedHashesCount)
+        return this
+    }
+
+    fun appendWalletsInfo(): FeedbackDataBuilder {
+        infoHolder.walletsInfo.forEach {
+            builder.appendDelimiter()
+            builder.appendKeyValue("Blockchain", it.blockchain.fullName)
+            builder.appendKeyValue("Host", it.host)
+            builder.appendKeyValue("Wallet address", it.address)
+            builder.appendKeyValue("Derivation path", it.derivationPath)
+            builder.appendKeyValue("Explorer link", it.explorerLink)
+
+            infoHolder.tokens[it.blockchain]?.let { tokens ->
+                builder.append("Tokens:")
+                appendLine()
+                tokens.forEach { token ->
+                    builder.appendKeyValue("Name", token.name)
+                    builder.appendKeyValue("ID", token.id ?: "[custom token]")
+                    builder.appendKeyValue("Contract address", token.contractAddress)
+                }
+            }
+        }
+        return this
+    }
+
+    fun appendTxFailedBlockchainInfo(error: String): FeedbackDataBuilder {
+        val walletInfo = infoHolder.onSendErrorWalletInfo ?: AdditionalFeedbackInfo.EmailWalletInfo()
+        builder.appendKeyValue("Blockchain", walletInfo.blockchain.fullName)
+        builder.appendKeyValue("Derivation path", walletInfo.derivationPath)
+        builder.appendKeyValue("Host", walletInfo.host)
+        builder.appendKeyValue("Token", infoHolder.token)
+        builder.appendKeyValue("Error", error)
+        builder.appendDelimiter()
+        builder.appendKeyValue("Source address", walletInfo.address)
+        builder.appendKeyValue("Destination address", infoHolder.destinationAddress)
+        builder.appendKeyValue("Amount", infoHolder.amount)
+        builder.appendKeyValue("Fee", infoHolder.fee)
+        return this
+    }
+
+    fun appendPhoneInfo(): FeedbackDataBuilder {
+        builder.appendKeyValue("Phone model", infoHolder.phoneModel)
+        builder.appendKeyValue("OS version", infoHolder.osVersion)
+        builder.appendKeyValue("App version", infoHolder.appVersion)
+        return this
+    }
+
+    fun build(): String = builder.toString()
+}
+
+private fun StringBuilder.appendKeyValue(key: String, value: String): StringBuilder {
+    return if (value.isNotBlank()) this.append("$key: $value\n") else this
+}
+
+private fun StringBuilder.appendDelimiter(): StringBuilder = append("----------\n")
+
+private fun StringBuilder.appendLine(count: Int = 1): StringBuilder {
+    return append(List(count) { "\n" }.joinToString(separator = ""))
+}

app/src/main/java/com/tangem/tap/common/feedback/FeedbackManager.kt

@@ -0,0 +1,115 @@
+package com.tangem.tap.common.feedback
+
+import android.content.Context
+import com.tangem.domain.common.TapWorkarounds
+import com.tangem.tap.common.extensions.sendEmail
+import com.tangem.tap.common.log.TangemLogCollector
+import com.tangem.tap.common.zendesk.ZendeskConfig
+import com.tangem.tap.foregroundActivityObserver
+import com.tangem.tap.withForegroundActivity
+import java.io.File
+import java.io.FileWriter
+import java.io.StringWriter
+import timber.log.Timber
+import zendesk.configurations.Configuration
+import zendesk.core.AnonymousIdentity
+import zendesk.core.Zendesk
+import zendesk.support.Support
+import zendesk.support.request.RequestConfiguration
+import zendesk.support.requestlist.RequestListActivity
+import zendesk.support.requestlist.RequestListConfiguration
+
+/**
+[REDACTED_AUTHOR]
+ */
+class FeedbackManager(
+    val infoHolder: AdditionalFeedbackInfo,
+    private val logCollector: TangemLogCollector,
+) {
+    fun initChat(
+        context: Context,
+        zendeskConfig: ZendeskConfig,
+    ) {
+        Zendesk.INSTANCE.init(
+            /* context = */ context,
+            /* zendeskUrl = */ zendeskConfig.url,
+            /* applicationId = */ zendeskConfig.appId,
+            /* oauthClientId = */ zendeskConfig.clientId,
+        )
+        Support.INSTANCE.init(Zendesk.INSTANCE)
+        Zendesk.INSTANCE.setIdentity(AnonymousIdentity())
+    }
+
+    fun sendEmail(feedbackData: FeedbackData, onFail: ((Exception) -> Unit)? = null) {
+        feedbackData.prepare(infoHolder)
+        foregroundActivityObserver.withForegroundActivity { activity ->
+            val fileLog = if (feedbackData is ScanFailsEmail) createLogFile(activity) else null
+            activity.sendEmail(
+                email = getSupportEmail(),
+                subject = activity.getString(feedbackData.subjectResId),
+                message = feedbackData.joinTogether(activity, infoHolder),
+                file = fileLog,
+                onFail = onFail
+            )
+        }
+    }
+
+    fun openChat(feedbackData: FeedbackData) {
+        feedbackData.prepare(infoHolder)
+        foregroundActivityObserver.withForegroundActivity { activity ->
+            RequestListActivity.builder()
+                .show(
+                    /* context = */ activity,
+                    /* configurations = */ buildConfigs(activity, feedbackData)
+                )
+        }
+    }
+
+    private fun createLogFile(context: Context): File? {
+        return try {
+            val file = File(context.filesDir, "logs.txt")
+            file.delete()
+            file.createNewFile()
+
+            val stringWriter = StringWriter()
+            logCollector.getLogs().forEach { stringWriter.append(it) }
+            val fileWriter = FileWriter(file)
+            fileWriter.write(stringWriter.toString())
+            fileWriter.close()
+            logCollector.clearLogs()
+            file
+        } catch (ex: Exception) {
+            Timber.e(ex, "Can't create the logs file")
+            null
+        }
+    }
+
+    private fun buildConfigs(
+        context: Context,
+        feedbackData: FeedbackData,
+    ): List<Configuration> {
+        return listOf(
+            // Request configuration
+            RequestConfiguration.Builder()
+                .withRequestSubject(context.getString(feedbackData.subjectResId))
+                .config(),
+            // Request list configuration
+            RequestListConfiguration.Builder()
+                .withContactUsButtonVisible(true)
+                .config(),
+        )
+    }
+
+    private fun getSupportEmail(): String {
+        return if (TapWorkarounds.isStart2CoinIssuer(infoHolder.cardIssuer)) {
+            S2C_SUPPORT_EMAIL
+        } else {
+            DEFAULT_SUPPORT_EMAIL
+        }
+    }
+
+    companion object {
+        const val DEFAULT_SUPPORT_EMAIL = "support@tangem.com"
+        const val S2C_SUPPORT_EMAIL = "cardsupport@start2coin.com"
+    }
+}

app/src/main/java/com/tangem/tap/common/log/TangemLogCollector.kt

@@ -0,0 +1,25 @@
+package com.tangem.tap.common.log
+
+import com.tangem.Log
+import com.tangem.TangemSdkLogger
+import java.text.SimpleDateFormat
+import java.util.Date
+
+class TangemLogCollector : TangemSdkLogger {
+    private val dateFormatter = SimpleDateFormat("HH:mm:ss.SSS")
+    private val logs = mutableListOf<String>()
+    private val mutex = Object()
+
+    override fun log(message: () -> String, level: Log.Level) {
+        val time = dateFormatter.format(Date())
+        synchronized(mutex) {
+            logs.add("$time: ${message()}\n")
+        }
+    }
+
+    fun getLogs(): List<String> = synchronized(mutex) { logs.toList() }
+
+    fun clearLogs() {
+        synchronized(mutex) { logs.clear() }
+    }
+}

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

@@ -7,15 +7,18 @@ import com.tangem.common.core.TangemError
 import com.tangem.domain.common.ScanResponse
 import com.tangem.tap.common.analytics.GlobalAnalyticsHandler
 import com.tangem.tap.common.entities.FiatCurrency
-import com.tangem.tap.common.redux.*
+import com.tangem.tap.common.feedback.FeedbackData
+import com.tangem.tap.common.feedback.FeedbackManager
+import com.tangem.tap.common.redux.DebugErrorAction
+import com.tangem.tap.common.redux.ErrorAction
+import com.tangem.tap.common.redux.NotificationAction
+import com.tangem.tap.common.redux.StateDialog
+import com.tangem.tap.common.redux.ToastNotificationAction
 import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.configurable.config.ConfigManager
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessage
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessagesManager
 import com.tangem.tap.features.details.redux.SecurityOption
-import com.tangem.tap.features.feedback.EmailData
-import com.tangem.tap.features.feedback.FeedbackManager
-import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
 import org.rekotlin.Action
 
 sealed class GlobalAction : Action {
@@ -74,10 +77,21 @@ sealed class GlobalAction : Action {
     data class SetFeedbackManager(val feedbackManager: FeedbackManager) : GlobalAction()
     data class SetAnanlyticHandlers(val analyticsHandlers: GlobalAnalyticsHandler) : GlobalAction()
 
-    data class SendFeedback(val emailData: EmailData) : GlobalAction()
+    data class SendEmail(val feedbackData: FeedbackData) : GlobalAction()
+    data class OpenChat(val feedbackData: FeedbackData) : GlobalAction()
     data class UpdateFeedbackInfo(val walletManagers: List<WalletManager>) : GlobalAction()
 
-    object InitCurrencyExchangeManager : GlobalAction() {
-        data class Success(val exchangeManager: CurrencyExchangeManager) : GlobalAction()
+    object ExchangeManager : GlobalAction() {
+        object Init : GlobalAction() {
+            data class Success(
+                val exchangeManager: com.tangem.tap.network.exchangeServices.CurrencyExchangeManager,
+            ) : GlobalAction()
+        }
+
+        object Update : GlobalAction()
+    }
+
+    object FetchUserCountry : GlobalAction() {
+        data class Success(val countryCode: String) : GlobalAction()
     }
 }

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

@@ -2,20 +2,31 @@ package com.tangem.tap.common.redux.global
 
 import com.tangem.common.CompletionResult
 import com.tangem.common.core.TangemSdkError
+import com.tangem.common.extensions.guard
 import com.tangem.common.extensions.ifNotNull
+import com.tangem.common.services.Result
 import com.tangem.domain.common.extensions.withMainContext
-import com.tangem.tap.*
+import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
 import com.tangem.tap.common.extensions.dispatchDialogShow
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.redux.AppDialog
 import com.tangem.tap.common.redux.AppState
+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.CurrencyExchangeManager
+import com.tangem.tap.network.exchangeServices.mercuryo.MercuryoApi
+import com.tangem.tap.network.exchangeServices.mercuryo.MercuryoService
 import com.tangem.tap.network.exchangeServices.moonpay.MoonPayService
-import com.tangem.tap.network.exchangeServices.onramper.OnramperService
+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
 
 class GlobalMiddleware {
@@ -24,94 +35,134 @@ class GlobalMiddleware {
     }
 }
 
-private val globalMiddlewareHandler: Middleware<AppState> = { _, appState ->
+private val globalMiddlewareHandler: Middleware<AppState> = { dispatch, appState ->
     { nextDispatch ->
         { action ->
-            when (action) {
-                is GlobalAction.ScanFailsCounter.ChooseBehavior -> {
-                    when (action.result) {
-                        is CompletionResult.Success -> store.dispatch(GlobalAction.ScanFailsCounter.Reset)
+            handleAction(action, appState, dispatch)
+            nextDispatch(action)
+        }
+    }
+}
+
+private fun handleAction(action: Action, appState: () -> AppState?, dispatch: DispatchFunction) {
+    when (action) {
+        is GlobalAction.ScanFailsCounter.ChooseBehavior -> {
+            when (action.result) {
+                is CompletionResult.Success -> store.dispatch(GlobalAction.ScanFailsCounter.Reset)
+                is CompletionResult.Failure -> {
+                    if (action.result.error is TangemSdkError.UserCancelled) {
+                        store.dispatch(GlobalAction.ScanFailsCounter.Increment)
+                        if (store.state.globalState.scanCardFailsCounter >= 2) {
+                            store.dispatchDialogShow(AppDialog.ScanFailsDialog)
+                        }
+                    } else {
+                        store.dispatch(GlobalAction.ScanFailsCounter.Reset)
+                    }
+                }
+            }
+        }
+        is GlobalAction.RestoreAppCurrency -> {
+            store.dispatch(GlobalAction.RestoreAppCurrency.Success(
+                preferencesStorage.fiatCurrenciesPrefStorage.getAppCurrency()
+            ))
+        }
+        is GlobalAction.HideWarningMessage -> {
+            store.state.globalState.warningManager?.let {
+                if (it.hideWarning(action.warning)) {
+                    if (WarningMessagesManager.isAlreadySignedHashesWarning(action.warning)) {
+                        //TODO: No appropriate warningMessage identification. Make it better later
+                        store.dispatch(WalletAction.Warnings.CheckHashesCount.SaveCardId)
+                    }
+
+                    store.dispatch(WalletAction.Warnings.Update)
+                    store.dispatch(SendAction.Warnings.Update)
+                }
+            }
+        }
+        is GlobalAction.SendEmail -> {
+            store.state.globalState.feedbackManager?.sendEmail(action.feedbackData)
+        }
+        is GlobalAction.OpenChat -> {
+            store.state.globalState.feedbackManager?.openChat(action.feedbackData)
+        }
+        is GlobalAction.UpdateWalletSignedHashes -> {
+            store.dispatch(WalletAction.Warnings.CheckRemainingSignatures(action.remainingSignatures))
+        }
+        is GlobalAction.UpdateFeedbackInfo -> {
+            store.state.globalState.feedbackManager?.infoHolder
+                ?.setWalletsInfo(action.walletManagers)
+        }
+        is GlobalAction.ExchangeManager.Init -> {
+            val config = appState()?.globalState?.configManager?.config
+            ifNotNull(
+                config?.mercuryoWidgetId,
+                config?.mercuryoSecret,
+                config?.moonPayApiKey,
+                config?.moonPayApiSecretKey,
+            ) { mercuryoWidgetId, mercuryoSecret, moonPayKey, moonPaySecretKey ->
+                scope.launch {
+                    val buyService = MercuryoService(
+                        apiVersion = MercuryoApi.API_VERSION,
+                        mercuryoWidgetId = mercuryoWidgetId,
+                        secret = mercuryoSecret,
+                    )
+                    val sellService = MoonPayService(moonPayKey, moonPaySecretKey)
+                    val exchangeManager = CurrencyExchangeManager(buyService, sellService)
+                    store.dispatchOnMain(GlobalAction.ExchangeManager.Init.Success(exchangeManager))
+                    store.dispatchOnMain(GlobalAction.ExchangeManager.Update)
+                }
+            }
+        }
+        is GlobalAction.ExchangeManager.Init.Success -> {}
+        is GlobalAction.ExchangeManager.Update -> {
+            val exchangeManager = appState()?.globalState?.exchangeManager.guard {
+                store.dispatchDebugErrorNotification("exchangeManager is not initialized")
+                return
+            }
+            scope.launch { exchangeManager.update() }
+        }
+        is GlobalAction.ScanCard -> {
+            scope.launch {
+                val result = tangemSdkManager.scanProduct(
+                    store.state.globalState.analyticsHandlers,
+                    currenciesRepository,
+                    action.additionalBlockchainsToDerive,
+                    action.messageResId
+                )
+                withMainContext {
+                    store.dispatch(GlobalAction.ScanFailsCounter.ChooseBehavior(result))
+                    when (result) {
+                        is CompletionResult.Success -> {
+                            tangemSdkManager.changeDisplayedCardIdNumbersCount(result.data)
+                            action.onSuccess?.invoke(result.data)
+                        }
                         is CompletionResult.Failure -> {
-                            if (action.result.error is TangemSdkError.UserCancelled) {
-                                store.dispatch(GlobalAction.ScanFailsCounter.Increment)
-                                if (store.state.globalState.scanCardFailsCounter >= 2) {
-                                    store.dispatchDialogShow(AppDialog.ScanFailsDialog)
-                                }
-                            } else {
-                                store.dispatch(GlobalAction.ScanFailsCounter.Reset)
-                            }
-                        }
-                    }
-                }
-                is GlobalAction.RestoreAppCurrency -> {
-                    store.dispatch(GlobalAction.RestoreAppCurrency.Success(
-                        preferencesStorage.fiatCurrenciesPrefStorage.getAppCurrency()
-                    ))
-                }
-                is GlobalAction.HideWarningMessage -> {
-                    store.state.globalState.warningManager?.let {
-                        if (it.hideWarning(action.warning)) {
-                            if (WarningMessagesManager.isAlreadySignedHashesWarning(action.warning)) {
-                                //TODO: No appropriate warningMessage identification. Make it better later
-                                store.dispatch(WalletAction.Warnings.CheckHashesCount.SaveCardId)
-                            }
-
-                            store.dispatch(WalletAction.Warnings.Update)
-                            store.dispatch(SendAction.Warnings.Update)
-                        }
-                    }
-                }
-
-                is GlobalAction.SendFeedback -> {
-                    store.state.globalState.feedbackManager?.send(action.emailData)
-                }
-                is GlobalAction.UpdateWalletSignedHashes -> {
-                    store.dispatch(WalletAction.Warnings.CheckRemainingSignatures(action.remainingSignatures))
-                }
-                is GlobalAction.UpdateFeedbackInfo -> {
-                    store.state.globalState.feedbackManager?.infoHolder
-                        ?.setWalletsInfo(action.walletManagers)
-                }
-                is GlobalAction.InitCurrencyExchangeManager -> {
-                    val config = appState()?.globalState?.configManager?.config
-                    ifNotNull(
-                        config?.onramperApiKey,
-                        config?.moonPayApiKey,
-                        config?.moonPayApiSecretKey,
-                    ) { onramperKey, moonPayKey, moonPaySecretKey ->
-                        scope.launch {
-                            val onramper = OnramperService(onramperKey)
-                            val moonPay = MoonPayService(moonPayKey, moonPaySecretKey)
-                            val exchangeManager = CurrencyExchangeManager(onramper, moonPay)
-                            exchangeManager.getStatus()
-                            store.dispatchOnMain(GlobalAction.InitCurrencyExchangeManager.Success(exchangeManager))
-                        }
-                    }
-                }
-                is GlobalAction.ScanCard -> {
-                    scope.launch {
-                        val result = tangemSdkManager.scanProduct(
-                            store.state.globalState.analyticsHandlers,
-                            currenciesRepository,
-                            action.additionalBlockchainsToDerive,
-                            action.messageResId
-                        )
-                        withMainContext {
-                            store.dispatch(GlobalAction.ScanFailsCounter.ChooseBehavior(result))
-                            when (result) {
-                                is CompletionResult.Success -> {
-                                    tangemSdkManager.changeDisplayedCardIdNumbersCount(result.data)
-                                    action.onSuccess?.invoke(result.data)
-                                }
-                                is CompletionResult.Failure -> {
-                                    action.onFailure?.invoke(result.error)
-                                }
-                            }
+                            action.onFailure?.invoke(result.error)
                         }
                     }
                 }
             }
-            nextDispatch(action)
+        }
+        is GlobalAction.FetchUserCountry -> {
+            scope.launch {
+                val techService = store.state.domainNetworks.tangemTechService
+                when (val result = techService.userCountry()) {
+                    is Result.Success -> {
+                        store.dispatch(
+                            GlobalAction.FetchUserCountry.Success(
+                                countryCode = result.data.code.lowercase()
+                            )
+                        )
+                    }
+                    is Result.Failure -> {
+                        store.dispatch(
+                            GlobalAction.FetchUserCountry.Success(
+                                countryCode = Locale.getDefault().country.lowercase()
+                            )
+                        )
+                    }
+                }
+            }
         }
     }
 }

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

@@ -70,12 +70,14 @@ fun globalReducer(action: Action, state: AppState): GlobalState {
         is GlobalAction.HideDialog -> {
             globalState.copy(dialog = null)
         }
-        is GlobalAction.InitCurrencyExchangeManager.Success -> {
-            globalState.copy(currencyExchangeManager = action.exchangeManager)
+        is GlobalAction.ExchangeManager.Init.Success -> {
+            globalState.copy(exchangeManager = action.exchangeManager)
         }
         is GlobalAction.SetIfCardVerifiedOnline ->
             globalState.copy(cardVerifiedOnline = action.verified)
-
+        is GlobalAction.FetchUserCountry.Success -> globalState.copy(
+            userCountryCode = action.countryCode
+        )
         else -> globalState
     }
 }

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

@@ -3,12 +3,12 @@ package com.tangem.tap.common.redux.global
 import com.tangem.domain.common.ScanResponse
 import com.tangem.tap.common.analytics.AnalyticsHandler
 import com.tangem.tap.common.entities.FiatCurrency
+import com.tangem.tap.common.feedback.FeedbackManager
 import com.tangem.tap.common.redux.StateDialog
 import com.tangem.tap.domain.PayIdManager
 import com.tangem.tap.domain.TapWalletManager
 import com.tangem.tap.domain.configurable.config.ConfigManager
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessagesManager
-import com.tangem.tap.features.feedback.FeedbackManager
 import com.tangem.tap.features.onboarding.OnboardingManager
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
 import org.rekotlin.StateType
@@ -25,9 +25,10 @@ data class GlobalState(
     val appCurrency: FiatCurrency = FiatCurrency.Default,
     val scanCardFailsCounter: Int = 0,
     val dialog: StateDialog? = null,
-    val currencyExchangeManager: CurrencyExchangeManager? = null,
+    val exchangeManager: CurrencyExchangeManager? = null,
     val resources: AndroidResources = AndroidResources(),
     val analyticsHandlers: AnalyticsHandler? = null,
+    val userCountryCode: String? = null,
 ) : StateType
 
 

app/src/main/java/com/tangem/tap/common/zendesk/ZendeskConfig.kt

@@ -0,0 +1,16 @@
+package com.tangem.tap.common.zendesk
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+@JsonClass(generateAdapter = true)
+data class ZendeskConfig(
+    @Json(name = "zendeskApiKey")
+    val apiKey: String,
+    @Json(name = "zendeskAppId")
+    val appId: String,
+    @Json(name = "zendeskClientId")
+    val clientId: String,
+    @Json(name = "zendeskUrl")
+    val url: String,
+)