Updated on 2026-08-14

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

@@ -5,7 +5,12 @@ import android.content.Context
 import com.tangem.tap.common.redux.AppDialog
 import com.tangem.tap.common.redux.global.GlobalState
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectDialog
-import com.tangem.tap.features.details.ui.walletconnect.dialogs.*
+import com.tangem.tap.features.details.ui.walletconnect.dialogs.ApproveWcSessionDialog
+import com.tangem.tap.features.details.ui.walletconnect.dialogs.BnbTransactionDialog
+import com.tangem.tap.features.details.ui.walletconnect.dialogs.ClipboardOrScanQrDialog
+import com.tangem.tap.features.details.ui.walletconnect.dialogs.PersonalSignDialog
+import com.tangem.tap.features.details.ui.walletconnect.dialogs.SimpleAlertDialog
+import com.tangem.tap.features.details.ui.walletconnect.dialogs.TransactionDialog
 import com.tangem.tap.features.onboarding.AddressInfoBottomSheetDialog
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsAction
 import com.tangem.tap.features.onboarding.products.twins.ui.dialog.CreateWalletInterruptDialog
@@ -16,6 +21,7 @@ import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.ConfirmDisc
 import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.UnfinishedBackupFoundDialog
 import com.tangem.tap.features.wallet.ui.dialogs.ScanFailsDialog
 import com.tangem.tap.features.wallet.ui.dialogs.SimpleOkDialog
+import com.tangem.tap.features.wallet.ui.wallet.CurrencySelectionDialog
 import com.tangem.tap.store
 import com.tangem.wallet.R
 import org.rekotlin.StoreSubscriber
@@ -54,7 +60,10 @@ class DialogManager : StoreSubscriber<GlobalState> {
             is AppDialog.ScanFailsDialog -> ScanFailsDialog.create(context)
             is AppDialog.AddressInfoDialog -> AddressInfoBottomSheetDialog(state.dialog, context)
             is AppDialog.TestActionsDialog -> TestActionsBottomSheetDialog(state.dialog, context)
-            is TwinCardsAction.Wallet.ShowInterruptDialog -> CreateWalletInterruptDialog.create(state.dialog, context)
+            is AppDialog.CurrencySelectionDialog ->
+                CurrencySelectionDialog.create(state.dialog, context)
+            is TwinCardsAction.Wallet.ShowInterruptDialog ->
+                CreateWalletInterruptDialog.create(state.dialog, context)
             is WalletConnectDialog.UnsupportedCard ->
                 SimpleAlertDialog.create(
                     titleRes = R.string.wallet_connect,

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

@@ -2,6 +2,7 @@ package com.tangem.tap.common.redux
 
 import com.tangem.common.extensions.VoidCallback
 import com.tangem.tap.common.TestAction
+import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.features.wallet.redux.AddressData
 import com.tangem.tap.features.wallet.redux.Currency
 
@@ -12,7 +13,12 @@ interface StateDialog
 
 sealed class AppDialog : StateDialog {
     data class SimpleOkDialog(val header: String, val message: String, val onOk: VoidCallback? = null) : AppDialog()
-    data class SimpleOkDialogRes(val headerId: Int, val messageId: Int, val onOk: VoidCallback? = null) : AppDialog()
+    data class SimpleOkDialogRes(
+        val headerId: Int,
+        val messageId: Int,
+        val onOk: VoidCallback? = null
+    ) : AppDialog()
+
     object ScanFailsDialog : AppDialog()
     data class AddressInfoDialog(
         val currency: Currency,
@@ -22,4 +28,9 @@ sealed class AppDialog : StateDialog {
     data class TestActionsDialog(
         val actionsList: List<TestAction>
     ) : AppDialog()
+
+    data class CurrencySelectionDialog(
+        val currenciesList: List<FiatCurrency>,
+        val currentAppCurrency: FiatCurrency,
+    ) : AppDialog()
 }

app/src/main/java/com/tangem/tap/features/details/redux/DetailsAction.kt

@@ -4,9 +4,7 @@ import com.tangem.blockchain.common.Wallet
 import com.tangem.common.card.Card
 import com.tangem.domain.common.ScanResponse
 import com.tangem.domain.common.TwinCardNumber
-import com.tangem.network.api.tangemTech.TangemTechService
 import com.tangem.operations.pins.CheckUserCodesResponse
-import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.common.redux.NotificationAction
 import com.tangem.tap.domain.termsOfUse.CardTou
 import com.tangem.wallet.R
@@ -18,9 +16,6 @@ sealed class DetailsAction : Action {
         val scanResponse: ScanResponse,
         val wallets: List<Wallet>,
         val cardTou: CardTou,
-        val fiatCurrencyName: FiatCurrency,
-        val fiatCurrencies: List<FiatCurrency>? = null,
-        val tangemTechService: TangemTechService,
     ) : DetailsAction()
 
     object ShowDisclaimer : DetailsAction()
@@ -46,13 +41,6 @@ sealed class DetailsAction : Action {
 
     object CreateBackup : DetailsAction()
 
-    sealed class AppCurrencyAction : DetailsAction() {
-        data class SetCurrencies(val currencies: List<FiatCurrency>) : AppCurrencyAction()
-        object ChooseAppCurrency : AppCurrencyAction()
-        object Cancel : AppCurrencyAction()
-        data class SelectAppCurrency(val fiatCurrency: FiatCurrency) : AppCurrencyAction()
-    }
-
     sealed class ManageSecurity : DetailsAction() {
         data class CheckCurrentSecurityOption(val card: Card) : ManageSecurity()
         data class SetCurrentOption(val userCodes: CheckUserCodesResponse) : ManageSecurity()

app/src/main/java/com/tangem/tap/features/details/redux/DetailsMiddleware.kt

@@ -3,24 +3,23 @@ package com.tangem.tap.features.details.redux
 import com.tangem.common.CompletionResult
 import com.tangem.common.card.FirmwareVersion
 import com.tangem.common.core.TangemSdkError
-import com.tangem.common.services.Result
-import com.tangem.network.api.tangemTech.CurrenciesResponse
 import com.tangem.operations.pins.CheckUserCodesResponse
-import com.tangem.tap.*
 import com.tangem.tap.common.analytics.Analytics
 import com.tangem.tap.common.analytics.AnalyticsParam
-import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.common.extensions.dispatchNotification
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.common.redux.navigation.AppScreen
 import com.tangem.tap.common.redux.navigation.NavigationAction
+import com.tangem.tap.currenciesRepository
 import com.tangem.tap.features.disclaimer.redux.DisclaimerAction
 import com.tangem.tap.features.onboarding.products.twins.redux.CreateTwinWalletMode
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsAction
 import com.tangem.tap.features.wallet.models.hasSendableAmountsOrPendingTransactions
-import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.scope
+import com.tangem.tap.store
+import com.tangem.tap.tangemSdkManager
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -28,15 +27,12 @@ import org.rekotlin.Middleware
 
 class DetailsMiddleware {
     private val eraseWalletMiddleware = EraseWalletMiddleware()
-    private val appCurrencyMiddleware = AppCurrencyMiddleware()
     private val manageSecurityMiddleware = ManageSecurityMiddleware()
     val detailsMiddleware: Middleware<AppState> = { _, _ ->
         { next ->
             { action ->
                 when (action) {
-                    is DetailsAction.PrepareScreen -> prepareData(action)
                     is DetailsAction.ResetToFactory -> eraseWalletMiddleware.handle(action)
-                    is DetailsAction.AppCurrencyAction -> appCurrencyMiddleware.handle(action)
                     is DetailsAction.ManageSecurity -> manageSecurityMiddleware.handle(action)
                     is DetailsAction.ShowDisclaimer -> {
                         store.dispatch(DisclaimerAction.ShowAcceptedDisclaimer)
@@ -69,48 +65,6 @@ class DetailsMiddleware {
         }
     }
 
-    private fun prepareData(action: DetailsAction.PrepareScreen) {
-        val fiatCurrenciesPrefStorage = preferencesStorage.fiatCurrenciesPrefStorage
-        val storedFiatCurrencies = fiatCurrenciesPrefStorage.restore()
-        if (storedFiatCurrencies.isNotEmpty()) {
-            store.dispatch(
-                DetailsAction.AppCurrencyAction.SetCurrencies(
-                    currencies = storedFiatCurrencies.mapToUiModel()
-                )
-            )
-        }
-
-        scope.launch {
-            val tangemTechService = action.tangemTechService
-            when (val result = tangemTechService.currencies()) {
-                is Result.Success -> {
-                    val currenciesList = result.data.currencies
-                    if (currenciesList.isNotEmpty() &&
-                        currenciesList.toSet() != storedFiatCurrencies.toSet()
-                    ) {
-                        fiatCurrenciesPrefStorage.save(currenciesList)
-                        dispatchOnMain(
-                            DetailsAction.AppCurrencyAction.SetCurrencies(
-                                currencies = currenciesList.mapToUiModel()
-                            )
-                        )
-                    }
-                }
-                is Result.Failure -> {}
-            }
-        }
-    }
-
-    private fun List<CurrenciesResponse.Currency>.mapToUiModel(): List<FiatCurrency> {
-        return this.map {
-            FiatCurrency(
-                code = it.code,
-                name = it.name,
-                symbol = it.unit
-            )
-        }
-    }
-
     class EraseWalletMiddleware {
         fun handle(action: DetailsAction.ResetToFactory) {
             when (action) {
@@ -158,22 +112,6 @@ class DetailsMiddleware {
         }
     }
 
-    class AppCurrencyMiddleware {
-        fun handle(action: DetailsAction.AppCurrencyAction) {
-            when (action) {
-                is DetailsAction.AppCurrencyAction.SelectAppCurrency -> {
-                    store.state.globalState.tapWalletManager.rates.clear()
-                    preferencesStorage.fiatCurrenciesPrefStorage
-                        .saveAppCurrency(action.fiatCurrency)
-                    store.dispatch(GlobalAction.ChangeAppCurrency(action.fiatCurrency))
-                    store.dispatch(WalletAction.LoadFiatRate())
-                }
-                else -> { /* no-op */
-                }
-            }
-        }
-    }
-
     class ManageSecurityMiddleware {
         fun handle(action: DetailsAction.ManageSecurity) {
             when (action) {

app/src/main/java/com/tangem/tap/features/details/redux/DetailsReducer.kt

@@ -29,9 +29,6 @@ private fun internalReduce(action: Action, state: AppState): DetailsState {
         is DetailsAction.ResetToFactory -> {
             handleEraseWallet(action, detailsState)
         }
-        is DetailsAction.AppCurrencyAction -> {
-            handleAppCurrencyAction(action, detailsState)
-        }
         is DetailsAction.ManageSecurity -> {
             handleSecurityAction(action, detailsState)
         }
@@ -48,10 +45,6 @@ private fun handlePrepareScreen(
         scanResponse = action.scanResponse,
         wallets = action.wallets,
         cardInfo = action.scanResponse.card.toCardInfo(),
-        appCurrencyState = state.appCurrencyState.copy(
-            currentFiatCurrency = action.fiatCurrencyName,
-            showAppCurrencyDialog = false,
-        ),
         cardTermsOfUseUrl = action.cardTou.getUrl(action.scanResponse.card),
         createBackupAllowed = action.scanResponse.card.backupStatus == Card.BackupStatus.NoBackup,
     )
@@ -93,31 +86,6 @@ private fun handleEraseWallet(
     }
 }
 
-private fun handleAppCurrencyAction(
-    action: DetailsAction.AppCurrencyAction, state: DetailsState,
-): DetailsState {
-    return when (action) {
-        is DetailsAction.AppCurrencyAction.SetCurrencies -> {
-            state.copy(appCurrencyState = state.appCurrencyState.copy(fiatCurrencies = action.currencies))
-        }
-        DetailsAction.AppCurrencyAction.ChooseAppCurrency -> {
-            state.copy(appCurrencyState = state.appCurrencyState.copy(showAppCurrencyDialog = true))
-        }
-        DetailsAction.AppCurrencyAction.Cancel -> {
-            state.copy(appCurrencyState = state.appCurrencyState.copy(showAppCurrencyDialog = false))
-        }
-        is DetailsAction.AppCurrencyAction.SelectAppCurrency -> {
-            state.copy(
-                appCurrencyState = state.appCurrencyState.copy(
-                    currentFiatCurrency = action.fiatCurrency,
-                    showAppCurrencyDialog = false
-                )
-            )
-        }
-        else -> state
-    }
-}
-
 private fun handleSecurityAction(
     action: DetailsAction.ManageSecurity, state: DetailsState,
 ): DetailsState {

app/src/main/java/com/tangem/tap/features/details/redux/DetailsState.kt

@@ -4,7 +4,6 @@ import android.net.Uri
 import com.tangem.blockchain.common.Wallet
 import com.tangem.domain.common.ScanResponse
 import com.tangem.tap.common.entities.Button
-import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsState
 import com.tangem.tap.store
 import org.rekotlin.StateType
@@ -15,7 +14,6 @@ data class DetailsState(
     val scanResponse: ScanResponse? = null,
     val wallets: List<Wallet> = emptyList(),
     val cardInfo: CardInfo? = null,
-    val appCurrencyState: AppCurrencyState = AppCurrencyState(),
     val eraseWalletState: EraseWalletState? = null,
     val confirmScreenState: ConfirmScreenState? = null,
     val securityScreenState: SecurityScreenState? = null,
@@ -48,10 +46,4 @@ data class SecurityScreenState(
     val buttonProceed: Button = Button(true),
 )
 
-enum class SecurityOption { LongTap, PassCode, AccessCode }
-
-data class AppCurrencyState(
-    val currentFiatCurrency: FiatCurrency = FiatCurrency.Default,
-    val showAppCurrencyDialog: Boolean = false,
-    val fiatCurrencies: List<FiatCurrency>? = null,
-)
+enum class SecurityOption { LongTap, PassCode, AccessCode }

app/src/main/java/com/tangem/tap/features/details/ui/CurrencySelectionDialog.kt

@@ -1,52 +0,0 @@
-package com.tangem.tap.features.details.ui
-
-import android.content.Context
-import androidx.appcompat.app.AlertDialog
-import com.tangem.tap.common.entities.FiatCurrency
-import com.tangem.tap.features.details.redux.DetailsAction
-import com.tangem.tap.store
-import com.tangem.wallet.R
-
-class CurrencySelectionDialog {
-
-    var dialog: AlertDialog? = null
-
-    fun show(
-        currenciesList: List<FiatCurrency>,
-        currentAppCurrency: FiatCurrency,
-        context: Context
-    ) {
-        if (dialog == null) {
-            val currenciesToShow = currenciesList
-                .map { it.displayName }
-                .toTypedArray()
-            var currentSelection = currenciesList
-                .indexOfFirst { it.code == currentAppCurrency.code }
-
-            dialog = AlertDialog.Builder(context)
-                .setTitle(context.getString(R.string.details_row_title_currency))
-                .setNegativeButton(context.getString(R.string.common_cancel)) { _, _ ->
-                    store.dispatch(DetailsAction.AppCurrencyAction.Cancel)
-                }
-                .setPositiveButton(context.getString(R.string.common_done)) { _, _ ->
-                    val selectedCurrency = currenciesList[currentSelection]
-                    store.dispatch(
-                        DetailsAction.AppCurrencyAction.SelectAppCurrency(
-                            fiatCurrency = selectedCurrency
-                        )
-                    )
-                    }
-                    .setOnDismissListener {
-                        store.dispatch(DetailsAction.AppCurrencyAction.Cancel)
-                    }
-                    .setSingleChoiceItems(currenciesToShow, currentSelection) { _, which ->
-                        currentSelection = which
-                    }.show()
-        }
-    }
-
-    fun clear() {
-        dialog = null
-    }
-
-}

app/src/main/java/com/tangem/tap/features/details/ui/DetailsFragment.kt

@@ -24,7 +24,6 @@ import org.rekotlin.StoreSubscriber
 
 class DetailsFragment : Fragment(R.layout.fragment_details), StoreSubscriber<DetailsState> {
 
-    private var currencySelectionDialog = CurrencySelectionDialog()
     private val binding: FragmentDetailsBinding by viewBinding(FragmentDetailsBinding::bind)
 
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -115,11 +114,6 @@ class DetailsFragment : Fragment(R.layout.fragment_details), StoreSubscriber<Det
             store.dispatch(DetailsAction.CreateBackup)
         }
 
-        tvAppCurrency.text = state.appCurrencyState.currentFiatCurrency.code
-
-        tvAppCurrencyTitle.setOnClickListener {
-            store.dispatch(DetailsAction.AppCurrencyAction.ChooseAppCurrency)
-        }
         tvSendFeedback.setOnClickListener {
             store.dispatch(GlobalAction.SendFeedback(FeedbackEmail()))
         }
@@ -140,17 +134,6 @@ class DetailsFragment : Fragment(R.layout.fragment_details), StoreSubscriber<Det
             null -> null
         }
         currentSecurity?.let { tvSecurity.text = getString(it) }
-
-        if (state.appCurrencyState.showAppCurrencyDialog &&
-            !state.appCurrencyState.fiatCurrencies.isNullOrEmpty()) {
-            currencySelectionDialog.show(
-                currenciesList = state.appCurrencyState.fiatCurrencies,
-                currentAppCurrency = state.appCurrencyState.currentFiatCurrency,
-                context = requireContext()
-            )
-        } else {
-            currencySelectionDialog.clear()
-        }
     }
 
 }

app/src/main/java/com/tangem/tap/features/wallet/redux/WalletAction.kt

@@ -1,17 +1,22 @@
 package com.tangem.tap.features.wallet.redux
 
 import android.content.Context
-import com.tangem.blockchain.common.*
+import com.tangem.blockchain.common.Amount
+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.blockchain.common.address.AddressType
 import com.tangem.common.card.Card
+import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.common.redux.ErrorAction
 import com.tangem.tap.common.redux.NotificationAction
 import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessage
 import com.tangem.tap.domain.tokens.BlockchainNetwork
 import com.tangem.wallet.R
-import org.rekotlin.Action
 import java.math.BigDecimal
+import org.rekotlin.Action
 
 sealed class WalletAction : Action {
 
@@ -98,7 +103,10 @@ sealed class WalletAction : Action {
     data class LoadFiatRate(
         val wallet: Wallet? = null, val coinsList: List<Currency>? = null,
     ) : WalletAction() {
-        data class Success(val fiatRate: Pair<Currency, BigDecimal?>) : WalletAction()
+        data class Success(
+            val fiatRates: Map<Currency, BigDecimal?>
+        ) : WalletAction()
+
         object Failure : WalletAction()
     }
 
@@ -163,4 +171,9 @@ sealed class WalletAction : Action {
     ) : WalletAction()
 
     data class RemoveWalletRent(val wallet: Wallet) : WalletAction()
+
+    sealed class AppCurrencyAction : WalletAction() {
+        object ChooseAppCurrency : AppCurrencyAction()
+        data class SelectAppCurrency(val fiatCurrency: FiatCurrency) : AppCurrencyAction()
+    }
 }

app/src/main/java/com/tangem/tap/features/wallet/redux/WalletState.kt

@@ -1,7 +1,13 @@
 package com.tangem.tap.features.wallet.redux
 
 import android.graphics.Bitmap
-import com.tangem.blockchain.common.*
+import com.tangem.blockchain.common.Amount
+import com.tangem.blockchain.common.AmountType
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.DerivationStyle
+import com.tangem.blockchain.common.Token
+import com.tangem.blockchain.common.Wallet
+import com.tangem.blockchain.common.WalletManager
 import com.tangem.blockchain.common.address.AddressType
 import com.tangem.blockchain.extensions.isAboveZero
 import com.tangem.common.extensions.isZero
@@ -25,8 +31,8 @@ import com.tangem.tap.features.wallet.ui.BalanceStatus
 import com.tangem.tap.features.wallet.ui.BalanceWidgetData
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
 import com.tangem.tap.store
-import org.rekotlin.StateType
 import java.math.BigDecimal
+import org.rekotlin.StateType
 import kotlin.properties.ReadOnlyProperty
 
 data class WalletState(

app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/AppCurrencyMiddleware.kt

@@ -0,0 +1,78 @@
+package com.tangem.tap.features.wallet.redux.middlewares
+
+import com.tangem.common.services.Result
+import com.tangem.network.api.tangemTech.CurrenciesResponse
+import com.tangem.network.api.tangemTech.TangemTechService
+import com.tangem.tap.common.entities.FiatCurrency
+import com.tangem.tap.common.extensions.dispatchDialogShow
+import com.tangem.tap.common.redux.AppDialog
+import com.tangem.tap.common.redux.global.GlobalAction
+import com.tangem.tap.domain.TapWalletManager
+import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.persistence.FiatCurrenciesPrefStorage
+import com.tangem.tap.scope
+import com.tangem.tap.store
+import kotlinx.coroutines.launch
+
+class AppCurrencyMiddleware(
+    private val tangemTechService: TangemTechService,
+    private val tapWalletManager: TapWalletManager,
+    private val fiatCurrenciesPrefStorage: FiatCurrenciesPrefStorage,
+    private val appCurrencyProvider: () -> FiatCurrency,
+) {
+    fun handle(action: WalletAction.AppCurrencyAction) {
+        when (action) {
+            is WalletAction.AppCurrencyAction.ChooseAppCurrency -> showSelector()
+            is WalletAction.AppCurrencyAction.SelectAppCurrency -> selectCurrency(action)
+        }
+    }
+
+    private fun showSelector() {
+        val storedFiatCurrencies = fiatCurrenciesPrefStorage.restore()
+        if (storedFiatCurrencies.isNotEmpty()) {
+            store.dispatchDialogShow(
+                AppDialog.CurrencySelectionDialog(
+                    currenciesList = storedFiatCurrencies.mapToUiModel(),
+                    currentAppCurrency = appCurrencyProvider.invoke()
+                )
+            )
+        }
+
+        scope.launch {
+            when (val result = tangemTechService.currencies()) {
+                is Result.Success -> {
+                    val currenciesList = result.data.currencies
+                    if (currenciesList.isNotEmpty() &&
+                        currenciesList.toSet() != storedFiatCurrencies.toSet()
+                    ) {
+                        fiatCurrenciesPrefStorage.save(currenciesList)
+                        store.dispatchDialogShow(
+                            AppDialog.CurrencySelectionDialog(
+                                currenciesList = storedFiatCurrencies.mapToUiModel(),
+                                currentAppCurrency = appCurrencyProvider.invoke()
+                            )
+                        )
+                    }
+                }
+                is Result.Failure -> {}
+            }
+        }
+    }
+
+    private fun selectCurrency(action: WalletAction.AppCurrencyAction.SelectAppCurrency) {
+        tapWalletManager.rates.clear()
+        fiatCurrenciesPrefStorage.saveAppCurrency(action.fiatCurrency)
+        store.dispatch(GlobalAction.ChangeAppCurrency(action.fiatCurrency))
+        store.dispatch(WalletAction.LoadFiatRate())
+    }
+
+    private fun List<CurrenciesResponse.Currency>.mapToUiModel(): List<FiatCurrency> {
+        return this.map {
+            FiatCurrency(
+                code = it.code,
+                name = it.name,
+                symbol = it.unit
+            )
+        }
+    }
+}

app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WalletMiddleware.kt

@@ -15,7 +15,13 @@ import com.tangem.domain.common.extensions.withMainContext
 import com.tangem.operations.attestation.Attestation
 import com.tangem.operations.attestation.OnlineCardVerifier
 import com.tangem.tap.common.analytics.Analytics
-import com.tangem.tap.common.extensions.*
+import com.tangem.tap.common.extensions.copyToClipboard
+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.extensions.onCardScanned
+import com.tangem.tap.common.extensions.shareText
+import com.tangem.tap.common.extensions.stripZeroPlainString
 import com.tangem.tap.common.redux.AppDialog
 import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.common.redux.global.GlobalAction
@@ -29,11 +35,17 @@ import com.tangem.tap.features.home.redux.HomeAction
 import com.tangem.tap.features.send.redux.PrepareSendScreen
 import com.tangem.tap.features.wallet.models.PendingTransactionType
 import com.tangem.tap.features.wallet.models.getPendingTransactions
-import com.tangem.tap.features.wallet.redux.*
+import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.features.wallet.redux.WalletData
+import com.tangem.tap.features.wallet.redux.WalletState
+import com.tangem.tap.features.wallet.redux.WalletStore
 import com.tangem.tap.network.NetworkStateChanged
+import com.tangem.tap.preferencesStorage
 import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.tap.tangemSdkManager
+import java.math.BigDecimal
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.launch
@@ -41,12 +53,19 @@ import org.rekotlin.Action
 import org.rekotlin.DispatchFunction
 import org.rekotlin.Middleware
 import timber.log.Timber
-import java.math.BigDecimal
 
 class WalletMiddleware {
     private val tradeCryptoMiddleware = TradeCryptoMiddleware()
     private val warningsMiddleware = WarningsMiddleware()
     private val multiWalletMiddleware = MultiWalletMiddleware()
+    private val appCurrencyMiddleware by lazy(mode = LazyThreadSafetyMode.NONE) {
+        AppCurrencyMiddleware(
+            tangemTechService = store.state.domainNetworks.tangemTechService,
+            tapWalletManager = store.state.globalState.tapWalletManager,
+            fiatCurrenciesPrefStorage = preferencesStorage.fiatCurrenciesPrefStorage,
+            appCurrencyProvider = { store.state.globalState.appCurrency },
+        )
+    }
 
     val walletMiddleware: Middleware<AppState> = { dispatch, state ->
         { next ->
@@ -71,6 +90,7 @@ class WalletMiddleware {
                 walletState,
                 globalState
             )
+            is WalletAction.AppCurrencyAction -> appCurrencyMiddleware.handle(action)
             is WalletAction.LoadWallet -> {
                 scope.launch {
                     if (action.blockchain == null) {
@@ -121,11 +141,15 @@ class WalletMiddleware {
                     )
                     when (ratesResult) {
                         is Result.Success -> {
-                            ratesResult.data.loadedRates.forEach {
-                                dispatchOnMain(WalletAction.LoadFiatRate.Success(it.toPair()))
+                            ratesResult.data.loadedRates.let {
+                                dispatchOnMain(WalletAction.LoadFiatRate.Success(it))
                             }
                             ratesResult.data.failedRates.forEach { (currency, throwable) ->
-                                Timber.e(throwable, "Loading rates failed for [%s]", currency.currencySymbol)
+                                Timber.e(
+                                    throwable,
+                                    "Loading rates failed for [%s]",
+                                    currency.currencySymbol
+                                )
                             }
                         }
                         is Result.Failure -> {

app/src/main/java/com/tangem/tap/features/wallet/redux/reducers/AppCurrencyReducer.kt

@@ -0,0 +1,16 @@
+package com.tangem.tap.features.wallet.redux.reducers
+
+import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.features.wallet.redux.WalletState
+
+class AppCurrencyReducer {
+    fun reduce(
+        action: WalletAction.AppCurrencyAction,
+        state: WalletState,
+    ): WalletState {
+        return when (action) {
+            is WalletAction.AppCurrencyAction.SelectAppCurrency,
+            is WalletAction.AppCurrencyAction.ChooseAppCurrency -> state
+        }
+    }
+}

app/src/main/java/com/tangem/tap/features/wallet/redux/reducers/OnWalletLoadedReducer.kt

@@ -9,7 +9,6 @@ import com.tangem.tap.common.extensions.toFormattedCurrencyString
 import com.tangem.tap.common.extensions.toFormattedFiatValue
 import com.tangem.tap.domain.getFirstToken
 import com.tangem.tap.domain.tokens.BlockchainNetwork
-import com.tangem.tap.features.wallet.models.TotalBalance
 import com.tangem.tap.features.wallet.models.removeUnknownTransactions
 import com.tangem.tap.features.wallet.models.toPendingTransactions
 import com.tangem.tap.features.wallet.redux.*
@@ -17,7 +16,6 @@ import com.tangem.tap.features.wallet.ui.BalanceStatus
 import com.tangem.tap.features.wallet.ui.BalanceWidgetData
 import com.tangem.tap.features.wallet.ui.TokenData
 import com.tangem.tap.store
-import java.math.BigDecimal
 import java.math.RoundingMode
 
 class OnWalletLoadedReducer {
@@ -109,12 +107,6 @@ class OnWalletLoadedReducer {
         val newWallets = tokens + newWalletData
         val wallets = walletState.replaceSomeWallets((newWallets))
 
-        val totalBalance = TotalBalance(
-            state = wallets.findTotalBalanceState(),
-            fiatAmount = wallets.calculateTotalFiatAmount(),
-            fiatCurrency = fiatCurrency,
-        )
-
         val state = if (wallets.any { it.currencyData.status == BalanceStatus.Loading }) {
             ProgressState.Loading
         } else {
@@ -122,7 +114,9 @@ class OnWalletLoadedReducer {
         }
         return walletState
             .updateWalletsData(wallets)
-            .updateTotalBalance(totalBalance)
+            .updateTotalBalance(
+                totalBalance = obtainTotalBalance(wallets, fiatCurrency)
+            )
             .copy(
                 state = state,
                 error = null
@@ -192,48 +186,4 @@ class OnWalletLoadedReducer {
             state = ProgressState.Done, error = null
         )
     }
-
-    private fun List<WalletData>.findTotalBalanceState(): TotalBalance.State {
-        return this.mapToTotalBalanceState()
-            .fold(initial = TotalBalance.State.Loading) { accState, newState ->
-                accState or newState
-            }
-    }
-
-    private fun List<WalletData>.calculateTotalFiatAmount(): BigDecimal {
-        return this.map { it.currencyData.fiatAmount ?: BigDecimal.ZERO }
-            .reduce(BigDecimal::plus)
-    }
-
-    private fun List<WalletData>.mapToTotalBalanceState(): List<TotalBalance.State> {
-        return this.map {
-            when (it.currencyData.status) {
-                BalanceStatus.VerifiedOnline,
-                BalanceStatus.SameCurrencyTransactionInProgress,
-                BalanceStatus.TransactionInProgress -> TotalBalance.State.Success
-                BalanceStatus.Unreachable,
-                BalanceStatus.NoAccount,
-                BalanceStatus.EmptyCard,
-                BalanceStatus.UnknownBlockchain -> TotalBalance.State.SomeTokensFailed
-                BalanceStatus.Loading,
-                null -> TotalBalance.State.Loading
-            }
-        }
-    }
-
-    infix fun TotalBalance.State.or(newState: TotalBalance.State): TotalBalance.State {
-        return when (this) {
-            TotalBalance.State.Loading -> when (newState) {
-                TotalBalance.State.Loading -> this
-                TotalBalance.State.SomeTokensFailed,
-                TotalBalance.State.Success -> newState
-            }
-            TotalBalance.State.Success,
-            TotalBalance.State.SomeTokensFailed -> when (newState) {
-                TotalBalance.State.Loading,
-                TotalBalance.State.SomeTokensFailed -> newState
-                TotalBalance.State.Success -> this
-            }
-        }
-    }
 }

app/src/main/java/com/tangem/tap/features/wallet/redux/reducers/TotalBalanceOperations.kt

@@ -0,0 +1,62 @@
+package com.tangem.tap.features.wallet.redux.reducers
+
+import com.tangem.tap.common.entities.FiatCurrency
+import com.tangem.tap.features.wallet.models.TotalBalance
+import com.tangem.tap.features.wallet.redux.WalletData
+import com.tangem.tap.features.wallet.ui.BalanceStatus
+import java.math.BigDecimal
+
+fun obtainTotalBalance(
+    wallets: List<WalletData>,
+    appCurrency: FiatCurrency
+): TotalBalance {
+    return TotalBalance(
+        state = wallets.findTotalBalanceState(),
+        fiatAmount = wallets.calculateTotalFiatAmount(),
+        fiatCurrency = appCurrency
+    )
+}
+
+private fun List<WalletData>.findTotalBalanceState(): TotalBalance.State {
+    return this.mapToTotalBalanceState()
+        .fold(initial = TotalBalance.State.Loading) { accState, newState ->
+            accState or newState
+        }
+}
+
+private fun List<WalletData>.calculateTotalFiatAmount(): BigDecimal {
+    return this.map { it.currencyData.fiatAmount ?: BigDecimal.ZERO }
+        .reduce(BigDecimal::plus)
+}
+
+private fun List<WalletData>.mapToTotalBalanceState(): List<TotalBalance.State> {
+    return this.map {
+        when (it.currencyData.status) {
+            BalanceStatus.VerifiedOnline,
+            BalanceStatus.SameCurrencyTransactionInProgress,
+            BalanceStatus.TransactionInProgress -> TotalBalance.State.Success
+            BalanceStatus.Unreachable,
+            BalanceStatus.NoAccount,
+            BalanceStatus.EmptyCard,
+            BalanceStatus.UnknownBlockchain -> TotalBalance.State.SomeTokensFailed
+            BalanceStatus.Loading,
+            null -> TotalBalance.State.Loading
+        }
+    }
+}
+
+infix fun TotalBalance.State.or(newState: TotalBalance.State): TotalBalance.State {
+    return when (this) {
+        TotalBalance.State.Loading -> when (newState) {
+            TotalBalance.State.Loading -> this
+            TotalBalance.State.SomeTokensFailed,
+            TotalBalance.State.Success -> newState
+        }
+        TotalBalance.State.Success,
+        TotalBalance.State.SomeTokensFailed -> when (newState) {
+            TotalBalance.State.Loading,
+            TotalBalance.State.SomeTokensFailed -> newState
+            TotalBalance.State.Success -> this
+        }
+    }
+}

app/src/main/java/com/tangem/tap/features/wallet/redux/reducers/WalletReducer.kt

@@ -3,6 +3,7 @@ package com.tangem.tap.features.wallet.redux.reducers
 import com.tangem.blockchain.common.AmountType
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.Wallet
+import com.tangem.common.extensions.mapNotNullValues
 import com.tangem.domain.common.TwinCardNumber
 import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.common.extensions.toFiatRateString
@@ -14,13 +15,26 @@ import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.extensions.getArtworkUrl
 import com.tangem.tap.domain.getFirstToken
 import com.tangem.tap.domain.tokens.BlockchainNetwork
-import com.tangem.tap.features.wallet.models.WalletRent
-import com.tangem.tap.features.wallet.redux.*
+import com.tangem.tap.features.wallet.redux.AddressData
+import com.tangem.tap.features.wallet.redux.Artwork
+import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.redux.ErrorType
+import com.tangem.tap.features.wallet.redux.ProgressState
+import com.tangem.tap.features.wallet.redux.TradeCryptoState
+import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.features.wallet.redux.WalletAddresses
+import com.tangem.tap.features.wallet.redux.WalletData
+import com.tangem.tap.features.wallet.redux.WalletDialog
+import com.tangem.tap.features.wallet.redux.WalletMainButton
+import com.tangem.tap.features.wallet.redux.WalletRent
+import com.tangem.tap.features.wallet.redux.WalletState
+import com.tangem.tap.features.wallet.redux.WalletStore
 import com.tangem.tap.features.wallet.ui.BalanceStatus
 import com.tangem.tap.features.wallet.ui.BalanceWidgetData
 import com.tangem.tap.store
-import org.rekotlin.Action
 import java.math.BigDecimal
+import java.math.RoundingMode
+import org.rekotlin.Action
 
 class WalletReducer {
     companion object {
@@ -32,6 +46,7 @@ private fun internalReduce(action: Action, state: AppState): WalletState {
 
     val multiWalletReducer = MultiWalletReducer()
     val onWalletLoadedReducer = OnWalletLoadedReducer()
+    val appCurrencyReducer = AppCurrencyReducer()
 
     if (action !is WalletAction) return state.walletState
 
@@ -260,7 +275,7 @@ private fun internalReduce(action: Action, state: AppState): WalletState {
         }
 
         is WalletAction.LoadFiatRate.Success ->
-            newState = setNewFiatRate(action.fiatRate, state.globalState.appCurrency, newState)
+            newState = setNewFiatRate(action.fiatRates, state.globalState.appCurrency, newState)
         is WalletAction.LoadArtwork -> {
             val artworkUrl = action.card.getArtworkUrl(action.artworkId)
                 ?: when (state.twinCardsState.cardNumber) {
@@ -314,6 +329,9 @@ private fun internalReduce(action: Action, state: AppState): WalletState {
             val walletsData = walletStore.walletsData.map { it.copy(walletRent = null) }
             newState = newState.updateWalletsData(walletsData)
         }
+        is WalletAction.AppCurrencyAction -> {
+            newState = appCurrencyReducer.reduce(action, newState)
+        }
         else -> { /* no-op */
         }
     }
@@ -369,50 +387,71 @@ private fun handleCheckSignedHashesActions(
 
 
 private fun setNewFiatRate(
-    fiatRate: Pair<Currency, BigDecimal?>,
+    fiatRates: Map<Currency, BigDecimal?>,
     appCurrency: FiatCurrency,
     state: WalletState
 ): WalletState {
-    val rate = fiatRate.second ?: return state
-    val rateFormatted = rate.toFiatRateString(
-        fiatCurrencyName = appCurrency.symbol
-    )
-    val currency = fiatRate.first
+    val rateFormatter: (BigDecimal) -> String = { rate: BigDecimal ->
+        rate.toFiatRateString(
+            fiatCurrencyName = appCurrency.symbol
+        )
+    }
 
-    return if (!state.isMultiwalletAllowed) {
-        setSingleWalletFiatRate(rate, rateFormatted, currency, appCurrency, state)
+    return if (state.isMultiwalletAllowed) {
+        setMultiWalletFiatRate(
+            fiatRates = fiatRates.mapNotNullValues { it.value },
+            rateFormatter = rateFormatter,
+            appCurrency = appCurrency,
+            state = state
+        )
     } else {
-        setMultiWalletFiatRate(rate, rateFormatted, currency, appCurrency, state)
+        val fiatRate = fiatRates.entries.firstOrNull()
+        val currency = fiatRate?.key ?: return state
+        val rate = fiatRate.value ?: return state
+
+        setSingleWalletFiatRate(
+            rate = rate,
+            rateFormatted = rateFormatter(rate),
+            currency = currency,
+            appCurrency = appCurrency,
+            state = state
+        )
     }
 }
 
 private fun setMultiWalletFiatRate(
-    rate: BigDecimal,
-    rateFormatted: String,
-    currency: Currency,
+    fiatRates: Map<Currency, BigDecimal>,
+    rateFormatter: (BigDecimal) -> String,
     appCurrency: FiatCurrency,
     state: WalletState
 ): WalletState {
+    val newWalletsData = fiatRates.mapNotNull { (currency, rate) ->
+        val walletStore = state.getWalletStore(currency) ?: return state
+        val wallet = walletStore.walletManager?.wallet
+        val walletData = state.getWalletData(currency) ?: return state
 
-    val walletStore = state.getWalletStore(currency) ?: return state
-    val wallet = walletStore.walletManager?.wallet
-    val walletData = state.getWalletData(currency) ?: return state
-
-    val fiatAmount = when (currency) {
-        is Currency.Blockchain ->
-            wallet?.amounts?.get(AmountType.Coin)?.value?.toFiatValue(rate)
-        is Currency.Token ->
-            wallet?.getTokenAmount(currency.token)?.value?.toFiatValue(rate)
+        val fiatAmount = when (currency) {
+            is Currency.Blockchain ->
+                wallet?.amounts?.get(AmountType.Coin)?.value?.toFiatValue(rate)
+            is Currency.Token ->
+                wallet?.getTokenAmount(currency.token)?.value?.toFiatValue(rate)
+        }
+        val fiatAmountFormatted = fiatAmount?.toFormattedFiatValue(appCurrency.symbol)
+        state.getWalletData(currency)?.copy(
+            currencyData = walletData.currencyData.copy(
+                fiatAmountFormatted = fiatAmountFormatted,
+                fiatAmount = fiatAmount
+            ),
+            fiatRate = rate,
+            fiatRateString = rateFormatter(rate)
+        )
     }
-    val fiatAmountFormatted = fiatAmount?.toFormattedFiatValue(appCurrency.symbol)
-    val newWalletData = state.getWalletData(currency)?.copy(
-        currencyData = walletData.currencyData.copy(
-            fiatAmountFormatted = fiatAmountFormatted,
-            fiatAmount = fiatAmount
-        ),
-        fiatRate = rate, fiatRateString = rateFormatted
-    )
-    return state.updateWalletData(newWalletData)
+
+    return state
+        .updateWalletsData(newWalletsData)
+        .updateTotalBalance(
+            totalBalance = obtainTotalBalance(newWalletsData, appCurrency)
+        )
 }
 
 private fun setSingleWalletFiatRate(

app/src/main/java/com/tangem/tap/features/wallet/ui/WalletFragment.kt

@@ -178,8 +178,6 @@ class WalletFragment : Fragment(R.layout.fragment_wallet), StoreSubscriber<Walle
                         scanNoteResponse,
                         store.state.walletState.walletManagers.map { it.wallet },
                         CardTou(),
-                        store.state.globalState.appCurrency,
-                        tangemTechService = store.state.domainNetworks.tangemTechService
                     ))
                     store.dispatch(NavigationAction.NavigateTo(AppScreen.Details))
                     true

app/src/main/java/com/tangem/tap/features/wallet/ui/wallet/CurrencySelectionDialog.kt

@@ -0,0 +1,41 @@
+package com.tangem.tap.features.wallet.ui.wallet
+
+import android.content.Context
+import androidx.appcompat.app.AlertDialog
+import com.tangem.tap.common.extensions.dispatchDialogHide
+import com.tangem.tap.common.redux.AppDialog
+import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.store
+import com.tangem.wallet.R
+
+object CurrencySelectionDialog {
+    fun create(
+        dialog: AppDialog.CurrencySelectionDialog,
+        context: Context
+    ): AlertDialog {
+        val currenciesToShow = dialog.currenciesList
+            .map { it.displayName }
+            .toTypedArray()
+        var currentSelection = dialog.currenciesList
+            .indexOfFirst { it.code == dialog.currentAppCurrency.code }
+
+        return AlertDialog.Builder(context)
+            .setTitle(context.getString(R.string.details_row_title_currency))
+            .setNegativeButton(context.getString(R.string.common_cancel)) { _, _ -> /* no-op */ }
+            .setPositiveButton(context.getString(R.string.common_done)) { _, _ ->
+                val selectedCurrency = dialog.currenciesList[currentSelection]
+                store.dispatch(
+                    WalletAction.AppCurrencyAction.SelectAppCurrency(
+                        fiatCurrency = selectedCurrency
+                    )
+                )
+            }
+            .setOnDismissListener {
+                store.dispatchDialogHide()
+            }
+            .setSingleChoiceItems(currenciesToShow, currentSelection) { _, which ->
+                currentSelection = which
+            }
+            .create()
+    }
+}

app/src/main/java/com/tangem/tap/features/wallet/ui/wallet/MultiWalletView.kt

@@ -158,7 +158,7 @@ class MultiWalletView : WalletView {
         tvCurrencyName.text = totalBalance.fiatCurrency.code
 
         tvCurrencyName.setOnClickListener {
-            // TODO: Open app currency selector
+            store.dispatch(WalletAction.AppCurrencyAction.ChooseAppCurrency)
         }
     }