Updated on 2026-08-14

2022-06-29 16:42:56 +03:00 · 2022-06-29 16:42:56 +03:00 · 7593bd0c36
commit 7593bd0c36
parent 6dbda3439d bdbe0068a0
94 changed files with 1146 additions and 974 deletions
--- a/app/src/main/java/com/tangem/tap/TapApplication.kt
+++ b/app/src/main/java/com/tangem/tap/TapApplication.kt
@ -1,6 +1,8 @@
 package com.tangem.tap

 import android.app.Application
+import coil.ImageLoader
+import coil.ImageLoaderFactory
 import com.appsflyer.AppsFlyerLib
 import com.google.firebase.ktx.Firebase
 import com.google.firebase.remoteconfig.ktx.remoteConfig
@ -10,7 +12,7 @@ import com.tangem.blockchain.network.BlockchainSdkRetrofitBuilder
 import com.tangem.domain.DomainLayer
 import com.tangem.network.common.MoshiConverter
 import com.tangem.tap.common.analytics.GlobalAnalyticsHandler
-import com.tangem.tap.common.images.PicassoHelper
+import com.tangem.tap.common.images.createCoilImageLoader
 import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.common.redux.appReducer
 import com.tangem.tap.common.redux.global.GlobalAction
@ -43,7 +45,7 @@ lateinit var currenciesRepository: CurrenciesRepository
 lateinit var walletConnectRepository: WalletConnectRepository
 lateinit var shopService: TangemShopService

-class TapApplication : Application() {
+class TapApplication : Application(), ImageLoaderFactory {
    override fun onCreate() {
        super.onCreate()

@ -61,7 +63,6 @@ class TapApplication : Application() {

        NetworkConnectivity.createInstance(store, this)
        preferencesStorage = PreferencesStorage(this)
-        PicassoHelper.initPicassoWithCaching(this)
        currenciesRepository = CurrenciesRepository(
            this, store.state.domainNetworks.tangemTechService
        )
@ -75,6 +76,10 @@ class TapApplication : Application() {
        initAppsFlyer()
    }

+    override fun newImageLoader(): ImageLoader {
+        return createCoilImageLoader(context = this)
+    }
+
    private fun loadConfigs() {
        val moshi = MoshiConverter.defaultMoshi()
        val localLoader = FeaturesLocalLoader(this, moshi)
@ -108,11 +113,6 @@ class TapApplication : Application() {
 }

 data class LogConfig(
-    // disables both [internal, http]
-    val picasso: Boolean = BuildConfig.DEBUG,
-    val picassoInternal: Boolean = true,
-    val picassoHttp: Boolean = true,
-
+    val coil: Boolean = BuildConfig.DEBUG,
    val storeAction: Boolean = BuildConfig.DEBUG,
-
 )
--- a/app/src/main/java/com/tangem/tap/common/DialogManager.kt
+++ b/app/src/main/java/com/tangem/tap/common/DialogManager.kt
@ -4,13 +4,10 @@ import android.app.Dialog
 import android.content.Context
 import com.tangem.tap.common.redux.AppDialog
 import com.tangem.tap.common.redux.global.GlobalState
+import com.tangem.tap.common.ui.SimpleAlertDialog
+import com.tangem.tap.common.ui.SimpleCancelableAlertDialog
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectDialog
-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.details.ui.walletconnect.dialogs.*
 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
@ -19,12 +16,8 @@ import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.AddMoreBack
 import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.BackupInProgressDialog
 import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.ConfirmDiscardingBackupDialog
 import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.UnfinishedBackupFoundDialog
-import com.tangem.tap.features.wallet.redux.WalletDialog
-import com.tangem.tap.features.wallet.ui.dialogs.AmountToSendBottomSheetDialog
-import com.tangem.tap.features.wallet.ui.dialogs.ChooseTradeActionBottomSheetDialog
-import com.tangem.tap.features.wallet.ui.dialogs.ScanFailsDialog
-import com.tangem.tap.features.wallet.ui.dialogs.SignedHashesWarningDialog
-import com.tangem.tap.features.wallet.ui.dialogs.SimpleOkDialog
+import com.tangem.tap.features.wallet.redux.models.WalletDialog
+import com.tangem.tap.features.wallet.ui.dialogs.*
 import com.tangem.tap.features.wallet.ui.wallet.CurrencySelectionDialog
 import com.tangem.tap.store
 import com.tangem.wallet.R
@ -72,6 +65,15 @@ class DialogManager : StoreSubscriber<GlobalState> {
                    messageRes = R.string.wallet_connect_scanner_error_no_ethereum_wallet,
                    context = context
                )
+            is WalletConnectDialog.AddNetwork ->
+                SimpleAlertDialog.create(
+                    titleRes = R.string.wallet_connect,
+                    message = context.getString(
+                        R.string.wallet_connect_network_not_found_format,
+                        state.dialog.network
+                    ),
+                    context = context
+                )
            is WalletConnectDialog.OpeningSessionRejected -> {
                SimpleAlertDialog.create(
                    titleRes = R.string.wallet_connect,
@ -115,6 +117,20 @@ class DialogManager : StoreSubscriber<GlobalState> {
                AmountToSendBottomSheetDialog(context, state.dialog)
            is WalletDialog.SignedHashesMultiWalletDialog ->
                SignedHashesWarningDialog.create(context)
+            is WalletDialog.TokensAreLinkedDialog -> SimpleAlertDialog.create(
+                title = context.getString(state.dialog.titleRes, state.dialog.currencySymbol),
+                message = context.getString(
+                    state.dialog.messageRes, state.dialog.currencySymbol, state.dialog.currencyTitle
+                ),
+                context = context,
+            )
+            is WalletDialog.RemoveWalletDialog -> SimpleCancelableAlertDialog.create(
+                title = context.getString(state.dialog.titleRes, state.dialog.currencyTitle),
+                messageRes = state.dialog.messageRes,
+                context = context,
+                primaryButtonRes = state.dialog.primaryButtonRes,
+                primaryButtonAction = state.dialog.action
+            )
            else -> null
        }
        dialog?.show()
--- a/app/src/main/java/com/tangem/tap/common/extensions/Blockchain.kt
+++ b/app/src/main/java/com/tangem/tap/common/extensions/Blockchain.kt
@ -62,6 +62,7 @@ fun Blockchain.getNetworkName(): String {
        Blockchain.Ethereum, Blockchain.EthereumTestnet -> "ERC20"
        Blockchain.BSC, Blockchain.BSCTestnet -> "BEP20"
        Blockchain.Binance, Blockchain.BinanceTestnet -> "BEP2"
+        Blockchain.Tron, Blockchain.TronTestnet -> "TRC20"
        else -> ""
    }
 }
--- a/app/src/main/java/com/tangem/tap/common/extensions/Picasso.kt
+++ b/app/src/main/java/com/tangem/tap/common/extensions/Picasso.kt
@ -1,135 +0,0 @@
-package com.tangem.tap.common.extensions
-
-import android.graphics.*
-import android.widget.TextView
-import androidx.constraintlayout.utils.widget.ImageFilterView
-import com.squareup.picasso.Callback
-import com.squareup.picasso.Picasso
-import com.squareup.picasso.Transformation
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.blockchain.common.IconsUtil
-import com.tangem.blockchain.common.Token
-import com.tangem.domain.common.extensions.toNetworkId
-import com.tangem.tap.domain.extensions.getCustomIconUrl
-import com.tangem.tap.domain.tokens.getIconUrl
-import com.tangem.wallet.R
-
-fun Picasso.loadCurrenciesIcon(
-    imageView: ImageFilterView,
-    textView: TextView,
-    token: Token? = null,
-    blockchain: Blockchain,
-) {
-
-    val url: String? = if (token != null) {
-        token.id?.let { getIconUrl(it) } ?: token.getCustomIconUrl()
-        ?: IconsUtil.getTokenIconUri(blockchain, token)?.toString()
-    } else {
-        getIconUrl(blockchain.toNetworkId())
-    }
-
-    imageView.setImageDrawable(null)
-    imageView.colorFilter = null
-    textView.text = null
-
-    when {
-        token?.symbol == QCX -> {
-            this.load(R.drawable.ic_qcx)?.into(imageView)
-        }
-        token?.symbol == VOYR -> {
-            this.load(R.drawable.ic_voyr)?.into(imageView)
-        }
-        url != null -> {
-            if (token != null) {
-                setTokenImage(imageView, textView, token, blockchain)
-            }
-            this.load(url)
-                .transform(RoundedCornersTransform())
-                .noPlaceholder()
-                ?.into(imageView,
-                    object : Callback {
-                        override fun onError(e: Exception?) {
-                            setOfflineCurrencyImage(imageView, textView, token, blockchain)
-                        }
-
-                        override fun onSuccess() {
-                            if (token != null) {
-                                imageView.colorFilter = null
-                                textView.text = null
-                            }
-                            if (blockchain.isTestnet()) imageView.saturation = 0f
-                        }
-                    })
-        }
-        else -> {
-            setOfflineCurrencyImage(imageView, textView, token, blockchain)
-        }
-    }
-}
-
-private const val QCX = "QCX"
-private const val VOYR = "VOYRME"
-
-private fun setOfflineCurrencyImage(
-    imageView: ImageFilterView,
-    textView: TextView,
-    token: Token?,
-    blockchain: Blockchain,
-) {
-    when (token) {
-        null -> setBlockchainImage(imageView, textView, blockchain)
-        else -> setTokenImage(imageView, textView, token, blockchain)
-    }
-}
-
-private fun setBlockchainImage(
-    imageView: ImageFilterView,
-    textView: TextView,
-    blockchain: Blockchain,
-) {
-    imageView.setImageResource(blockchain.getRoundIconRes())
-    imageView.colorFilter = null
-    if (blockchain.isTestnet()) imageView.saturation = 0f
-    textView.text = null
-}
-
-private fun setTokenImage(
-    imageView: ImageFilterView,
-    textView: TextView,
-    token: Token,
-    tokenBlockchain: Blockchain
-) {
-    imageView.setImageResource(R.drawable.shape_circle)
-    if (tokenBlockchain.isTestnet()) {
-        imageView.saturation = 0f
-    } else {
-        imageView.setColorFilter(token.getColor())
-    }
-    textView.text = token.symbol.take(1)
-}
-
-private class RoundedCornersTransform : Transformation {
-
-    override fun transform(source: Bitmap): Bitmap {
-        val size = source.width.coerceAtMost(source.height)
-        val x = (source.width - size) / 2
-        val y = (source.height - size) / 2
-        val squaredBitmap = Bitmap.createBitmap(source, x, y, size, size)
-        if (squaredBitmap != source) source.recycle()
-
-        val paint = Paint().apply {
-            shader = BitmapShader(squaredBitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP)
-            isAntiAlias = true
-        }
-
-        val rectF = RectF(0f, 0f, source.width.toFloat(), source.height.toFloat())
-        val radius = size / 8f
-        val bitmap = Bitmap.createBitmap(size, size, source.config)
-        Canvas(bitmap).drawRoundRect(rectF, radius, radius, paint)
-        squaredBitmap.recycle()
-
-        return bitmap
-    }
-
-    override fun key(): String = "rounded_corners"
-}
--- a/app/src/main/java/com/tangem/tap/common/extensions/Specific.kt
+++ b/app/src/main/java/com/tangem/tap/common/extensions/Specific.kt
@ -53,8 +53,7 @@ fun BigDecimal.toFiatString(
    fiatCurrencyName: String,
    formatWithSpaces: Boolean = false
 ): String {
-    var fiatValue = rateValue.multiply(this)
-    fiatValue = fiatValue.setScale(2, RoundingMode.HALF_UP)
+    val fiatValue = rateValue.multiply(this)
    return fiatValue.toFormattedFiatValue(fiatCurrencyName, formatWithSpaces)
 }

@ -67,7 +66,8 @@ fun BigDecimal.toFormattedFiatValue(
    fiatCurrencyName: String,
    formatWithSpaces: Boolean = false
 ): String {
-    val fiatValue = if (formatWithSpaces) this.formatWithSpaces() else this
+    val fiatValue = this.setScale(2, RoundingMode.HALF_UP)
+        .let { if (formatWithSpaces) it.formatWithSpaces() else it }
    return " ${fiatValue}  $fiatCurrencyName"
 }

--- a/app/src/main/java/com/tangem/tap/common/extensions/Token.kt
+++ b/app/src/main/java/com/tangem/tap/common/extensions/Token.kt
@ -1,6 +1,8 @@
 package com.tangem.tap.common.extensions

+import android.graphics.Color
 import androidx.annotation.ColorInt
+import androidx.core.graphics.luminance
 import androidx.core.graphics.toColorInt
 import com.tangem.blockchain.common.Token
 import com.tangem.wallet.R
@ -9,8 +11,13 @@ import com.tangem.wallet.R
 fun Token.getColor(): Int {
    return try {
        ("#" + this.contractAddress.subSequence(2..7).toString())
-                .toColorInt()
+            .toColorInt()
    } catch (exception: Exception) {
        R.color.lightGray4
    }
+}
+
+@ColorInt
+fun Token.getTextColor(): Int {
+    return if (this.getColor().luminance > 0.5) Color.BLACK else Color.WHITE
 }
--- a/app/src/main/java/com/tangem/tap/common/images/Coil.kt
+++ b/app/src/main/java/com/tangem/tap/common/images/Coil.kt
@ -0,0 +1,50 @@
+package com.tangem.tap.common.images
+
+import android.content.Context
+import android.util.Log
+import coil.ImageLoader
+import coil.util.Logger
+import com.tangem.tap.logConfig
+import okhttp3.OkHttpClient
+import okhttp3.logging.HttpLoggingInterceptor
+import timber.log.Timber
+
+private const val COIL_LOG_TAG = "COIL"
+
+fun createCoilImageLoader(
+    context: Context
+): ImageLoader {
+    return ImageLoader.Builder(context)
+        .apply {
+            if (!logConfig.coil) return@apply
+
+            logger(CoilTimberLogger())
+            okHttpClient {
+                OkHttpClient.Builder()
+                    .addNetworkInterceptor(
+                        HttpLoggingInterceptor { message ->
+                            Timber.tag(COIL_LOG_TAG).d(message)
+                        }
+                            .apply {
+                                level = HttpLoggingInterceptor.Level.BODY
+                            }
+                    )
+                    .build()
+
+            }
+        }
+        .build()
+}
+
+
+private class CoilTimberLogger : Logger {
+
+    override var level: Int = Log.DEBUG
+
+    override fun log(tag: String, priority: Int, message: String?, throwable: Throwable?) {
+        with(Timber.tag(COIL_LOG_TAG)) {
+            throwable?.let { e -> e(e, message) }
+            message?.let { msg -> d(msg) }
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/common/images/Picasso.kt
+++ b/app/src/main/java/com/tangem/tap/common/images/Picasso.kt
@ -1,68 +0,0 @@
-package com.tangem.tap.common.images
-
-import android.app.Application
-import com.squareup.picasso.OkHttp3Downloader
-import com.squareup.picasso.Picasso
-import com.tangem.tap.logConfig
-import com.tangem.wallet.BuildConfig
-import okhttp3.Cache
-import okhttp3.CacheControl
-import okhttp3.OkHttpClient
-import okhttp3.logging.HttpLoggingInterceptor
-import timber.log.Timber
-import java.io.File
-import java.util.concurrent.TimeUnit
-
-class PicassoHelper {
-    companion object {
-        private const val KEEP_CACHE_MAX_DAYS = 7
-
-        fun initPicassoWithCaching(application: Application) {
-            val picasso = Picasso.Builder(application)
-                .downloader(OkHttp3Downloader(getOkHttpForPicasso(application)))
-                .build()
-            picasso.isLoggingEnabled = logIsEnabled()
-            picasso.setIndicatorsEnabled(BuildConfig.DEBUG)
-            Picasso.setSingletonInstance(picasso)
-        }
-
-        private fun getOkHttpForPicasso(application: Application): OkHttpClient {
-            return OkHttpClient.Builder().apply {
-                cache(Cache(File(application.filesDir, "artworks"), Long.MAX_VALUE))
-                callTimeout(15000, TimeUnit.MILLISECONDS)
-
-                if (logIsEnabled()) {
-                    addDebugInterceptors(this)
-                }
-
-                addInterceptor { chain ->
-                    val cacheControl = CacheControl.Builder()
-                        .maxStale(KEEP_CACHE_MAX_DAYS, TimeUnit.DAYS)
-                        .build()
-                    val origRequest = chain.request()
-                    val neverExpireRequest = origRequest.newBuilder()
-                        .cacheControl(cacheControl)
-                        .build()
-                    chain.proceed(neverExpireRequest)
-                }
-            }.build()
-
-        }
-
-        private fun addDebugInterceptors(okHttpBuilder: OkHttpClient.Builder) {
-            val picassoInterceptor = HttpLoggingInterceptor(PicassoOkHttpLogger()).apply {
-                level = HttpLoggingInterceptor.Level.BODY
-            }
-            okHttpBuilder.addInterceptor(picassoInterceptor)
-        }
-
-        private fun logIsEnabled(): Boolean = BuildConfig.DEBUG && logConfig.picasso
-
-    }
-}
-
-private class PicassoOkHttpLogger : HttpLoggingInterceptor.Logger {
-    override fun log(message: String) {
-        Timber.d(message)
-    }
-}
--- a/app/src/main/java/com/tangem/tap/common/redux/StateDialog.kt
+++ b/app/src/main/java/com/tangem/tap/common/redux/StateDialog.kt
@ -2,8 +2,8 @@ package com.tangem.tap.common.redux

 import com.tangem.common.extensions.VoidCallback
 import com.tangem.tap.common.TestAction
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.AddressData
-import com.tangem.tap.features.wallet.redux.Currency

 /**
 [REDACTED_AUTHOR]
--- a/app/src/main/java/com/tangem/tap/common/shop/TangemShopService.kt
+++ b/app/src/main/java/com/tangem/tap/common/shop/TangemShopService.kt
@ -5,6 +5,7 @@ import android.content.Intent
 import com.google.android.gms.wallet.PaymentData
 import com.shopify.buy3.Storefront
 import com.tangem.tap.common.analytics.AnalyticsHandler
+import com.tangem.tap.common.extensions.filterNotNull
 import com.tangem.tap.common.shop.data.ProductType
 import com.tangem.tap.common.shop.data.TangemProduct
 import com.tangem.tap.common.shop.data.TotalSum
@ -21,7 +22,6 @@ class TangemShopService(application: Application, shopifyShop: ShopifyShop) {

    private val shopifyService = ShopifyService(application, shopifyShop)

-    private lateinit var product: Storefront.Product

    private val checkouts = mutableMapOf<ProductType, Storefront.Checkout>()
    private val variants = mutableMapOf<ProductType, Storefront.ProductVariant>()
@ -31,22 +31,19 @@ class TangemShopService(application: Application, shopifyShop: ShopifyShop) {
    suspend fun getProducts(): Result<List<TangemProduct>> {
        val result = shopifyService.getProducts()

-        result.onSuccess {
-            product = it.first {
-                val variantsSku = it.variants.edges.map { it.node.sku }
-                variantsSku.contains(ProductType.WALLET_2_CARDS.sku) && variantsSku.contains(
-                    ProductType.WALLET_3_CARDS.sku
-                )
-            }
-            product.variants.edges.map { it.node }
-                .forEach { variant ->
-                    if (variant.sku == ProductType.WALLET_2_CARDS.sku) {
-                        variants[ProductType.WALLET_2_CARDS] = variant
-                    } else if (variant.sku == ProductType.WALLET_3_CARDS.sku) {
-                        variants[ProductType.WALLET_3_CARDS] = variant
-                    }
-                }
+        return result.mapCatching { product ->
+            val availableVariants = product
+                .flatMap { it.variants.edges.map { it.node } }
+                .filter { SKUS_TO_DISPLAY.contains(it.sku) }
+                .associateBy { ProductType.fromSku(it.sku) }
+                .filterNotNull()
+            variants.putAll(availableVariants)

+            if (variants.size < SKUS_TO_DISPLAY.size) {
+                return Result.failure(Exception(
+                    "Shopify: products are missing, " +
+                            "\nproducts available: ${variants.keys.map { it.sku }}"))
+            }

            val twoCardsProduct = TangemProduct(
                type = ProductType.WALLET_2_CARDS,
@ -65,7 +62,6 @@ class TangemShopService(application: Application, shopifyShop: ShopifyShop) {
            createCheckouts()
            return Result.success(listOf(twoCardsProduct, threeCardsProduct))
        }
-        return Result.failure(result.exceptionOrNull()!!)
    }

    private suspend fun createCheckouts() {
@ -214,6 +210,7 @@ class TangemShopService(application: Application, shopifyShop: ShopifyShop) {
    companion object {
        const val TANGEM_WALLET_2_CARDS_SKU = "TG115x2"
        const val TANGEM_WALLET_3_CARDS_SKU = "TG115x3"
+        val SKUS_TO_DISPLAY = listOf(TANGEM_WALLET_2_CARDS_SKU, TANGEM_WALLET_3_CARDS_SKU)
    }
 }

--- a/app/src/main/java/com/tangem/tap/common/shop/data/ProductType.kt
+++ b/app/src/main/java/com/tangem/tap/common/shop/data/ProductType.kt
@ -4,5 +4,15 @@ import com.tangem.tap.common.shop.TangemShopService

 enum class ProductType(val sku: String) {
    WALLET_2_CARDS(TangemShopService.TANGEM_WALLET_2_CARDS_SKU),
-    WALLET_3_CARDS(TangemShopService.TANGEM_WALLET_3_CARDS_SKU)
+    WALLET_3_CARDS(TangemShopService.TANGEM_WALLET_3_CARDS_SKU);
+
+    companion object {
+        fun fromSku(sku: String): ProductType? {
+            return when (sku) {
+                WALLET_2_CARDS.sku -> WALLET_2_CARDS
+                WALLET_3_CARDS.sku -> WALLET_3_CARDS
+                else -> null
+            }
+        }
+    }
 }
--- a/app/src/main/java/com/tangem/tap/common/ui/SimpleAlertDialog.kt
+++ b/app/src/main/java/com/tangem/tap/common/ui/SimpleAlertDialog.kt
@ -0,0 +1,59 @@
+package com.tangem.tap.common.ui
+
+import android.content.Context
+import androidx.appcompat.app.AlertDialog
+import com.tangem.tap.common.redux.global.GlobalAction
+import com.tangem.tap.store
+import com.tangem.wallet.R
+
+class SimpleAlertDialog {
+    companion object {
+        fun create(
+            titleRes: Int? = null,
+            messageRes: Int? = null,
+            title: String? = null,
+            message: String? = null,
+            primaryButtonRes: Int = R.string.common_ok,
+            context: Context,
+        ): AlertDialog {
+            return SimpleCancelableAlertDialog.create(
+                titleRes = titleRes,
+                messageRes = messageRes,
+                title = title,
+                message = message,
+                primaryButtonRes = primaryButtonRes,
+                secondaryButtonRes = null,
+                context = context
+            )
+        }
+    }
+}
+
+class SimpleCancelableAlertDialog {
+    companion object {
+        fun create(
+            titleRes: Int? = null,
+            messageRes: Int? = null,
+            title: String? = null,
+            message: String? = null,
+            primaryButtonRes: Int = R.string.common_ok,
+            secondaryButtonRes: Int? = R.string.common_cancel,
+            primaryButtonAction: () -> Unit = {},
+            secondaryButtonAction: () -> Unit = {},
+            context: Context,
+        ): AlertDialog {
+
+            return AlertDialog.Builder(context).apply {
+                setTitle(titleRes?.let { context.getString(it) } ?: title )
+                setMessage(messageRes?.let { context.getString(it) } ?: message)
+                setPositiveButton(context.getText(primaryButtonRes)) { _, _ -> primaryButtonAction() }
+                if (secondaryButtonRes != null) {
+                    setNegativeButton(context.getText(secondaryButtonRes)) { _, _ -> secondaryButtonAction()}
+                }
+                setOnDismissListener {
+                    store.dispatch(GlobalAction.HideDialog)
+                }
+            }.create()
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/domain/RatesRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/RatesRepository.kt
@ -3,7 +3,7 @@ package com.tangem.tap.domain
 import com.tangem.common.services.Result
 import com.tangem.domain.common.ThrottlerWithValues
 import com.tangem.network.api.tangemTech.TangemTechService
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.store
 import java.math.BigDecimal

--- a/app/src/main/java/com/tangem/tap/domain/TapWalletManager.kt
+++ b/app/src/main/java/com/tangem/tap/domain/TapWalletManager.kt
@ -26,7 +26,7 @@ import kotlinx.coroutines.withContext

 class TapWalletManager {
    val walletManagerFactory: WalletManagerFactory
-        by lazy { WalletManagerFactory(blockchainSdkConfig) }
+            by lazy { WalletManagerFactory(blockchainSdkConfig) }

    val rates: RatesRepository = RatesRepository()

@ -34,10 +34,10 @@ class TapWalletManager {
        store.state.globalState.configManager?.config?.blockchainSdkConfig ?: BlockchainSdkConfig()
    }

-    private val walletManagersThrottler = ThrottlerWithValues<BlockchainNetwork, Result<Wallet>>(10000)
+    private val walletManagersThrottler =
+        ThrottlerWithValues<BlockchainNetwork, Result<Wallet>>(10000)

    suspend fun loadWalletData(walletManager: WalletManager) {
-        val blockchain = walletManager.wallet.blockchain
        val blockchainNetwork = BlockchainNetwork.fromWalletManager(walletManager)
        val result = if (walletManagersThrottler.isStillThrottled(blockchainNetwork)) {
            walletManagersThrottler.geValue(blockchainNetwork)!!
@ -54,17 +54,21 @@ class TapWalletManager {
            is Result.Failure -> {
                when (result.error) {
                    is TapError.WalletManager.NoAccountError -> {
-                        dispatchOnMain(WalletAction.LoadWallet.NoAccount(
-                            walletManager.wallet,
-                            blockchainNetwork,
-                            (result.error as TapError.WalletManager.NoAccountError).customMessage
-                        ))
+                        dispatchOnMain(
+                            WalletAction.LoadWallet.NoAccount(
+                                walletManager.wallet,
+                                blockchainNetwork,
+                                (result.error as TapError.WalletManager.NoAccountError).customMessage
+                            )
+                        )
                    }
                    else -> {
-                        dispatchOnMain(WalletAction.LoadWallet.Failure(
-                            walletManager.wallet,
-                            result.error.localizedMessage
-                        ))
+                        dispatchOnMain(
+                            WalletAction.LoadWallet.Failure(
+                                walletManager.wallet,
+                                result.error.localizedMessage
+                            )
+                        )
                    }
                }
            }
@ -109,6 +113,37 @@ class TapWalletManager {
            return
        }

+        if (data.card.isMultiwalletAllowed) {
+            loadMultiWalletData(data)
+        } else {
+            loadSingleWalletData(data)
+        }
+
+        dispatchOnMain(WalletAction.LoadWallet())
+        dispatchOnMain(WalletAction.LoadFiatRate())
+    }
+
+    private suspend fun loadMultiWalletData(
+        scanResponse: ScanResponse
+    ) {
+        val savedCurrencies = currenciesRepository.loadSavedCurrencies(
+            scanResponse.card.cardId, scanResponse.card.settings.isHDWalletAllowed
+        )
+        if (savedCurrencies.isEmpty()) return
+
+        val walletManagers =
+            walletManagerFactory.makeWalletManagersForApp(scanResponse, savedCurrencies)
+        dispatchOnMain(
+            WalletAction.MultiWallet.AddBlockchains(savedCurrencies, walletManagers),
+        )
+        savedCurrencies.map {
+            if (it.tokens.isNotEmpty()) {
+                dispatchOnMain(WalletAction.MultiWallet.AddTokens(it.tokens, it))
+            }
+        }
+    }
+
+    private suspend fun loadSingleWalletData(data: ScanResponse) {
        val blockchain = data.getBlockchain()
        val primaryWalletManager = walletManagerFactory.makePrimaryWalletManager(data)

@ -120,87 +155,12 @@ class TapWalletManager {
                primaryWalletManager.addToken(primaryToken)
                dispatchOnMain(WalletAction.MultiWallet.SetPrimaryToken(primaryToken))
            }
-            if (data.card.isMultiwalletAllowed) {
-                loadMultiWalletData(data, blockchain, primaryWalletManager)
-            } else {
-                dispatchOnMain(WalletAction.MultiWallet.AddBlockchains(
+            dispatchOnMain(
+                WalletAction.MultiWallet.AddBlockchains(
                    listOf(BlockchainNetwork.fromWalletManager(primaryWalletManager)),
                    listOf(primaryWalletManager)
-                ))
-            }
-        } else {
-            if (data.card.isMultiwalletAllowed) {
-                loadMultiWalletData(data, blockchain, null)
-            }
-        }
-        dispatchOnMain(WalletAction.LoadWallet())
-        dispatchOnMain(WalletAction.LoadFiatRate())
-    }
-
-    private suspend fun loadMultiWalletData(
-        scanResponse: ScanResponse,
-        primaryBlockchain: Blockchain?,
-        primaryWalletManager: WalletManager?
-    ) {
-        val primaryTokens = primaryWalletManager?.cardTokens?.toList() ?: emptyList()
-        val savedCurrencies = currenciesRepository.loadSavedCurrencies(
-            scanResponse.card.cardId, scanResponse.card.settings.isHDWalletAllowed
-        )
-
-        if (savedCurrencies.isEmpty()) {
-            if (primaryBlockchain != null && primaryWalletManager != null) {
-                val blockchainNetwork = BlockchainNetwork.fromWalletManager(primaryWalletManager)
-                dispatchOnMain(
-                    WalletAction.MultiWallet.SaveCurrencies(listOf(blockchainNetwork)),
-                    WalletAction.MultiWallet.AddBlockchains(
-                        listOf(blockchainNetwork),
-                        listOf(primaryWalletManager)
-                    ),
-                    WalletAction.MultiWallet.AddTokens(primaryTokens.toList(), blockchainNetwork)
                )
-
-            } else {
-                val blockchainNetworks = listOf(
-                    BlockchainNetwork(Blockchain.Bitcoin, scanResponse.card),
-                    BlockchainNetwork(Blockchain.Ethereum, scanResponse.card)
-                )
-
-                val walletManagers = walletManagerFactory.makeWalletManagersForApp(
-                    scanResponse,
-                    blockchainNetworks
-                )
-
-                dispatchOnMain(
-                    WalletAction.MultiWallet.SaveCurrencies(blockchainNetworks),
-                    WalletAction.MultiWallet.AddBlockchains(blockchainNetworks, walletManagers),
-                )
-            }
-//            dispatchOnMain(
-//                WalletAction.MultiWallet.FindBlockchainsInUse,
-//                WalletAction.MultiWallet.FindTokensInUse,
-//            )
-        } else {
-            val walletManagers = if (
-                primaryTokens.isNotEmpty() &&
-                primaryWalletManager != null &&
-                primaryBlockchain != null && primaryBlockchain != Blockchain.Unknown
-            ) {
-                val blockchainsWithoutPrimary = savedCurrencies.filterNot { it.blockchain == primaryBlockchain }
-                walletManagerFactory.makeWalletManagersForApp(
-                    scanResponse,
-                    blockchainsWithoutPrimary
-                ).plus(primaryWalletManager)
-            } else {
-                walletManagerFactory.makeWalletManagersForApp(scanResponse, savedCurrencies)
-            }
-            dispatchOnMain(
-                WalletAction.MultiWallet.AddBlockchains(savedCurrencies, walletManagers),
            )
-            savedCurrencies.map {
-                if (it.tokens.isNotEmpty()) {
-                    dispatchOnMain(WalletAction.MultiWallet.AddTokens(it.tokens, it))
-                }
-            }
        }
    }

--- a/app/src/main/java/com/tangem/tap/domain/UrlBitmapLoader.kt
+++ b/app/src/main/java/com/tangem/tap/domain/UrlBitmapLoader.kt
@ -1,49 +0,0 @@
-package com.tangem.tap.domain
-
-import android.graphics.Bitmap
-import android.graphics.drawable.Drawable
-import android.os.Handler
-import android.os.Looper
-import com.squareup.picasso.Picasso
-import com.squareup.picasso.Target
-import com.tangem.common.services.Result
-
-/**
-[REDACTED_AUTHOR]
- */
-class UrlBitmapLoader {
-    private val mainHandler = Handler(Looper.getMainLooper())
-
-    fun loadBitmap(url: String, callback: (Result<Bitmap>) -> Unit) {
-        val target = DownloadTarget(callback)
-        protectedFromGarbageCollectorTargets.add(target)
-        mainHandler.post { Picasso.get().load(url).into(target) }
-    }
-
-    fun loadBitmap(url: String, target: DownloadTarget) {
-        protectedFromGarbageCollectorTargets.add(target)
-        Picasso.get().load(url).into(target)
-    }
-
-}
-
-private val protectedFromGarbageCollectorTargets = mutableListOf<Target>()
-
-// It adds the ability to trigger multiple downloads with a unique callback.
-open class DownloadTarget(
-    val callback: (Result<Bitmap>) -> Unit,
-) : Target {
-
-    override fun onBitmapLoaded(bitmap: Bitmap, from: Picasso.LoadedFrom) {
-        callback(Result.Success(bitmap))
-        protectedFromGarbageCollectorTargets.remove(this)
-    }
-
-    override fun onBitmapFailed(e: Exception?, errorDrawable: Drawable?) {
-        callback.invoke(Result.Failure(e ?: Exception("Unknown exception")))
-        protectedFromGarbageCollectorTargets.remove(this)
-    }
-
-    override fun onPrepareLoad(placeHolderDrawable: Drawable?) {
-    }
-}
--- a/app/src/main/java/com/tangem/tap/domain/extensions/CurrencyExchangeManager.kt
+++ b/app/src/main/java/com/tangem/tap/domain/extensions/CurrencyExchangeManager.kt
@ -2,7 +2,7 @@ package com.tangem.tap.domain.extensions

 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.Blockchain.Arbitrum
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeStatus
 import com.tangem.tap.store
--- a/app/src/main/java/com/tangem/tap/domain/extensions/WalletManagerFactory.kt
+++ b/app/src/main/java/com/tangem/tap/domain/extensions/WalletManagerFactory.kt
@ -11,7 +11,7 @@ import com.tangem.domain.common.ScanResponse
 import com.tangem.domain.common.TapWorkarounds.isTestCard
 import com.tangem.domain.common.TapWorkarounds.useOldStyleDerivation
 import com.tangem.tap.domain.tokens.models.BlockchainNetwork
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.Currency

 fun WalletManagerFactory.makeWalletManagerForApp(
    scanResponse: ScanResponse,
--- a/app/src/main/java/com/tangem/tap/domain/tasks/product/CreateProductWalletTask.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tasks/product/CreateProductWalletTask.kt
@ -112,31 +112,44 @@ private class CreateWalletTangemWallet : ProductCommandProcessor<CreateProductWa
        this.card = card
        val curves = card.getCurvesForNonCreatedWallets()

+        if (curves.isEmpty()) {
+            val createWalletResponses = card.wallets.map { CreateWalletResponse(card.cardId, it) }
+            proceedWithCreatedWallets(createWalletResponses, session, callback)
+            return
+        }
+
        CreateWalletsTask(curves).run(session) { result ->
            when (result) {
                is CompletionResult.Success -> {
-                    val createWalletResponses = result.data.createWalletResponses
-                    when {
-                        card.settings.isBackupAllowed -> {
-                            linkPrimaryCard(createWalletResponses, session, callback)
-                        }
-                        card.settings.isHDWalletAllowed -> {
-                            deriveKeys(createWalletResponses, session, callback)
-                        }
-                        else -> {
-                            callback(
-                                CompletionResult.Success(
-                                    CreateProductWalletTaskResponse(card = session.environment.card!!)
-                                )
-                            )
-                        }
-                    }
+                    proceedWithCreatedWallets(result.data.createWalletResponses, session, callback)
                }
                is CompletionResult.Failure -> callback(CompletionResult.Failure(result.error))
            }
        }
    }

+    private fun proceedWithCreatedWallets(
+        createWalletResponses: List<CreateWalletResponse>,
+        session: CardSession,
+        callback: (result: CompletionResult<CreateProductWalletTaskResponse>) -> Unit,
+    ) {
+        when {
+            card.settings.isBackupAllowed -> {
+                linkPrimaryCard(createWalletResponses, session, callback)
+            }
+            card.settings.isHDWalletAllowed -> {
+                deriveKeys(createWalletResponses, session, callback)
+            }
+            else -> {
+                callback(
+                    CompletionResult.Success(
+                        CreateProductWalletTaskResponse(card = session.environment.card!!)
+                    )
+                )
+            }
+        }
+    }
+
    private fun linkPrimaryCard(
        createWalletResponse: List<CreateWalletResponse>,
        session: CardSession,
--- a/app/src/main/java/com/tangem/tap/domain/tokens/CurrenciesRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tokens/CurrenciesRepository.kt
@ -185,8 +185,9 @@ class CurrenciesRepository(
        tokens.map {
            async {
                tangemNetworkService.getTokens(
-                    it.contractAddress,
-                    it.blockchainDao.toBlockchain().toNetworkId()
+                    contractAddress = it.contractAddress,
+                    networkId = it.blockchainDao.toBlockchain().toNetworkId(),
+                    active = true,
                )
            }
        }.map { it.await() }
--- a/app/src/main/java/com/tangem/tap/domain/tokens/LoadAvailableCoinsService.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tokens/LoadAvailableCoinsService.kt
@ -53,6 +53,7 @@ class LoadAvailableCoinsService(
        val networkIds = supportedBlockchains.toSet().map { it.toNetworkId() }
        return networkService.getListOfCoins(
            networkIds = networkIds,
+            active = true,
            offset = offset,
            limit = LOAD_PER_PAGE,
            searchText = searchInput
--- a/app/src/main/java/com/tangem/tap/domain/walletconnect/WalletConnectRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/walletconnect/WalletConnectRepository.kt
@ -5,11 +5,15 @@ import android.content.Context
 import com.squareup.moshi.JsonAdapter
 import com.squareup.moshi.JsonClass
 import com.squareup.moshi.Types
+import com.tangem.common.extensions.hexToBytes
+import com.tangem.common.extensions.toHexString
 import com.tangem.network.common.MoshiConverter
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectSession
 import com.tangem.tap.features.details.redux.walletconnect.WalletForSession
 import com.trustwallet.walletconnect.models.WCPeerMeta
 import com.trustwallet.walletconnect.models.session.WCSession
+import timber.log.Timber
+import java.nio.charset.Charset

 class WalletConnectRepository(val context: Application) {
    private val moshi = MoshiConverter.defaultMoshi()
@ -35,17 +39,29 @@ class WalletConnectRepository(val context: Application) {
    fun loadSavedSessions(): List<WalletConnectSession> {
        return try {
            val json = context.readFileText(FILE_NAME_PREFIX_SESSIONS)
+                .hexToUtf8()
            walletConnectAdapter.fromJson(json)!!.map { it.toSession() }
        } catch (exception: Exception) {
+            Timber.e(exception)
            emptyList()
        }
    }

    private fun saveSessions(sessions: List<WalletConnectSession>) {
        val json = walletConnectAdapter.toJson(sessions.map { SessionDao.fromSession(it) })
+            .utf8ToHex() // convert to hex to solve problems with saving text with emojis
+        Timber.e("WC sessions, saving following json: $json")
        context.rewriteFile(json, FILE_NAME_PREFIX_SESSIONS)
    }

+    private fun String.utf8ToHex(): String {
+        return this.toByteArray().toHexString()
+    }
+
+    private fun String.hexToUtf8(): String {
+        return this.hexToBytes().toString(Charset.defaultCharset())
+    }
+
    private fun Context.readFileText(fileName: String): String =
        this.openFileInput(fileName).bufferedReader().readText()

--- a/app/src/main/java/com/tangem/tap/features/demo/DemoMiddlewares.kt
+++ b/app/src/main/java/com/tangem/tap/features/demo/DemoMiddlewares.kt
@ -5,7 +5,7 @@ import com.tangem.domain.common.ScanResponse
 import com.tangem.domain.common.extensions.withMainContext
 import com.tangem.tap.domain.extensions.makePrimaryWalletManager
 import com.tangem.tap.features.onboarding.products.note.redux.OnboardingNoteAction
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.ProgressState
 import com.tangem.tap.scope
 import com.tangem.tap.store
--- a/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectMiddleware.kt
@ -1,12 +1,11 @@
 package com.tangem.tap.features.details.redux.walletconnect

 import com.tangem.blockchain.common.Blockchain
-import com.tangem.blockchain.common.DerivationParams
 import com.tangem.blockchain.common.WalletManager
 import com.tangem.common.extensions.guard
 import com.tangem.domain.common.ScanResponse
-import com.tangem.domain.common.TapWorkarounds.derivationStyle
 import com.tangem.domain.common.TapWorkarounds.isTestCard
+import com.tangem.domain.common.extensions.withMainContext
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.extensions.getFromClipboard
 import com.tangem.tap.common.redux.AppState
@ -21,8 +20,6 @@ import com.tangem.tap.domain.walletconnect.BnbHelper
 import com.tangem.tap.domain.walletconnect.WalletConnectManager
 import com.tangem.tap.domain.walletconnect.WalletConnectNetworkUtils
 import com.tangem.tap.features.demo.DemoHelper
-import com.tangem.tap.features.wallet.redux.Currency
-import com.tangem.tap.features.wallet.redux.WalletAction
 import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.wallet.R
@ -192,40 +189,51 @@ class WalletConnectMiddleware {
            return
        }

-        val walletManager = getWalletManager(scanResponse, blockchain).guard {
-            store.dispatchOnMain(WalletConnectAction.FailureEstablishingSession(null))
-            return
+        scope.launch {
+            val walletManager = getWalletManager(scanResponse, blockchain).guard {
+                store.dispatchOnMain(WalletConnectAction.FailureEstablishingSession(session.session))
+                store.dispatchOnMain(
+                    GlobalAction.ShowDialog(
+                        WalletConnectDialog.AddNetwork(blockchain.fullName)
+                    )
+                )
+                return@launch
+            }
+
+            val wallet = walletManager.wallet
+            val derivedKey =
+                if (wallet.publicKey.blockchainKey.contentEquals(wallet.publicKey.seedKey)) {
+                    null
+                } else {
+                    walletManager.wallet.publicKey.blockchainKey
+                }
+            val walletForSession = WalletForSession(
+                cardId = scanResponse.card.cardId,
+                walletPublicKey = wallet.publicKey.seedKey,
+                derivedPublicKey = derivedKey,
+                derivationPath = wallet.publicKey.derivationPath,
+                blockchain = wallet.blockchain
+            )
+
+            withMainContext {
+                val updatedSession = session.copy(wallet = walletForSession)
+                walletConnectManager.updateSession(updatedSession)
+
+                store.dispatch(WalletConnectAction.AddScanResponse(scanResponse))
+
+                store.dispatch(
+                    GlobalAction.ShowDialog(
+                        WalletConnectDialog.ApproveWcSession(
+                            updatedSession
+                        )
+                    )
+                )
+            }
        }

-        val wallet = walletManager.wallet
-        val derivedKey =
-            if (wallet.publicKey.blockchainKey.contentEquals(wallet.publicKey.seedKey)) {
-                null
-            } else {
-                walletManager.wallet.publicKey.blockchainKey
-            }
-        val walletForSession = WalletForSession(
-            cardId = scanResponse.card.cardId,
-            walletPublicKey = wallet.publicKey.seedKey,
-            derivedPublicKey = derivedKey,
-            derivationPath = wallet.publicKey.derivationPath,
-            blockchain = wallet.blockchain
-        )
-        val updatedSession = session.copy(wallet = walletForSession)
-        walletConnectManager.updateSession(updatedSession)
-
-        store.dispatchOnMain(WalletConnectAction.AddScanResponse(scanResponse))
-
-        store.dispatchOnMain(
-            GlobalAction.ShowDialog(
-                WalletConnectDialog.ApproveWcSession(
-                    updatedSession
-                )
-            )
-        )
    }

-    private fun getWalletManager(
+    private suspend fun getWalletManager(
        scanResponse: ScanResponse, blockchain: Blockchain
    ): WalletManager? {
        val card = scanResponse.card
@ -236,42 +244,25 @@ class WalletConnectMiddleware {
            blockchain
        }

+        val blockchainNetwork = BlockchainNetwork(
+            blockchain = blockchainToMake,
+            card = card
+        )
+
        return if (store.state.globalState.scanResponse?.card?.cardId == card.cardId) {
-            val derivationPath = blockchainToMake.derivationPath(card.derivationStyle)?.rawPath
-            store.state.walletState.getWalletManager(
-                Currency.Blockchain(blockchainToMake, derivationPath)
-            )
-                ?: factory.makeWalletManagerForApp(
-                    scanResponse,
-                    blockchainToMake,
-                    card.derivationStyle?.let { DerivationParams.Default(it) }
-                )
-                    ?.also { walletManager ->
-                        store.dispatch(
-                            WalletAction.MultiWallet.AddBlockchain(
-                                BlockchainNetwork.fromWalletManager(walletManager), walletManager
-                            )
-                        )
-                    }
+            store.state.walletState.getWalletManager(blockchainNetwork)
        } else {
-            val walletManager = factory.makeWalletManagerForApp(
-                scanResponse,
-                blockchainToMake,
-                card.derivationStyle?.let { DerivationParams.Default(it) }
-            )
-            scope.launch {
-                if (currenciesRepository.loadSavedCurrencies(card.cardId, card.settings.isHDWalletAllowed)
-                        .find { it.blockchain == blockchainToMake } != null
-                ) {
-                    walletManager?.let {
-                        currenciesRepository.saveUpdatedCurrency(
-                            card.cardId,
-                            BlockchainNetwork.fromWalletManager(walletManager)
-                        )
-                    }
-                }
+            if (currenciesRepository
+                    .loadSavedCurrencies(card.cardId, card.settings.isHDWalletAllowed)
+                    .contains(blockchainNetwork)
+            ) {
+                factory.makeWalletManagerForApp(
+                    scanResponse = scanResponse,
+                    blockchainNetwork = blockchainNetwork
+                )
+            } else {
+                null
            }
-            return walletManager
        }
    }
 }
--- a/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectState.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectState.kt
@ -82,6 +82,7 @@ data class WalletForSession(
 sealed class WalletConnectDialog : StateDialog {
    data class ClipboardOrScanQr(val clipboardUri: String) : WalletConnectDialog()
    object UnsupportedCard : WalletConnectDialog()
+    data class AddNetwork(val network: String) : WalletConnectDialog()
    object OpeningSessionRejected : WalletConnectDialog()
    object SessionTimeout : WalletConnectDialog()
    data class ApproveWcSession(val session: WalletConnectSession) : WalletConnectDialog()
--- a/app/src/main/java/com/tangem/tap/features/details/ui/DetailsFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/DetailsFragment.kt
@ -67,7 +67,7 @@ class DetailsFragment : Fragment(R.layout.fragment_details), StoreSubscriber<Det
        setState(state)
    }

-    private fun setState(state: DetailsState)  = with (binding){
+    private fun setState(state: DetailsState)  = with (binding) {

        if (state.cardInfo != null) {
            val cardId = if (state.isTangemTwins) {
--- a/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/dialogs/SimpleAlertDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/dialogs/SimpleAlertDialog.kt
@ -1,28 +0,0 @@
-package com.tangem.tap.features.details.ui.walletconnect.dialogs
-
-import android.content.Context
-import androidx.appcompat.app.AlertDialog
-import com.tangem.tap.common.redux.global.GlobalAction
-import com.tangem.tap.store
-import com.tangem.wallet.R
-
-class SimpleAlertDialog {
-    companion object {
-        fun create(
-            titleRes: Int,
-            messageRes: Int,
-            buttonRes: Int = R.string.common_ok,
-            context: Context,
-        ): AlertDialog {
-
-            return AlertDialog.Builder(context).apply {
-                setTitle(context.getString(titleRes))
-                setMessage(context.getText(messageRes))
-                setPositiveButton(context.getText(buttonRes)) { _, _ -> }
-                setOnDismissListener {
-                    store.dispatch(GlobalAction.HideDialog)
-                }
-            }.create()
-        }
-    }
-}
--- a/app/src/main/java/com/tangem/tap/features/onboarding/AddressInfoBottomSheetDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/AddressInfoBottomSheetDialog.kt
@ -10,8 +10,8 @@ import com.tangem.tap.common.extensions.dispatchDialogHide
 import com.tangem.tap.common.extensions.dispatchShare
 import com.tangem.tap.common.extensions.dispatchToastNotification
 import com.tangem.tap.common.redux.AppDialog
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.AddressData
-import com.tangem.tap.features.wallet.redux.Currency
 import com.tangem.tap.store
 import com.tangem.wallet.R
 import com.tangem.wallet.databinding.DialogOnboardingAddressInfoBinding
--- a/app/src/main/java/com/tangem/tap/features/onboarding/OnboardingManager.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/OnboardingManager.kt
@ -12,8 +12,8 @@ import com.tangem.tap.common.extensions.isPositive
 import com.tangem.tap.common.extensions.safeUpdate
 import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.extensions.getOrLoadCardArtworkUrl
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.models.hasPendingTransactions
-import com.tangem.tap.features.wallet.redux.Currency
 import com.tangem.tap.features.wallet.redux.ProgressState
 import com.tangem.tap.persistence.UsedCardsPrefStorage
 import timber.log.Timber
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/note/OnboardingNoteFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/note/OnboardingNoteFragment.kt
@ -10,7 +10,7 @@ import androidx.annotation.LayoutRes
 import androidx.constraintlayout.widget.ConstraintSet
 import androidx.core.view.isVisible
 import androidx.transition.TransitionManager
-import com.squareup.picasso.Picasso
+import coil.load
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.tangem_sdk_new.extensions.fadeIn
 import com.tangem.tangem_sdk_new.extensions.fadeOut
@ -67,11 +67,11 @@ class OnboardingNoteFragment : BaseOnboardingFragment<OnboardingNoteState>() {
    override fun newState(state: OnboardingNoteState) {
        if (activity == null || view == null) return

-        Picasso.get()
-            .load(state.cardArtworkUrl)
-            .error(R.drawable.card_placeholder_black)
-            .placeholder(R.drawable.card_placeholder_black)
-            ?.into(binding.onboardingTopContainer.imvFrontCard)
+        binding.onboardingTopContainer.imvFrontCard.load(state.cardArtworkUrl) {
+            placeholder(R.drawable.card_placeholder_black)
+            error(R.drawable.card_placeholder_black)
+            fallback(R.drawable.card_placeholder_black)
+        }

        pbBinding.pbState.max = state.steps.size - 1
        pbBinding.pbState.progress = state.progress
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/note/redux/OnboardingNoteMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/note/redux/OnboardingNoteMiddleware.kt
@ -15,7 +15,7 @@ import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.extensions.hasWallets
 import com.tangem.tap.domain.extensions.makePrimaryWalletManager
 import com.tangem.tap.features.demo.DemoHelper
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.ProgressState
 import com.tangem.tap.scope
 import com.tangem.tap.store
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/otherCards/OnboardingOtherCardsFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/otherCards/OnboardingOtherCardsFragment.kt
@ -7,7 +7,7 @@ import androidx.annotation.LayoutRes
 import androidx.constraintlayout.widget.ConstraintSet
 import androidx.core.view.isVisible
 import androidx.transition.TransitionManager
-import com.squareup.picasso.Picasso
+import coil.load
 import com.tangem.tap.common.extensions.getDrawableCompat
 import com.tangem.tap.common.redux.navigation.ShareElement
 import com.tangem.tap.common.transitions.InternalNoteLayoutTransition
@ -54,11 +54,11 @@ class OnboardingOtherCardsFragment : BaseOnboardingFragment<OnboardingOtherCards
        if (activity == null || view == null) return
        if (state.currentStep == OnboardingOtherCardsStep.None) return

-        Picasso.get()
-            .load(state.cardArtworkUrl)
-            .error(R.drawable.card_placeholder_black)
-            .placeholder(R.drawable.card_placeholder_black)
-            ?.into(binding.onboardingTopContainer.imvFrontCard)
+        binding.onboardingTopContainer.imvFrontCard.load(state.cardArtworkUrl) {
+            placeholder(R.drawable.card_placeholder_black)
+            error(R.drawable.card_placeholder_black)
+            fallback(R.drawable.card_placeholder_black)
+        }

        pbBinding.pbState.max = state.steps.size - 1
        pbBinding.pbState.progress = state.progress
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/otherCards/redux/OnboardingOtherCardsMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/otherCards/redux/OnboardingOtherCardsMiddleware.kt
@ -1,5 +1,6 @@
 package com.tangem.tap.features.onboarding.products.otherCards.redux

+import com.tangem.blockchain.common.Blockchain
 import com.tangem.common.CompletionResult
 import com.tangem.domain.common.extensions.withMainContext
 import com.tangem.tap.DELAY_SDK_DIALOG_CLOSE
@ -10,6 +11,8 @@ 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.domain.extensions.hasWallets
+import com.tangem.tap.domain.tokens.models.BlockchainNetwork
+import com.tangem.tap.features.wallet.redux.WalletAction
 import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.tap.tangemSdkManager
@ -73,6 +76,21 @@ private fun handleOtherCardsAction(action: Action, dispatch: DispatchFunction) {
                            onboardingManager.scanResponse = updatedResponse
                            onboardingManager.activationStarted(updatedResponse.card.cardId)

+                            val primaryBlockchain = updatedResponse.getBlockchain()
+                            val blockchainNetworks = if (primaryBlockchain != Blockchain.Unknown) {
+                                val primaryToken = updatedResponse.getPrimaryToken()
+                                val blockchainNetwork = BlockchainNetwork(primaryBlockchain, updatedResponse.card).updateTokens(
+                                    listOfNotNull(primaryToken))
+                                listOf(blockchainNetwork)
+                            } else {
+                                listOf(
+                                    BlockchainNetwork(Blockchain.Bitcoin, updatedResponse.card),
+                                    BlockchainNetwork(Blockchain.Ethereum, updatedResponse.card)
+                                )
+                            }
+
+                            store.dispatch(WalletAction.MultiWallet.SaveCurrencies(blockchainNetworks))
+
                            delay(DELAY_SDK_DIALOG_CLOSE)
                            store.dispatch(OnboardingOtherCardsAction.SetStepOfScreen(OnboardingOtherCardsStep.Done))
                        }
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/twins/redux/TwinCardsMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/twins/redux/TwinCardsMiddleware.kt
@ -16,7 +16,7 @@ import com.tangem.tap.common.redux.navigation.NavigationAction
 import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.extensions.makePrimaryWalletManager
 import com.tangem.tap.domain.twins.TwinCardsManager
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.ProgressState
 import com.tangem.tap.preferencesStorage
 import com.tangem.tap.scope
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/twins/ui/TwinsCardsFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/twins/ui/TwinsCardsFragment.kt
@ -9,13 +9,18 @@ import androidx.constraintlayout.widget.ConstraintSet
 import androidx.core.view.isVisible
 import androidx.transition.TransitionInflater
 import androidx.transition.TransitionManager
-import com.squareup.picasso.Picasso
+import coil.load
 import com.tangem.Message
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.common.extensions.VoidCallback
 import com.tangem.domain.common.TwinCardNumber
 import com.tangem.tangem_sdk_new.ui.widget.leapfrogWidget.LeapfrogWidget
-import com.tangem.tap.common.extensions.*
+import com.tangem.tap.common.extensions.beginDelayedTransition
+import com.tangem.tap.common.extensions.getDrawableCompat
+import com.tangem.tap.common.extensions.hide
+import com.tangem.tap.common.extensions.readAssetAsString
+import com.tangem.tap.common.extensions.show
+import com.tangem.tap.common.extensions.stripZeroPlainString
 import com.tangem.tap.common.redux.navigation.AppScreen
 import com.tangem.tap.common.redux.navigation.NavigationAction
 import com.tangem.tap.common.redux.navigation.ShareElement
@ -75,24 +80,28 @@ class TwinsCardsFragment : BaseOnboardingFragment<TwinCardsState>() {
        resources.getValue(R.dimen.device_scale_factor_for_twins_welcome, typedValue, true)
        val deviceScaleFactorForWelcomeState = typedValue.float

-        twinsWidget = TwinsCardWidget(LeapfrogWidget(binding.onboardingTopContainer.cardsContainer), deviceScaleFactorForWelcomeState) {
+        twinsWidget = TwinsCardWidget(
+            LeapfrogWidget(binding.onboardingTopContainer.cardsContainer),
+            deviceScaleFactorForWelcomeState
+        ) {
            285f * deviceScaleFactorForWelcomeState
        }
-        btnRefreshBalanceWidget = RefreshBalanceWidget(binding.onboardingTopContainer.onboardingMainContainer)
+        btnRefreshBalanceWidget =
+            RefreshBalanceWidget(binding.onboardingTopContainer.onboardingMainContainer)

        binding.toolbar.title = getText(R.string.twins_recreate_toolbar)

-        Picasso.get()
-            .load(Artwork.TWIN_CARD_1)
-            .error(R.drawable.card_placeholder_black)
-            .placeholder(R.drawable.card_placeholder_black)
-            ?.into(binding.onboardingTopContainer.imvTwinFrontCard)
+        binding.onboardingTopContainer.imvTwinFrontCard.load(Artwork.TWIN_CARD_1) {
+            placeholder(R.drawable.card_placeholder_black)
+            error(R.drawable.card_placeholder_black)
+            fallback(R.drawable.card_placeholder_black)
+        }

-        Picasso.get()
-            .load(Artwork.TWIN_CARD_2)
-            .error(R.drawable.card_placeholder_white)
-            .placeholder(R.drawable.card_placeholder_white)
-            ?.into(binding.onboardingTopContainer.imvTwinBackCard)
+        binding.onboardingTopContainer.imvTwinBackCard.load(Artwork.TWIN_CARD_2) {
+            placeholder(R.drawable.card_placeholder_white)
+            error(R.drawable.card_placeholder_white)
+            fallback(R.drawable.card_placeholder_white)
+        }
    }

    private fun reconfigureLayoutForTwins(containerBinding: LayoutOnboardingContainerTopBinding) =
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletMiddleware.kt
@ -1,5 +1,6 @@
 package com.tangem.tap.features.onboarding.products.wallet.redux

+import com.tangem.blockchain.common.Blockchain
 import com.tangem.common.CompletionResult
 import com.tangem.common.card.Card
 import com.tangem.domain.common.ScanResponse
@ -12,9 +13,11 @@ 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.domain.extensions.hasWallets
+import com.tangem.tap.domain.tokens.models.BlockchainNetwork
 import com.tangem.tap.features.demo.DemoHelper
 import com.tangem.tap.features.home.redux.HomeAction
 import com.tangem.tap.features.wallet.redux.Artwork
+import com.tangem.tap.features.wallet.redux.WalletAction
 import kotlinx.coroutines.launch
 import org.rekotlin.Action
 import org.rekotlin.Middleware
@ -84,6 +87,11 @@ private fun handleWalletAction(action: Action) {
                                    primaryCard = result.data.primaryCard
                                )
                            onboardingManager.scanResponse = updatedResponse
+                            val blockchainNetworks = listOf(
+                                BlockchainNetwork(Blockchain.Bitcoin, result.data.card),
+                                BlockchainNetwork(Blockchain.Ethereum, result.data.card)
+                            )
+                            store.dispatchOnMain(WalletAction.MultiWallet.SaveCurrencies(blockchainNetworks))
                            onboardingManager.activationStarted(updatedResponse.card.cardId)
                            store.dispatch(OnboardingWalletAction.ProceedBackup)
                        }
@ -260,6 +268,11 @@ private fun handleBackupAction(appState: () -> AppState?, action: BackupAction)
            backupService.proceedBackup { result ->
                when (result) {
                    is CompletionResult.Success -> {
+                        val blockchainNetworks = listOf(
+                            BlockchainNetwork(Blockchain.Bitcoin, result.data),
+                            BlockchainNetwork(Blockchain.Ethereum, result.data)
+                        )
+                        store.dispatchOnMain(WalletAction.MultiWallet.SaveCurrencies(blockchainNetworks))
                        if (backupService.currentState == BackupService.State.Finished) {
                            store.dispatchOnMain(BackupAction.FinishBackup)
                        } else {
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/OnboardingWalletFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/OnboardingWalletFragment.kt
@ -11,9 +11,9 @@ import androidx.fragment.app.Fragment
 import androidx.transition.TransitionInflater
 import androidx.transition.TransitionManager
 import by.kirich1409.viewbindingdelegate.viewBinding
+import coil.load
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.tabs.TabLayoutMediator
-import com.squareup.picasso.Picasso
 import com.tangem.common.CardIdFormatter
 import com.tangem.common.core.CardIdDisplayFormat
 import com.tangem.tangem_sdk_new.ui.widget.leapfrogWidget.LeapfrogWidget
@ -22,7 +22,12 @@ import com.tangem.tap.common.extensions.hide
 import com.tangem.tap.common.extensions.show
 import com.tangem.tap.features.FragmentOnBackPressedHandler
 import com.tangem.tap.features.addBackPressHandler
-import com.tangem.tap.features.onboarding.products.wallet.redux.*
+import com.tangem.tap.features.onboarding.products.wallet.redux.BackupAction
+import com.tangem.tap.features.onboarding.products.wallet.redux.BackupState
+import com.tangem.tap.features.onboarding.products.wallet.redux.BackupStep
+import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletAction
+import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletState
+import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletStep
 import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.AccessCodeDialog
 import com.tangem.tap.store
 import com.tangem.wallet.R
@ -124,11 +129,11 @@ class OnboardingWalletFragment : Fragment(R.layout.fragment_onboarding_wallet),
    }

    private fun loadImageIntoImageView(url: String?, view: ImageView) {
-        Picasso.get()
-            .load(url)
-            .error(R.drawable.card_placeholder_black)
-            .placeholder(R.drawable.card_placeholder_black)
-            ?.into(view)
+        view.load(url) {
+            placeholder(R.drawable.card_placeholder_black)
+            error(R.drawable.card_placeholder_black)
+            fallback(R.drawable.card_placeholder_black)
+        }
    }

    private fun setupCreateWalletState() = with(binding) {
--- a/app/src/main/java/com/tangem/tap/features/send/redux/reducers/FeeReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/reducers/FeeReducer.kt
@ -106,7 +106,7 @@ class FeeReducer : SendInternalReducer {

    private fun getFeePrecision(sendState: SendState): FeePrecision {
        val blockchain = sendState.walletManager?.wallet?.blockchain
-        return if (blockchain?.fullNameWithoutTestnet == Blockchain.Tron.fullName &&
+        return if ((blockchain?.fullNameWithoutTestnet == Blockchain.Arbitrum.fullName || blockchain?.fullNameWithoutTestnet == Blockchain.Tron.fullName) &&
            sendState.amountState.typeOfAmount is AmountType.Token) {
            FeePrecision.CAN_BE_LOWER
        } else {
--- a/app/src/main/java/com/tangem/tap/features/send/redux/reducers/ReceiptReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/redux/reducers/ReceiptReducer.kt
@ -7,6 +7,7 @@ import com.tangem.tap.common.extensions.stripZeroPlainString
 import com.tangem.tap.features.send.redux.ReceiptAction.RefreshReceipt
 import com.tangem.tap.features.send.redux.SendScreenAction
 import com.tangem.tap.features.send.redux.states.*
+import com.tangem.tap.features.wallet.redux.WalletState.Companion.UNKNOWN_AMOUNT_SIGN
 import com.tangem.tap.store
 import java.math.BigDecimal

@ -15,10 +16,6 @@ import java.math.BigDecimal
 */
 class ReceiptReducer : SendInternalReducer {

-    companion object {
-        const val EMPTY = "-"
-    }
-
    private lateinit var sendState: SendState
    private lateinit var amountState: AmountState
    private lateinit var feeState: FeeState
@ -137,9 +134,9 @@ class ReceiptReducer : SendInternalReducer {
            )
        } else {
            ReceiptTokenFiat(
-                amountFiat = EMPTY,
-                feeFiat = EMPTY,
-                totalFiat = EMPTY,
+                amountFiat = UNKNOWN_AMOUNT_SIGN,
+                feeFiat = UNKNOWN_AMOUNT_SIGN,
+                totalFiat = UNKNOWN_AMOUNT_SIGN,
                willSentToken = tokensToSend.stripZeroPlainString(),
                willSentFeeCoin = feeCoin.stripZeroPlainString(),
                symbols = symbols
@ -169,7 +166,7 @@ class ReceiptReducer : SendInternalReducer {
            ReceiptTokenCrypto(
                amountToken = tokensToSend.stripZeroPlainString(),
                feeCoin = feeCoin.stripZeroPlainString().addPrecisionSign(),
-                totalFiat = EMPTY,
+                totalFiat = UNKNOWN_AMOUNT_SIGN,
                symbols = symbols
            )
        }
@ -206,7 +203,7 @@ class ReceiptReducer : SendInternalReducer {
        return when {
            !isToken && sendState.coinIsConvertible() -> sendState.coinConverter!!.toFiatWithPrecision(value).stripZeroPlainString()
            isToken && sendState.tokenIsConvertible() -> sendState.tokenConverter!!.toFiatWithPrecision(value).stripZeroPlainString()
-            else -> EMPTY
+            else -> UNKNOWN_AMOUNT_SIGN
        }
    }

--- a/app/src/main/java/com/tangem/tap/features/send/ui/stateSubscribers/SendStateSubscriber.kt
+++ b/app/src/main/java/com/tangem/tap/features/send/ui/stateSubscribers/SendStateSubscriber.kt
@ -17,12 +17,13 @@ import com.tangem.tap.features.BaseStoreFragment
 import com.tangem.tap.features.send.redux.AddressPayIdVerifyAction.Error
 import com.tangem.tap.features.send.redux.FeeAction
 import com.tangem.tap.features.send.redux.SendAction
-import com.tangem.tap.features.send.redux.reducers.ReceiptReducer
 import com.tangem.tap.features.send.redux.states.*
 import com.tangem.tap.features.send.ui.FeeUiHelper
 import com.tangem.tap.features.send.ui.SendFragment
 import com.tangem.tap.features.send.ui.dialogs.SendTransactionFailsDialog
 import com.tangem.tap.features.send.ui.dialogs.TezosWarningDialog
+import com.tangem.tap.features.wallet.redux.WalletState.Companion.ROUGH_SIGN
+import com.tangem.tap.features.wallet.redux.WalletState.Companion.UNKNOWN_AMOUNT_SIGN
 import com.tangem.tap.features.wallet.ui.adapters.WarningMessagesAdapter
 import com.tangem.tap.store
 import com.tangem.wallet.R
@ -257,12 +258,12 @@ class SendStateSubscriber(fragment: BaseStoreFragment) :
        val mainLayout = clReceiptContainer as ViewGroup
        val totalLayout = llTotalContainer.llTotal as ViewGroup
        val totalTokenLayout = llTotalContainer.flTotalTokenCrypto as ViewGroup
-        fun getString(id: Int, vararg formatStrings: String): String =
-            mainLayout.context.getString(id, *formatStrings)

-        val rough = getString(R.string.sign_rough)
-        fun roughOrEmpty(value: String): String =
-            if (value == ReceiptReducer.EMPTY) value else "$rough $value"
+        fun getString(id: Int, vararg formatStrings: String): String = mainLayout.getString(id, *formatStrings)
+
+        fun roughOrEmpty(value: String): String {
+            return if (value == UNKNOWN_AMOUNT_SIGN) value else "$ROUGH_SIGN $value"
+        }

        when (state.visibleTypeOfReceipt) {
            ReceiptLayoutType.FIAT -> {
--- a/app/src/main/java/com/tangem/tap/features/shop/redux/ShopAction.kt
+++ b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopAction.kt
@ -1,15 +1,20 @@
 package com.tangem.tap.features.shop.redux

 import android.content.Intent
+import com.tangem.tap.common.redux.NotificationAction
 import com.tangem.tap.common.shop.GooglePayService
 import com.tangem.tap.common.shop.data.ProductType
 import com.tangem.tap.common.shop.data.TangemProduct
+import com.tangem.wallet.R
 import org.rekotlin.Action

 sealed class ShopAction : Action {

    object LoadProducts : ShopAction() {
        data class Success(val products: List<TangemProduct>) : ShopAction()
+        object Failure : ShopAction(), NotificationAction {
+            override val messageResource = R.string.common_server_unavailable
+        }
    }

    data class ApplyPromoCode(val promoCode: String) : ShopAction() {
--- a/app/src/main/java/com/tangem/tap/features/shop/redux/ShopMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopMiddleware.kt
@ -11,6 +11,7 @@ import com.tangem.tap.store
 import kotlinx.coroutines.launch
 import org.rekotlin.Action
 import org.rekotlin.Middleware
+import timber.log.Timber

 class ShopMiddleware {

@ -88,10 +89,13 @@ private fun handle(action: Action) {
        }
        ShopAction.LoadProducts -> {
            scope.launch {
-                val result = shopService.getProducts()
-                result.onSuccess {
-                    store.dispatchOnMain(ShopAction.LoadProducts.Success(it))
-                }
+                shopService.getProducts().fold(
+                    onSuccess = { store.dispatchOnMain(ShopAction.LoadProducts.Success(it)) },
+                    onFailure = {
+                        Timber.e(it)
+                        store.dispatchOnMain(ShopAction.LoadProducts.Failure)
+                    }
+                )
            }
        }
        is ShopAction.CheckIfGooglePayAvailable -> {
--- a/app/src/main/java/com/tangem/tap/features/shop/redux/ShopReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopReducer.kt
@ -65,5 +65,6 @@ private fun internalReduce(action: Action, state: ShopState): ShopState {
        }
        ShopAction.FinishSuccessfulOrder -> state
        ShopAction.ResetState -> ShopState()
+        ShopAction.LoadProducts.Failure -> state
    }
 }
--- a/app/src/main/java/com/tangem/tap/features/tokens/redux/TokensMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/tokens/redux/TokensMiddleware.kt
@ -30,7 +30,7 @@ import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.extensions.makeWalletManagerForApp
 import com.tangem.tap.domain.tokens.LoadAvailableCoinsService
 import com.tangem.tap.domain.tokens.models.BlockchainNetwork
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.WalletAction
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@ -309,7 +309,10 @@ class TokensMiddleware {
        if (currencies.isNotEmpty()) {
            currencies.forEach { currency ->
                store.state.walletState.getWalletData(currency)?.let {
-                    store.dispatch(WalletAction.MultiWallet.RemoveWallet(it))
+                    store.dispatch(WalletAction.MultiWallet.RemoveWallet(
+                        walletData = it,
+                        fromWalletDetails = false
+                    ))
                }
            }
        }
--- a/app/src/main/java/com/tangem/tap/features/tokens/redux/TokensState.kt
+++ b/app/src/main/java/com/tangem/tap/features/tokens/redux/TokensState.kt
@ -34,18 +34,18 @@ data class TokensState(
 typealias ContractAddress = String

 fun List<WalletData>.toTokensContractAddresses(): List<ContractAddress> {
-    return mapNotNull { (it.currency as? com.tangem.tap.features.wallet.redux.Currency.Token)?.token?.contractAddress }.distinct()
+    return mapNotNull { (it.currency as? com.tangem.tap.features.wallet.models.Currency.Token)?.token?.contractAddress }.distinct()
 }

 fun List<WalletData>.toNonCustomTokens(derivationStyle: DerivationStyle?): List<Token> {
    return filter { !it.currency.isCustomCurrency(derivationStyle) }
-        .mapNotNull { (it.currency as? com.tangem.tap.features.wallet.redux.Currency.Token)?.token }
+        .mapNotNull { (it.currency as? com.tangem.tap.features.wallet.models.Currency.Token)?.token }
        .distinct()
 }

 fun List<WalletData>.toNonCustomTokensWithBlockchains(derivationStyle: DerivationStyle?): List<TokenWithBlockchain> {
    return mapNotNull {
-        if (it.currency !is com.tangem.tap.features.wallet.redux.Currency.Token) return@mapNotNull null
+        if (it.currency !is com.tangem.tap.features.wallet.models.Currency.Token) return@mapNotNull null
        if (it.currency.isCustomCurrency(derivationStyle)) return@mapNotNull null
        TokenWithBlockchain(it.currency.token, it.currency.blockchain)
    }.distinct()
@ -56,7 +56,7 @@ fun List<WalletData>.toNonCustomBlockchains(derivationStyle: DerivationStyle?):
        if (it.currency.isCustomCurrency(derivationStyle)) {
            null
        } else {
-            (it.currency as? com.tangem.tap.features.wallet.redux.Currency.Blockchain)?.blockchain
+            (it.currency as? com.tangem.tap.features.wallet.models.Currency.Blockchain)?.blockchain
        }
    }.distinct()
 }
--- a/app/src/main/java/com/tangem/tap/features/wallet/models/Currency.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/models/Currency.kt
@ -0,0 +1,97 @@
+package com.tangem.tap.features.wallet.models
+
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.DerivationStyle
+import com.tangem.blockchain.common.Token
+import com.tangem.domain.common.extensions.toCoinId
+import com.tangem.domain.features.addCustomToken.CustomCurrency
+import com.tangem.tap.common.redux.global.CryptoCurrencyName
+import com.tangem.tap.domain.tokens.models.BlockchainNetwork
+import com.tangem.tap.features.tokens.redux.TokenWithBlockchain
+
+sealed interface Currency {
+
+    val coinId: String?
+        get() = when (this) {
+            is Blockchain -> blockchain.toCoinId()
+            is Token -> token.id
+        }
+    val blockchain: com.tangem.blockchain.common.Blockchain
+    val currencySymbol: CryptoCurrencyName
+    val derivationPath: String?
+
+    val currencyName: String
+        get() = when (this) {
+            is Blockchain -> blockchain.fullName
+            is Token -> token.name
+        }
+
+    data class Token(
+        val token: com.tangem.blockchain.common.Token,
+        override val blockchain: com.tangem.blockchain.common.Blockchain,
+        override val derivationPath: String?
+    ) : Currency {
+        override val currencySymbol = token.symbol
+    }
+
+    data class Blockchain(
+        override val blockchain: com.tangem.blockchain.common.Blockchain,
+        override val derivationPath: String?
+    ) : Currency {
+        override val currencySymbol: CryptoCurrencyName = blockchain.currency
+    }
+
+    fun isCustomCurrency(derivationStyle: DerivationStyle?): Boolean {
+        if (this is Token && this.token.id == null) return true
+
+        if (derivationPath == null || derivationStyle == null) return false
+
+        return derivationPath != blockchain.derivationPath(derivationStyle)?.rawPath
+    }
+
+    fun isBlockchain(): Boolean = this is Blockchain
+
+    fun isToken(): Boolean = this is Token
+
+    companion object {
+        fun fromBlockchainNetwork(
+            blockchainNetwork: BlockchainNetwork,
+            token: com.tangem.blockchain.common.Token? = null
+        ): Currency {
+            return if (token != null) {
+                Token(
+                    token = token,
+                    blockchain = blockchainNetwork.blockchain,
+                    derivationPath = blockchainNetwork.derivationPath
+                )
+            } else {
+                Blockchain(
+                    blockchain = blockchainNetwork.blockchain,
+                    derivationPath = blockchainNetwork.derivationPath
+                )
+            }
+        }
+
+        fun fromCustomCurrency(customCurrency: CustomCurrency): Currency {
+            return when (customCurrency) {
+                is CustomCurrency.CustomBlockchain -> Blockchain(
+                    blockchain = customCurrency.network,
+                    derivationPath = customCurrency.derivationPath?.rawPath
+                )
+                is CustomCurrency.CustomToken -> Token(
+                    token = customCurrency.token,
+                    blockchain = customCurrency.network,
+                    derivationPath = customCurrency.derivationPath?.rawPath,
+                )
+            }
+        }
+
+        fun fromTokenWithBlockchain(tokenWithBlockchain: TokenWithBlockchain): Token {
+            return Token(
+                token = tokenWithBlockchain.token,
+                blockchain = tokenWithBlockchain.blockchain,
+                derivationPath = null
+            )
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/WalletAction.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/WalletAction.kt
@ -14,6 +14,7 @@ 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.models.BlockchainNetwork
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.wallet.R
 import java.math.BigDecimal
 import org.rekotlin.Action
@ -74,7 +75,8 @@ sealed class WalletAction : Action {
        ) : MultiWallet()

        data class SelectWallet(val walletData: WalletData?) : MultiWallet()
-        data class RemoveWallet(val walletData: WalletData) : MultiWallet()
+        data class RemoveWallet(val walletData: WalletData, val fromWalletDetails: Boolean = true) : MultiWallet()
+        data class TryToRemoveWallet(val walletData: WalletData) : MultiWallet()
        data class SetPrimaryBlockchain(val blockchain: Blockchain) : MultiWallet()
        data class SetPrimaryToken(val token: Token) : MultiWallet()
    }
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/WalletState.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/WalletState.kt
@ -1,17 +1,10 @@
 package com.tangem.tap.features.wallet.redux

 import android.graphics.Bitmap
-import com.tangem.blockchain.common.Amount
-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.*
 import com.tangem.blockchain.common.address.AddressType
 import com.tangem.common.extensions.isZero
 import com.tangem.domain.common.extensions.canHandleToken
-import com.tangem.domain.common.extensions.toCoinId
-import com.tangem.domain.features.addCustomToken.CustomCurrency
 import com.tangem.tap.common.entities.Button
 import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.common.extensions.toQrCode
@ -23,22 +16,15 @@ import com.tangem.tap.domain.extensions.buyIsAllowed
 import com.tangem.tap.domain.extensions.sellIsAllowed
 import com.tangem.tap.domain.tokens.models.BlockchainNetwork
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsState
-import com.tangem.tap.features.tokens.redux.TokenWithBlockchain
-import com.tangem.tap.features.wallet.models.PendingTransaction
-import com.tangem.tap.features.wallet.models.TotalBalance
-import com.tangem.tap.features.wallet.models.WalletRent
-import com.tangem.tap.features.wallet.models.WalletWarning
-import com.tangem.tap.features.wallet.models.hasPendingTransactions
-import com.tangem.tap.features.wallet.models.hasSendableAmounts
-import com.tangem.tap.features.wallet.models.isSendableAmount
+import com.tangem.tap.features.wallet.models.*
 import com.tangem.tap.features.wallet.redux.reducers.calculateTotalFiatAmount
 import com.tangem.tap.features.wallet.redux.reducers.findProgressState
 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 java.math.BigDecimal
 import org.rekotlin.StateType
+import java.math.BigDecimal
 import kotlin.properties.ReadOnlyProperty

 data class WalletState(
@ -315,6 +301,11 @@ data class WalletState(
            )
        } else this
    }
+
+    companion object {
+        const val UNKNOWN_AMOUNT_SIGN = "—"
+        const val ROUGH_SIGN = "≈"
+    }
 }

 sealed interface WalletDialog : StateDialog {
@ -439,87 +430,6 @@ data class WalletData(
    private fun tokenAmountIsEmpty(): Boolean = currencyData.amount?.isZero() == true
 }

-sealed interface Currency {
-
-    val coinId: String?
-        get() = when (this) {
-            is Blockchain -> blockchain.toCoinId()
-            is Token -> token.id
-        }
-    val blockchain: com.tangem.blockchain.common.Blockchain
-    val currencySymbol: CryptoCurrencyName
-    val derivationPath: String?
-
-    data class Token(
-        val token: com.tangem.blockchain.common.Token,
-        override val blockchain: com.tangem.blockchain.common.Blockchain,
-        override val derivationPath: String?
-    ) : Currency {
-        override val currencySymbol = token.symbol
-    }
-
-    data class Blockchain(
-        override val blockchain: com.tangem.blockchain.common.Blockchain,
-        override val derivationPath: String?
-    ) : Currency {
-        override val currencySymbol: CryptoCurrencyName = blockchain.currency
-    }
-
-    fun isCustomCurrency(derivationStyle: DerivationStyle?): Boolean {
-        if (this is Token && this.token.id == null) return true
-
-        if (derivationPath == null || derivationStyle == null) return false
-
-        return derivationPath != blockchain.derivationPath(derivationStyle)?.rawPath
-    }
-
-    fun isBlockchain(): Boolean = this is Blockchain
-
-    fun isToken(): Boolean = this is Token
-
-    companion object {
-        fun fromBlockchainNetwork(
-            blockchainNetwork: BlockchainNetwork,
-            token: com.tangem.blockchain.common.Token? = null
-        ): Currency {
-            return if (token != null) {
-                Token(
-                    token = token,
-                    blockchain = blockchainNetwork.blockchain,
-                    derivationPath = blockchainNetwork.derivationPath
-                )
-            } else {
-                Blockchain(
-                    blockchain = blockchainNetwork.blockchain,
-                    derivationPath = blockchainNetwork.derivationPath
-                )
-            }
-        }
-
-        fun fromCustomCurrency(customCurrency: CustomCurrency): Currency {
-            return when (customCurrency) {
-                is CustomCurrency.CustomBlockchain -> Blockchain(
-                    blockchain = customCurrency.network,
-                    derivationPath = customCurrency.derivationPath?.rawPath
-                )
-                is CustomCurrency.CustomToken -> Token(
-                    token = customCurrency.token,
-                    blockchain = customCurrency.network,
-                    derivationPath = customCurrency.derivationPath?.rawPath,
-                )
-            }
-        }
-
-        fun fromTokenWithBlockchain(tokenWithBlockchain: TokenWithBlockchain): Token {
-            return Token(
-                token = tokenWithBlockchain.token,
-                blockchain = tokenWithBlockchain.blockchain,
-                derivationPath = null
-            )
-        }
-    }
-}
-
 data class WalletStore(
    val walletManager: WalletManager?,
    val blockchainNetwork: BlockchainNetwork,
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/AppCurrencyMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/AppCurrencyMiddleware.kt
@ -9,7 +9,7 @@ import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.domain.TapWalletManager
 import com.tangem.tap.features.details.redux.DetailsAction
 import com.tangem.tap.features.wallet.redux.WalletAction
-import com.tangem.tap.features.wallet.redux.WalletDialog
+import com.tangem.tap.features.wallet.redux.models.WalletDialog
 import com.tangem.tap.persistence.FiatCurrenciesPrefStorage
 import com.tangem.tap.scope
 import com.tangem.tap.store
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/MultiWalletMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/MultiWalletMiddleware.kt
@ -3,6 +3,8 @@ package com.tangem.tap.features.wallet.redux.middlewares
 import com.tangem.blockchain.common.AmountType
 import com.tangem.blockchain.common.Token
 import com.tangem.blockchain.common.WalletManager
+import com.tangem.common.extensions.guard
+import com.tangem.tap.common.extensions.dispatchDialogShow
 import com.tangem.tap.common.extensions.safeUpdate
 import com.tangem.tap.common.redux.global.GlobalState
 import com.tangem.tap.common.redux.navigation.AppScreen
@ -12,9 +14,10 @@ import com.tangem.tap.domain.extensions.makeWalletManagerForApp
 import com.tangem.tap.domain.tokens.models.BlockchainNetwork
 import com.tangem.tap.features.demo.DemoHelper
 import com.tangem.tap.features.demo.isDemoCard
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.WalletAction
 import com.tangem.tap.features.wallet.redux.WalletState
+import com.tangem.tap.features.wallet.redux.models.WalletDialog
 import com.tangem.tap.scope
 import com.tangem.tap.store
 import kotlinx.coroutines.Dispatchers
@ -55,23 +58,55 @@ class MultiWalletMiddleware {
                        blockchainNetwork = action.blockchain
                    )
                }
-                store.dispatch(WalletAction.LoadFiatRate(
-                    coinsList = listOf(
-                        Currency.Blockchain(
-                            action.blockchain.blockchain,
-                            action.blockchain.derivationPath
+                store.dispatch(
+                    WalletAction.LoadFiatRate(
+                        coinsList = listOf(
+                            Currency.Blockchain(
+                                action.blockchain.blockchain,
+                                action.blockchain.derivationPath
+                            )
                        )
                    )
-                ))
-                store.dispatch(WalletAction.LoadWallet(
-                    action.blockchain, action.walletManager
-                ))
+                )
+                store.dispatch(
+                    WalletAction.LoadWallet(
+                        action.blockchain, action.walletManager
+                    )
+                )
            }
            is WalletAction.MultiWallet.SaveCurrencies -> {
                globalState.scanResponse?.card?.cardId?.let {
                    currenciesRepository.saveCurrencies(it, action.blockchainNetworks)
                }
            }
+            is WalletAction.MultiWallet.TryToRemoveWallet -> {
+                val walletState = store.state.walletState
+                val currency = action.walletData.currency
+                val walletCanBeRemoved = store.state.walletState.canBeRemoved(
+                    store.state.walletState.getSelectedWalletData()
+                )
+                if (walletCanBeRemoved) {
+                    store.dispatch(WalletAction.MultiWallet.RemoveWallet(action.walletData))
+                    return
+                }
+
+                val walletManager = walletState.getWalletManager(currency).guard {
+                    store.dispatch(WalletAction.MultiWallet.RemoveWallet(action.walletData))
+                    return
+                }
+
+                val dialog = when {
+                    currency is Currency.Blockchain &&
+                            walletManager.cardTokens.isNotEmpty() ->
+                        WalletDialog.TokensAreLinkedDialog(
+                            currency.currencyName, currency.currencySymbol
+                        )
+
+                    else ->
+                        WalletDialog.RemoveWalletDialog(currency.currencyName, action.walletData)
+                }
+                store.dispatchDialogShow(dialog)
+            }
            is WalletAction.MultiWallet.RemoveWallet -> {
                val cardId = globalState.scanResponse?.card?.cardId
                when (val currency = action.walletData.currency) {
@ -94,12 +129,18 @@ class MultiWalletMiddleware {
                                currenciesRepository.removeToken(
                                    cardId = it,
                                    token = currency.token,
-                                    blockchainNetwork = BlockchainNetwork.fromWalletManager(walletManager)
+                                    blockchainNetwork = BlockchainNetwork.fromWalletManager(
+                                        walletManager
+                                    )
                                )
                            }
                        }
                    }
                }
+                if (action.fromWalletDetails) {
+                    store.dispatch(WalletAction.MultiWallet.SelectWallet(null))
+                    store.dispatch(NavigationAction.PopBackTo())
+                }
            }
 //            is WalletAction.MultiWallet.FindBlockchainsInUse -> {
 //                val scanResponse = globalState.scanResponse ?: return
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/TradeCryptoMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/TradeCryptoMiddleware.kt
@ -10,7 +10,7 @@ import com.tangem.tap.common.redux.navigation.NavigationAction
 import com.tangem.tap.features.demo.DemoHelper
 import com.tangem.tap.features.send.redux.PrepareSendScreen
 import com.tangem.tap.features.send.redux.SendAction
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.WalletAction
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
 import com.tangem.tap.network.exchangeServices.buyErc20Tokens
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WalletDialogsMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WalletDialogsMiddleware.kt
@ -4,7 +4,7 @@ import com.tangem.tap.common.extensions.dispatchDialogHide
 import com.tangem.tap.common.extensions.dispatchDialogShow
 import com.tangem.tap.common.redux.AppDialog
 import com.tangem.tap.features.wallet.redux.WalletAction
-import com.tangem.tap.features.wallet.redux.WalletDialog
+import com.tangem.tap.features.wallet.redux.models.WalletDialog
 import com.tangem.tap.store

 class WalletDialogsMiddleware {
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WalletMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WalletMiddleware.kt
@ -31,9 +31,10 @@ import com.tangem.tap.features.demo.DemoHelper
 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.filterByCoin
 import com.tangem.tap.features.wallet.models.getPendingTransactions
 import com.tangem.tap.features.wallet.models.getSendableAmounts
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.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
@ -332,7 +333,10 @@ class WalletMiddleware {
                    }

                    val balance = walletManager.wallet.fundsAvailable(AmountType.Coin)
-                    val outgoingTxs = walletManager.wallet.getPendingTransactions(PendingTransactionType.Outgoing)
+                    val outgoingTxs = walletManager.wallet.getPendingTransactions(
+                        PendingTransactionType.Outgoing
+                    ).filterByCoin()
+
                    val rentExempt = result.data
                    val show = if (outgoingTxs.isEmpty()) {
                        isNeedToShowWarning(balance, rentExempt)
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/models/WalletDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/models/WalletDialog.kt
@ -0,0 +1,39 @@
+package com.tangem.tap.features.wallet.redux.models
+
+import com.tangem.blockchain.common.Amount
+import com.tangem.tap.common.entities.FiatCurrency
+import com.tangem.tap.common.redux.StateDialog
+import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.features.wallet.redux.WalletData
+import com.tangem.tap.store
+import com.tangem.wallet.R
+
+sealed interface WalletDialog : StateDialog {
+    data class SelectAmountToSendDialog(val amounts: List<Amount>?) : WalletDialog
+    object SignedHashesMultiWalletDialog : WalletDialog
+    object ChooseTradeActionDialog : WalletDialog
+    data class CurrencySelectionDialog(
+        val currenciesList: List<FiatCurrency>,
+        val currentAppCurrency: FiatCurrency,
+    ) : WalletDialog
+
+    data class RemoveWalletDialog(
+        val currencyTitle: String,
+        private val walletData: WalletData
+    ): WalletDialog {
+        val messageRes: Int = R.string.token_details_hide_alert_message
+        val titleRes: Int = R.string.token_details_hide_alert_title
+        val primaryButtonRes: Int = R.string.token_details_hide_alert_hide
+        val action = { store.dispatch(WalletAction.MultiWallet.RemoveWallet(walletData)) }
+    }
+
+    data class TokensAreLinkedDialog(
+        val currencyTitle: String,
+        val currencySymbol: String
+    ): WalletDialog {
+        val messageRes: Int = R.string.token_details_unable_hide_alert_message
+        val titleRes: Int = R.string.token_details_unable_hide_alert_title
+    }
+
+
+}
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/reducers/MultiWalletReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/reducers/MultiWalletReducer.kt
@ -7,10 +7,13 @@ import com.tangem.tap.common.extensions.toFiatString
 import com.tangem.tap.common.extensions.toFormattedCurrencyString
 import com.tangem.tap.domain.getFirstToken
 import com.tangem.tap.domain.tokens.models.BlockchainNetwork
+import com.tangem.tap.features.wallet.models.Currency
+import com.tangem.tap.features.wallet.models.WalletRent
 import com.tangem.tap.features.wallet.models.filterByToken
 import com.tangem.tap.features.wallet.models.getPendingTransactions
 import com.tangem.tap.features.wallet.models.removeUnknownTransactions
 import com.tangem.tap.features.wallet.redux.*
+import com.tangem.tap.features.wallet.redux.WalletState.Companion.UNKNOWN_AMOUNT_SIGN
 import com.tangem.tap.features.wallet.ui.BalanceStatus
 import com.tangem.tap.features.wallet.ui.BalanceWidgetData
 import com.tangem.tap.features.wallet.ui.TokenData
@ -102,10 +105,10 @@ class MultiWalletReducer {
            }
            is WalletAction.MultiWallet.TokenLoaded -> {
                val currency = Currency.fromBlockchainNetwork(action.blockchain, action.token)
-                val wallet = state.getWalletManager(currency)?.wallet.guard {
-                    throw NullPointerException("MultiWallet.TokenLoaded: WalletManager must be no NULL")
+                val walletManager = state.getWalletManager(currency).guard {
+                    throw NullPointerException("MultiWallet.TokenLoaded: WalletManager must be not NULL")
                }
-
+                val wallet = walletManager.wallet
                val pendingTransactions = wallet.getPendingTransactions()
                val tokenPendingTransactions = pendingTransactions.filterByToken(action.token)
                val tokenBalanceStatus = when {
@ -125,9 +128,8 @@ class MultiWalletReducer {
                            action.amount.decimals, action.amount.currencySymbol
                        ),
                        fiatAmountFormatted = tokenWalletData.fiatRate?.let {
-                            action.amount.value
-                                ?.toFiatString(it, store.state.globalState.appCurrency.symbol)
-                        },
+                            action.amount.value?.toFiatString(it, store.state.globalState.appCurrency.symbol)
+                        } ?: UNKNOWN_AMOUNT_SIGN,
                        blockchainAmount = wallet.amounts[AmountType.Coin]?.value ?: BigDecimal.ZERO
                    ),
                    pendingTransactions = pendingTransactions.removeUnknownTransactions(),
@ -136,7 +138,8 @@ class MultiWalletReducer {
                        token = action.token,
                        blockchain = action.blockchain.blockchain,
                        derivationPath = action.blockchain.derivationPath
-                    )
+                    ),
+                    walletRent = findWalletRent(state.getWalletStore(walletManager.wallet))
                )
                state.updateWalletData(newTokenWalletData)
            }
@ -157,8 +160,15 @@ class MultiWalletReducer {
 //            is WalletAction.MultiWallet.FindTokensInUse -> state
 //            is WalletAction.MultiWallet.FindBlockchainsInUse -> state
            is WalletAction.MultiWallet.SaveCurrencies -> state
+            is WalletAction.MultiWallet.TryToRemoveWallet -> state
        }
    }
+
+    private fun findWalletRent(walletStore: WalletStore?): WalletRent? {
+        return walletStore?.walletsData?.firstOrNull {
+            it.walletRent != null
+        }?.walletRent
+    }
 }

 private fun addTokens(
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/reducers/OnWalletLoadedReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/reducers/OnWalletLoadedReducer.kt
@ -9,15 +9,16 @@ 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.models.BlockchainNetwork
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.models.filterByToken
 import com.tangem.tap.features.wallet.models.getPendingTransactions
 import com.tangem.tap.features.wallet.models.removeUnknownTransactions
 import com.tangem.tap.features.wallet.redux.*
+import com.tangem.tap.features.wallet.redux.WalletState.Companion.UNKNOWN_AMOUNT_SIGN
 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.RoundingMode

 class OnWalletLoadedReducer {

@ -54,6 +55,8 @@ class OnWalletLoadedReducer {
        }

        val fiatAmount = walletData.fiatRate?.let { coinAmountValue?.toFiatValue(it) }
+        val fiatAmountFormatted = fiatAmount?.toFormattedFiatValue(fiatCurrency.symbol) ?: UNKNOWN_AMOUNT_SIGN
+
        val newWalletData = walletData.copy(
            currencyData = walletData.currencyData.copy(
                status = balanceStatus,
@ -63,7 +66,7 @@ class OnWalletLoadedReducer {
                amount = coinAmountValue,
                amountFormatted = formattedAmount,
                fiatAmount = fiatAmount,
-                fiatAmountFormatted = fiatAmount?.toFormattedFiatValue(fiatCurrency.symbol)
+                fiatAmountFormatted = fiatAmountFormatted,
            ),
            pendingTransactions = pendingTransactions.removeUnknownTransactions(),
            mainButton = WalletMainButton.SendButton(isCoinSendButtonEnabled),
@ -81,8 +84,9 @@ class OnWalletLoadedReducer {
                else -> BalanceStatus.VerifiedOnline
            }
            val tokenAmountValue = wallet.getTokenAmount(token)?.value
-            val tokenFiatAmount =
-                tokenWalletData?.fiatRate?.let { rate -> tokenAmountValue?.toFiatValue(rate) }
+            val tokenFiatAmount = tokenWalletData?.fiatRate?.let { tokenAmountValue?.toFiatValue(it) }
+            val tokenFiatAmountFormatted = tokenFiatAmount?.toFormattedFiatValue(fiatCurrency.symbol)
+                ?: UNKNOWN_AMOUNT_SIGN

            val isTokenSendButtonEnabled = newWalletData.shouldEnableTokenSendButton()
                && pendingTransactions.isEmpty()
@ -96,7 +100,7 @@ class OnWalletLoadedReducer {
                        token.symbol
                    ),
                    fiatAmount = tokenFiatAmount,
-                    fiatAmountFormatted = tokenFiatAmount?.toFormattedFiatValue(fiatCurrency.symbol)
+                    fiatAmountFormatted = tokenFiatAmountFormatted,
                ),
                pendingTransactions = tokenPendingTransactions.removeUnknownTransactions(),
                mainButton = WalletMainButton.SendButton(isTokenSendButtonEnabled),
@ -140,9 +144,8 @@ class OnWalletLoadedReducer {
            wallet.blockchain.decimals(),
            wallet.blockchain.currency
        )
-        val fiatRate = walletState.primaryWallet?.fiatRate
-        val fiatAmountRaw = fiatRate?.multiply(amount)?.setScale(2, RoundingMode.DOWN)
-        val fiatAmount = fiatRate?.let { amount?.toFiatString(it, fiatCurrencyName) }
+        val fiatAmount = walletState.primaryWallet?.fiatRate?.let { amount?.toFiatValue(it) }
+        val fiatAmountFormatted = fiatAmount?.toFormattedFiatValue(fiatCurrencyName) ?: UNKNOWN_AMOUNT_SIGN

        val pendingTransactions = wallet.getPendingTransactions()
        val sendButtonEnabled = amount?.isZero() == false && pendingTransactions.isEmpty()
@ -159,8 +162,8 @@ class OnWalletLoadedReducer {
                blockchainAmount = amount,
                amount = amount,
                amountFormatted = formattedAmount,
-                fiatAmountFormatted = fiatAmount,
-                fiatAmount = fiatAmountRaw
+                fiatAmount = fiatAmount,
+                fiatAmountFormatted = fiatAmountFormatted
            ),
            pendingTransactions = pendingTransactions.removeUnknownTransactions(),
            mainButton = WalletMainButton.SendButton(sendButtonEnabled),
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/reducers/WalletReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/reducers/WalletReducer.kt
@ -19,7 +19,7 @@ import com.tangem.tap.domain.tokens.models.BlockchainNetwork
 import com.tangem.tap.features.wallet.models.WalletRent
 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.models.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
@ -217,8 +217,8 @@ private fun internalReduce(action: Action, state: AppState): WalletState {
                            currency = walletBlockchain.currency,
                        ),
                        fiatAmount = fiatAmount,
-                        fiatAmountFormatted = fiatAmount.toFiatRateString(
-                            fiatCurrencyName = store.state.globalState.appCurrency.symbol
+                        fiatAmountFormatted = fiatAmount.toFormattedFiatValue(
+                            fiatCurrencyName = state.globalState.appCurrency.symbol
                        ),
                        amountToCreateAccount = action.amountToCreateAccount,
                    )
@ -439,7 +439,7 @@ private fun setMultiWalletFiatRate(
                wallet?.getTokenAmount(currency.token)?.value?.toFiatValue(rate)
        }
        if (currencyData.status == BalanceStatus.NoAccount && fiatAmount == null) {
-            fiatAmount = BigDecimal.ZERO
+            fiatAmount = BigDecimal.ZERO.setScale(2)
        }
        val fiatAmountFormatted = fiatAmount?.toFormattedFiatValue(appCurrency.symbol)

--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/BalanceWidget.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/BalanceWidget.kt
@ -26,8 +26,8 @@ data class BalanceWidgetData(
    val blockchainAmount: BigDecimal? = BigDecimal.ZERO,
    val amount: BigDecimal? = null,
    val amountFormatted: String? = null,
-    val fiatAmountFormatted: String? = null,
    val fiatAmount: BigDecimal? = null,
+    val fiatAmountFormatted: String? = null,
    val token: TokenData? = null,
    val amountToCreateAccount: String? = null,
    val errorMessage: String? = null
--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/WalletDetailsFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/WalletDetailsFragment.kt
@ -1,11 +1,7 @@
 package com.tangem.tap.features.wallet.ui

 import android.os.Bundle
-import android.view.Menu
-import android.view.MenuInflater
-import android.view.MenuItem
-import android.view.View
-import android.view.ViewGroup
+import android.view.*
 import android.widget.TextView
 import androidx.activity.OnBackPressedCallback
 import androidx.annotation.ColorRes
@ -15,31 +11,21 @@ import androidx.fragment.app.Fragment
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.transition.TransitionInflater
 import by.kirich1409.viewbindingdelegate.viewBinding
-import com.squareup.picasso.Picasso
+import com.tangem.tangem_sdk_new.extensions.dpToPx
 import com.tangem.tap.common.SnackbarHandler
 import com.tangem.tap.common.TestActions
-import com.tangem.tap.common.extensions.appendIfNotNull
-import com.tangem.tap.common.extensions.beginDelayedTransition
-import com.tangem.tap.common.extensions.fitChipsByGroupWidth
-import com.tangem.tap.common.extensions.getColor
-import com.tangem.tap.common.extensions.getString
-import com.tangem.tap.common.extensions.hide
-import com.tangem.tap.common.extensions.loadCurrenciesIcon
-import com.tangem.tap.common.extensions.show
-import com.tangem.tap.common.extensions.toQrCode
+import com.tangem.tap.common.extensions.*
 import com.tangem.tap.common.recyclerView.SpaceItemDecoration
 import com.tangem.tap.common.redux.navigation.NavigationAction
 import com.tangem.tap.domain.tokens.models.BlockchainNetwork
 import com.tangem.tap.features.onboarding.getQRReceiveMessage
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.models.PendingTransaction
-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.WalletAction
-import com.tangem.tap.features.wallet.redux.WalletData
-import com.tangem.tap.features.wallet.redux.WalletState
+import com.tangem.tap.features.wallet.redux.*
+import com.tangem.tap.features.wallet.redux.WalletState.Companion.UNKNOWN_AMOUNT_SIGN
 import com.tangem.tap.features.wallet.ui.adapters.PendingTransactionsAdapter
 import com.tangem.tap.features.wallet.ui.adapters.WalletDetailWarningMessagesAdapter
+import com.tangem.tap.features.wallet.ui.images.loadCurrencyIcon
 import com.tangem.tap.features.wallet.ui.test.TestWalletDetails
 import com.tangem.tap.store
 import com.tangem.wallet.R
@ -143,16 +129,18 @@ class WalletDetailsFragment : Fragment(R.layout.fragment_wallet_details),

        handleCurrencyIcon(selectedWallet)
        handleWarnings(selectedWallet)
+        updateViewMeasurements()

        binding.srlWalletDetails.setOnRefreshListener {
            if (selectedWallet.currencyData.status != BalanceStatus.Loading) {
                store.dispatch(WalletAction.LoadWallet(
-                    blockchain = BlockchainNetwork(
-                        selectedWallet.currency.blockchain,
-                        selectedWallet.currency.derivationPath,
-                        emptyList()
+                        blockchain = BlockchainNetwork(
+                            selectedWallet.currency.blockchain,
+                            selectedWallet.currency.derivationPath,
+                            emptyList()
+                        )
                    )
-                ))
+                )
            }
        }

@ -161,13 +149,27 @@ class WalletDetailsFragment : Fragment(R.layout.fragment_wallet_details),
        }
    }

+    private fun updateViewMeasurements() {
+        val tvFiatAmount = binding.lWalletDetails.lBalance.tvFiatAmount
+        val paddingStart = when (tvFiatAmount.text) {
+            UNKNOWN_AMOUNT_SIGN -> 16f
+            else -> 12f
+        }
+        tvFiatAmount.setPadding(
+            tvFiatAmount.dpToPx(paddingStart).toInt(),
+            tvFiatAmount.paddingTop,
+            tvFiatAmount.paddingEnd,
+            tvFiatAmount.paddingBottom,
+        )
+    }
+
    private fun setupCurrency(currencyData: BalanceWidgetData, currency: Currency) = with(binding) {
        tvCurrencyTitle.text = currencyData.currency
        if (currency is Currency.Token) {
-            binding.tvCurrencySubtitle.text = currency.blockchain.tokenDisplayName()
-            binding.tvCurrencySubtitle.show()
+            tvCurrencySubtitle.text = currency.blockchain.tokenDisplayName()
+            tvCurrencySubtitle.show()
        } else {
-            binding.tvCurrencySubtitle.hide()
+            tvCurrencySubtitle.hide()
        }
    }

@ -199,9 +201,9 @@ class WalletDetailsFragment : Fragment(R.layout.fragment_wallet_details),
    }

    private fun handleCurrencyIcon(wallet: WalletData) = with(binding.lWalletDetails.lBalance) {
-        Picasso.get().loadCurrenciesIcon(
-            imageView = ivCurrency,
-            textView = tvTokenLetter,
+        loadCurrencyIcon(
+            currencyImageView = ivCurrency,
+            currencyTextView = tvTokenLetter,
            blockchain = wallet.currency.blockchain,
            token = (wallet.currency as? Currency.Token)?.token
        )
@ -295,7 +297,10 @@ class WalletDetailsFragment : Fragment(R.layout.fragment_wallet_details),
                lBalance.root.show()
                lBalance.groupBalance.hide()
                lBalance.tvError.show()
-                lBalance.tvError.setWarningStatus(R.string.wallet_balance_blockchain_unreachable, data.errorMessage)
+                lBalance.tvError.setWarningStatus(
+                    R.string.wallet_balance_blockchain_unreachable,
+                    data.errorMessage
+                )
            }
            BalanceStatus.NoAccount -> {
                lBalance.root.hide()
@ -314,9 +319,7 @@ class WalletDetailsFragment : Fragment(R.layout.fragment_wallet_details),
        return when (item.itemId) {
            R.id.menu_remove -> {
                store.state.walletState.getSelectedWalletData()?.let { walletData ->
-                    store.dispatch(WalletAction.MultiWallet.RemoveWallet(walletData))
-                    store.dispatch(WalletAction.MultiWallet.SelectWallet(null))
-                    store.dispatch(NavigationAction.PopBackTo())
+                    store.dispatch(WalletAction.MultiWallet.TryToRemoveWallet(walletData))
                    true
                }
                false
@ -327,10 +330,6 @@ class WalletDetailsFragment : Fragment(R.layout.fragment_wallet_details),

    override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
        inflater.inflate(R.menu.wallet_details, menu)
-        val walletCanBeRemoved = store.state.walletState.canBeRemoved(
-            store.state.walletState.getSelectedWalletData()
-        )
-        menu.getItem(0).isEnabled = walletCanBeRemoved
    }

    private fun TextView.setWarningStatus(mainMessage: Int, error: String? = null) {
@ -346,7 +345,11 @@ class WalletDetailsFragment : Fragment(R.layout.fragment_wallet_details),
        setStatus(getString(mainMessage), R.color.darkGray4, null)
    }

-    private fun TextView.setStatus(text: String, @ColorRes color: Int, @DrawableRes drawable: Int?) {
+    private fun TextView.setStatus(
+        text: String,
+        @ColorRes color: Int,
+        @DrawableRes drawable: Int?
+    ) {
        this.text = text
        setTextColor(getColor(color))
        setCompoundDrawablesWithIntrinsicBounds(drawable ?: 0, 0, 0, 0)
--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/WalletFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/WalletFragment.kt
@ -12,7 +12,7 @@ import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import androidx.transition.TransitionInflater
 import by.kirich1409.viewbindingdelegate.viewBinding
-import com.squareup.picasso.Picasso
+import coil.load
 import com.tangem.tap.MainActivity
 import com.tangem.tap.common.extensions.show
 import com.tangem.tap.common.recyclerView.SpaceItemDecoration
@ -165,11 +165,11 @@ class WalletFragment : Fragment(R.layout.fragment_wallet), StoreSubscriber<Walle
    }

    private fun setupCardImage(cardImage: Artwork?) {
-        Picasso.get()
-            .load(cardImage?.artworkId)
-            .placeholder(R.drawable.card_placeholder_black)
-            ?.error(R.drawable.card_placeholder_black)
-            ?.into(binding.ivCard)
+        binding.ivCard.load(cardImage?.artworkId) {
+            placeholder(R.drawable.card_placeholder_black)
+            error(R.drawable.card_placeholder_black)
+            fallback(R.drawable.card_placeholder_black)
+        }
    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/adapters/WalletAdapter.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/adapters/WalletAdapter.kt
@ -6,18 +6,17 @@ import androidx.core.view.isVisible
 import androidx.recyclerview.widget.DiffUtil
 import androidx.recyclerview.widget.ListAdapter
 import androidx.recyclerview.widget.RecyclerView
-import com.squareup.picasso.Picasso
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.Token
 import com.tangem.domain.common.TapWorkarounds.derivationStyle
 import com.tangem.tap.common.extensions.getString
 import com.tangem.tap.common.extensions.hide
-import com.tangem.tap.common.extensions.loadCurrenciesIcon
 import com.tangem.tap.common.extensions.show
-import com.tangem.tap.features.wallet.redux.Currency
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.WalletAction
 import com.tangem.tap.features.wallet.redux.WalletData
 import com.tangem.tap.features.wallet.ui.BalanceStatus
+import com.tangem.tap.features.wallet.ui.images.loadCurrencyIcon
 import com.tangem.tap.store
 import com.tangem.wallet.R
 import com.tangem.wallet.databinding.ItemCurrencyWalletBinding
@ -98,16 +97,16 @@ class WalletAdapter
                lContent.root.show()
            }

-            Picasso.get().loadCurrenciesIcon(
-                imageView = ivCurrency,
-                textView = tvTokenLetter,
+            loadCurrencyIcon(
+                currencyImageView = ivCurrency,
+                currencyTextView = tvTokenLetter,
                token = (wallet.currency as? Currency.Token)?.token,
                blockchain = wallet.currency.blockchain,
            )

            lContent.tvCurrency.text = wallet.currencyData.currency
-            lContent.tvAmountFiat.text = wallet.currencyData.fiatAmountFormatted ?: "—"
-            lContent.tvAmount.text = wallet.currencyData.amountFormatted ?: "—"
+            lContent.tvAmountFiat.text = wallet.currencyData.fiatAmountFormatted
+            lContent.tvAmount.text = wallet.currencyData.amountFormatted

            lContent.tvStatus.isVisible = statusMessage != null
            lContent.tvStatus.text = statusMessage
--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/dialogs/AmountToSendBottomSheetDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/dialogs/AmountToSendBottomSheetDialog.kt
@ -5,16 +5,12 @@ import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.ViewGroup
 import androidx.appcompat.view.ContextThemeWrapper
-import androidx.recyclerview.widget.DiffUtil
-import androidx.recyclerview.widget.DividerItemDecoration
-import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.recyclerview.widget.ListAdapter
-import androidx.recyclerview.widget.RecyclerView
+import androidx.recyclerview.widget.*
 import com.google.android.material.bottomsheet.BottomSheetDialog
 import com.tangem.blockchain.common.Amount
 import com.tangem.tap.common.extensions.toFormattedString
 import com.tangem.tap.features.wallet.redux.WalletAction
-import com.tangem.tap.features.wallet.redux.WalletDialog
+import com.tangem.tap.features.wallet.redux.models.WalletDialog
 import com.tangem.tap.store
 import com.tangem.wallet.R
 import com.tangem.wallet.databinding.DialogWalletSendBinding
--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/images/CurrencyIconRequest.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/images/CurrencyIconRequest.kt
@ -0,0 +1,109 @@
+package com.tangem.tap.features.wallet.ui.images
+
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.constraintlayout.utils.widget.ImageFilterView
+import coil.imageLoader
+import coil.load
+import coil.request.ImageRequest
+import coil.transform.RoundedCornersTransformation
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.IconsUtil
+import com.tangem.blockchain.common.Token
+import com.tangem.domain.common.extensions.toNetworkId
+import com.tangem.tap.common.extensions.getColor
+import com.tangem.tap.common.extensions.getRoundIconRes
+import com.tangem.tap.common.extensions.getTextColor
+import com.tangem.tap.domain.extensions.getCustomIconUrl
+import com.tangem.tap.domain.tokens.getIconUrl
+import com.tangem.wallet.R
+
+private const val QCX = "QCX"
+private const val VOYR = "VOYRME"
+
+fun loadCurrencyIcon(
+    currencyImageView: ImageFilterView,
+    currencyTextView: TextView,
+    token: Token?,
+    blockchain: Blockchain,
+) {
+    when {
+        token == null -> currencyImageView.loadIcon(
+            iconUrl = getIconUrl(blockchain.toNetworkId()),
+            placeholderRes = blockchain.getRoundIconRes(),
+            onStart = {
+                if (blockchain.isTestnet()) {
+                    currencyImageView.saturation = 0f
+                } else {
+                    currencyImageView.colorFilter = null
+                }
+            }
+        )
+        token.symbol == QCX -> currencyImageView.load(R.drawable.ic_qcx)
+        token.symbol == VOYR -> currencyImageView.load(R.drawable.ic_voyr)
+        else -> currencyImageView.loadIcon(
+            iconUrl = getTokenIconUrl(token, blockchain),
+            placeholderRes = R.drawable.shape_circle,
+            onStart = {
+                currencyTextView.text = token.symbol.take(1)
+                currencyTextView.setTextColor(token.getTextColor())
+
+                if (blockchain.isTestnet()) {
+                    currencyImageView.saturation = 0f
+                }
+            },
+            onError = {
+                currencyImageView.colorFilter = PorterDuffColorFilter(
+                    /* color = */
+                    token.getColor(),
+                    /* mode = */
+                    PorterDuff.Mode.SRC_ATOP,
+                )
+            },
+            onSuccess = {
+                if (!blockchain.isTestnet()) {
+                    currencyImageView.colorFilter = null
+                }
+            }
+        )
+    }
+}
+
+private inline fun ImageView.loadIcon(
+    iconUrl: String?,
+    placeholderRes: Int,
+    crossinline onStart: () -> Unit = {},
+    crossinline onSuccess: () -> Unit = {},
+    crossinline onError: () -> Unit = {},
+) {
+    ImageRequest.Builder(context)
+        .data(iconUrl)
+        .placeholder(placeholderRes)
+        .error(placeholderRes)
+        .fallback(placeholderRes)
+        .transformations(
+            RoundedCornersTransformation(
+                topLeft = 32f,
+                topRight = 32f,
+                bottomLeft = 32f,
+                bottomRight = 32f
+            )
+        )
+        .listener(
+            onStart = { onStart() },
+            onSuccess = { _, _ -> onSuccess() },
+            onError = { _, _ -> onError() }
+        )
+        .target(imageView = this)
+        .build()
+        .also(context.imageLoader::enqueue)
+}
+
+private fun getTokenIconUrl(token: Token, blockchain: Blockchain): String? {
+    return token.id?.let(::getIconUrl)
+        ?: token.getCustomIconUrl()
+        ?: IconsUtil.getTokenIconUri(blockchain, token)
+            ?.toString()
+}
--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/wallet/CurrencySelectionDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/wallet/CurrencySelectionDialog.kt
@ -3,7 +3,7 @@ package com.tangem.tap.features.wallet.ui.wallet
 import android.content.Context
 import androidx.appcompat.app.AlertDialog
 import com.tangem.tap.features.wallet.redux.WalletAction
-import com.tangem.tap.features.wallet.redux.WalletDialog
+import com.tangem.tap.features.wallet.redux.models.WalletDialog
 import com.tangem.tap.store
 import com.tangem.wallet.R

--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/wallet/SingleWalletView.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/wallet/SingleWalletView.kt
@ -10,13 +10,9 @@ import com.tangem.tap.common.extensions.fitChipsByGroupWidth
 import com.tangem.tap.common.extensions.hide
 import com.tangem.tap.common.extensions.show
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsState
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.models.PendingTransaction
-import com.tangem.tap.features.wallet.redux.Currency
-import com.tangem.tap.features.wallet.redux.TradeCryptoState
-import com.tangem.tap.features.wallet.redux.WalletAction
-import com.tangem.tap.features.wallet.redux.WalletData
-import com.tangem.tap.features.wallet.redux.WalletMainButton
-import com.tangem.tap.features.wallet.redux.WalletState
+import com.tangem.tap.features.wallet.redux.*
 import com.tangem.tap.features.wallet.ui.BalanceWidget
 import com.tangem.tap.features.wallet.ui.MultipleAddressUiHelper
 import com.tangem.tap.features.wallet.ui.WalletFragment