Updated on 2026-08-14

2023-02-27 16:55:53 +03:00 · 2023-02-27 16:55:53 +03:00 · 2c78e27915
commit 2c78e27915
parent 73d7b186d9 90c8ac23b4
140 changed files with 3963 additions and 630 deletions
--- a/app/src/main/java/com/tangem/tap/common/ShimmerRecyclerAdapter.kt
+++ b/app/src/main/java/com/tangem/tap/common/ShimmerRecyclerAdapter.kt
@ -0,0 +1,33 @@
+package com.tangem.tap.common
+
+import android.view.ViewGroup
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.ListAdapter
+import androidx.recyclerview.widget.RecyclerView
+
+/**
+[REDACTED_AUTHOR]
+ */
+open class ShimmerRecyclerAdapter(
+    private val viewHolderViewFactory: (ViewGroup) -> ViewGroup,
+) : ListAdapter<ShimmerData, ShimmerVH>(DiffUtilCallback) {
+
+    override fun getItemId(position: Int): Long {
+        return if (currentList.isEmpty()) 0 else currentList[position].hashCode().toLong()
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ShimmerVH {
+        return ShimmerVH(viewHolderViewFactory.invoke(parent))
+    }
+
+    override fun onBindViewHolder(holder: ShimmerVH, position: Int) {}
+
+    object DiffUtilCallback : DiffUtil.ItemCallback<ShimmerData>() {
+        override fun areContentsTheSame(oldItem: ShimmerData, newItem: ShimmerData) = oldItem == newItem
+        override fun areItemsTheSame(oldItem: ShimmerData, newItem: ShimmerData) = oldItem == newItem
+    }
+}
+
+class ShimmerVH(viewGroup: ViewGroup) : RecyclerView.ViewHolder(viewGroup)
+
+data class ShimmerData(private val any: String = "")
--- a/app/src/main/java/com/tangem/tap/common/analytics/converters/BasicEventConverter.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/converters/BasicEventConverter.kt
@ -114,19 +114,53 @@ data class BasicEventsSourceData(
    val paramCardBalanceState: AnalyticsParam.CardBalanceState by lazy { calculateAmount().toCardBalanceState() }

    private fun calculateAmount(): BigDecimal {
-        return biometricsWalletDataModels?.calculateTotalCryptoAmount()
-            ?: walletState.walletsDataFromStores.calculateTotalCryptoAmount()
+        val calculator: IBalanceCalculator = biometricsWalletDataModels
+            ?.let { BiometricsBalanceCalculator(it) }
+            ?: BalanceCalculator(walletState)
+
+        return calculator.calculate()
    }

    private fun BigDecimal.toCardBalanceState(): AnalyticsParam.CardBalanceState = when {
        isZero() -> AnalyticsParam.CardBalanceState.Empty
        else -> AnalyticsParam.CardBalanceState.Full
    }
+}

-    private fun List<WalletDataModel>.calculateTotalCryptoAmount(): BigDecimal {
-        return this
-            .map { it.status.amount }
-            .reduce(BigDecimal::plus)
+private interface IBalanceCalculator {
+    fun calculate(): BigDecimal
+}
+
+private class BiometricsBalanceCalculator(
+    private val walletDataModel: List<WalletDataModel>,
+) : IBalanceCalculator {
+
+    override fun calculate(): BigDecimal {
+        val singleToken = walletDataModel
+            .filter { it.currency.isToken() }
+            .firstOrNull { it.isCardSingleToken }
+
+        val totalAmount = singleToken?.status?.amount
+            ?: walletDataModel.calculateTotalCryptoAmount()
+
+        return totalAmount
+    }
+
+    private fun List<WalletDataModel>.calculateTotalCryptoAmount(): BigDecimal = this
+        .map { it.status.amount }
+        .reduce(BigDecimal::plus)
+}
+
+private class BalanceCalculator(
+    private val walletState: WalletState,
+) : IBalanceCalculator {
+
+    override fun calculate(): BigDecimal {
+        val singleTokenData = walletState.primaryTokenData
+        val totalAmount = singleTokenData?.currencyData?.amount
+            ?: walletState.walletsDataFromStores.calculateTotalCryptoAmount()
+
+        return totalAmount
    }
 }

--- a/app/src/main/java/com/tangem/tap/common/analytics/events/AnalyticsParam.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/events/AnalyticsParam.kt
@ -10,7 +10,7 @@ sealed class AnalyticsParam {
        class Token(token: com.tangem.blockchain.common.Token) : CurrencyType(token.symbol)
        class FiatCurrency(
            fiatCurrency: com.tangem.tap.common.entities.FiatCurrency,
-        ) : CurrencyType(fiatCurrency.symbol)
+        ) : CurrencyType(fiatCurrency.code)

        class Amount(amount: com.tangem.blockchain.common.Amount) : CurrencyType(amount.currencySymbol)
    }
@ -63,8 +63,18 @@ sealed class AnalyticsParam {
        object BlockchainSdk : Error("Blockchain Sdk Error")
    }

+    sealed class ScannedFrom(val value: String) {
+        object Introduction : ScannedFrom("Introduction")
+        object Main : ScannedFrom("Main")
+        object SignIn : ScannedFrom("Sign In")
+        object MyWallets : ScannedFrom("My Wallets")
+    }
+
    companion object Key {
-        const val BatchId = "Batch"
+        const val Batch = "Batch"
+        const val ProductType = "Product Type"
+        const val Firmware = "Firmware"
+        const val Currency = "Currency"
        const val ErrorDescription = "Error Description"
        const val ErrorCode = "Error Code"
        const val ErrorKey = "Error Key"
--- a/app/src/main/java/com/tangem/tap/common/analytics/events/Basic.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/events/Basic.kt
@ -11,6 +11,15 @@ sealed class Basic(
    error: Throwable? = null,
 ) : AnalyticsEvent("Basic", event, params, error) {

+    class CardWasScanned(
+        source: AnalyticsParam.ScannedFrom,
+    ) : Basic(
+        event = "Card Was Scanned",
+        params = mapOf(
+            "Source" to source.value,
+        ),
+    )
+
    class SignedIn(
        state: AnalyticsParam.CardBalanceState,
        currency: AnalyticsParam.CardCurrency,
@ -19,14 +28,14 @@ sealed class Basic(
        event = "Signed in",
        params = mapOf(
            "State" to state.value,
-            "Currency" to currency.value,
-            AnalyticsParam.BatchId to batch,
+            AnalyticsParam.Currency to currency.value,
+            AnalyticsParam.Batch to batch,
        ),
    )

    class ToppedUp(currency: AnalyticsParam.CardCurrency) : Basic(
        event = "Topped up",
-        params = mapOf("Currency" to currency.value),
+        params = mapOf(AnalyticsParam.Currency to currency.value),
    )

    class ScanError(error: Throwable) : Basic(
--- a/app/src/main/java/com/tangem/tap/common/analytics/events/IntroductionProcess.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/events/IntroductionProcess.kt
@ -14,6 +14,5 @@ sealed class IntroductionProcess(
    class ButtonTokensList : IntroductionProcess("Button - Tokens List")
    class ButtonBuyCards : IntroductionProcess("Button - Buy Cards")
    class ButtonScanCard : IntroductionProcess("Button - Scan Card")
-    class CardWasScanned : IntroductionProcess("Card Was Scanned")
    class ButtonRequestSupport : IntroductionProcess("Button - Request Support")
 }
--- a/app/src/main/java/com/tangem/tap/common/analytics/events/MainScreen.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/events/MainScreen.kt
@ -13,8 +13,8 @@ sealed class MainScreen(
    class ScreenOpened : MainScreen("Screen opened")

    class ButtonScanCard : MainScreen("Button - Scan Card")
-    class CardWasScanned : MainScreen("Card Was Scanned")
    class ButtonMyWallets : MainScreen("Button - My Wallets")
+    class ButtonBuy : MainScreen("Button - Buy")

    class EnableBiometrics(state: AnalyticsParam.OnOffState) : MainScreen(
        event = "Enable Biometric",
--- a/app/src/main/java/com/tangem/tap/common/analytics/events/MyWallets.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/events/MyWallets.kt
@ -8,7 +8,6 @@ sealed class MyWallets(
 ) : AnalyticsEvent("My Wallets", event, params) {

    class MyWalletsScreenOpened : MyWallets(event = "My Wallets Screen Opened")
-    class CardWasScanned : MyWallets(event = "Card Was Scanned")

    sealed class Button {
        class ScanNewCard : MyWallets(event = "Button - Scan New Card")
--- a/app/src/main/java/com/tangem/tap/common/analytics/events/Onboarding.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/events/Onboarding.kt
@ -51,7 +51,7 @@ sealed class Onboarding(

        class ButtonBuyCrypto(currency: AnalyticsParam.CurrencyType) : Topup(
            event = "Button - Buy Crypto",
-            params = mapOf("Currency" to currency.value),
+            params = mapOf(AnalyticsParam.Currency to currency.value),
        )

        class ButtonShowWalletAddress : Topup("Button - Show the Wallet Address")
@ -67,16 +67,26 @@ sealed class Onboarding(
        class SetupFinished : Twins("Twin Setup Finished")
    }

-    class PinCodeSet : Onboarding("Onboarding", "PIN code set")
+    class PinScreenOpened : Onboarding("Onboarding", "PIN screen opened")
+    class ButtonSetPinCode : Onboarding("Onboarding", "Button - Set PIN Code")
+    class CardConnectionScreenOpened : Onboarding("Onboarding", "Card Connection Screen Opened")
    class ButtonConnect : Onboarding("Onboarding", "Button - Connect")
+    class PinCodeSet : Onboarding("Onboarding", "PIN code set")
+
+    class KYCScreenOpened : Onboarding("Onboarding", "KYC screen opened")
    class KYCStarted : Onboarding("Onboarding", "KYC started")
    class KYCInProgress : Onboarding("Onboarding", "KYC in progress")
    class KYCRejected : Onboarding("Onboarding", "KYC rejected")
+
    class ClaimScreenOpened : Onboarding("Onboarding", "Claim screen opened")
    class ButtonClaim : Onboarding("Onboarding", "Button - Claim")
    class ClaimWasSuccessfully : Onboarding("Onboarding", "Claim was successfully")
+
    class ButtonChat : Onboarding("Onboarding", "Button - Chat")

+    class NotEnoughGasError : Onboarding("Onboarding", "Not Enough Gas Error")
+    class CardNotPassedError : Onboarding("Onboarding", "Card Not Passed Error")
+
    class EnableBiometrics(state: AnalyticsParam.OnOffState) : Onboarding(
        category = "Onboarding / Biometric",
        event = "Enable Biometric",
--- a/app/src/main/java/com/tangem/tap/common/analytics/events/SignIn.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/events/SignIn.kt
@ -12,7 +12,6 @@ sealed class SignIn(
 ) : AnalyticsEvent("Sign In", event, params, error) {

    class ScreenOpened : SignIn(event = "Sing In Screen Opened")
-    class CardWasScanned : SignIn(event = "Card Was Scanned")

    class ButtonBiometricSignIn : SignIn(event = "Button - Biometric Sign In")
    class ButtonCardSignIn : SignIn(event = "Button - Card Sign In")
--- a/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/BatchIdParamsInterceptor.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/BatchIdParamsInterceptor.kt
@ -1,21 +0,0 @@
-package com.tangem.tap.common.analytics.paramsInterceptor
-
-import com.tangem.core.analytics.api.ParamsInterceptor
-import com.tangem.core.analytics.AnalyticsEvent
-import com.tangem.tap.common.analytics.events.AnalyticsParam
-
-/**
-[REDACTED_AUTHOR]
- */
-class BatchIdParamsInterceptor(
-    val batchId: String,
-) : ParamsInterceptor {
-
-    override fun id(): String = this::class.java.simpleName
-
-    override fun canBeAppliedTo(event: AnalyticsEvent): Boolean = true
-
-    override fun intercept(params: MutableMap<String, String>) {
-        params[AnalyticsParam.BatchId] = batchId
-    }
-}
--- a/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/CardContextInterceptor.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/CardContextInterceptor.kt
@ -0,0 +1,72 @@
+package com.tangem.tap.common.analytics.paramsInterceptor
+
+import com.tangem.core.analytics.AnalyticsEvent
+import com.tangem.core.analytics.api.ParamsInterceptor
+import com.tangem.domain.common.ProductType
+import com.tangem.domain.common.ScanResponse
+import com.tangem.tap.common.analytics.converters.ParamCardCurrencyConverter
+import com.tangem.tap.common.analytics.events.AnalyticsParam
+import com.tangem.tap.common.analytics.events.IntroductionProcess
+import com.tangem.tap.common.analytics.events.MainScreen
+import com.tangem.tap.features.demo.DemoHelper
+
+/**
+[REDACTED_AUTHOR]
+ */
+class CardContextInterceptor(
+    private val scanResponse: ScanResponse?,
+) : ParamsInterceptor {
+
+    override fun id(): String = CardContextInterceptor.id()
+
+    override fun canBeAppliedTo(event: AnalyticsEvent): Boolean {
+        return when (event) {
+            is IntroductionProcess.ButtonScanCard, is MainScreen.ButtonScanCard -> false
+            else -> true
+        }
+    }
+
+    override fun intercept(params: MutableMap<String, String>) {
+        scanResponse ?: return
+
+        val card = scanResponse.card
+        params[AnalyticsParam.Batch] = card.batchId
+        params[AnalyticsParam.ProductType] = getProductType(scanResponse)
+        params[AnalyticsParam.Firmware] = card.firmwareVersion.stringValue
+
+        ParamCardCurrencyConverter().convert(scanResponse.cardTypesResolver)?.let {
+            params[AnalyticsParam.Currency] = it.value
+        }
+    }
+
+    private fun getProductType(scanResponse: ScanResponse): String {
+        return when (scanResponse.productType) {
+            ProductType.Note -> "Note"
+            ProductType.Twins -> "Twin"
+            ProductType.Wallet -> "Wallet"
+            ProductType.SaltPay -> if (scanResponse.cardTypesResolver.isSaltPayVisa()) {
+                "Visa"
+            } else {
+                "Visa Backup"
+            }
+            ProductType.Start2Coin -> "Start2Coin"
+            else -> if (DemoHelper.isDemoCard(scanResponse)) {
+                if (DemoHelper.isTestDemoCard(scanResponse)) {
+                    "Demo Test"
+                } else {
+                    when (scanResponse.card.cardId.substring(0..1)) {
+                        "AC" -> "Demo Wallet"
+                        "AB" -> "Demo Note"
+                        else -> "Demo Other"
+                    }
+                }
+            } else {
+                "Other"
+            }
+        }
+    }
+
+    companion object {
+        fun id(): String = CardContextInterceptor::class.java.simpleName
+    }
+}
--- a/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/LinkedCardContextInterceptor.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/LinkedCardContextInterceptor.kt
@ -0,0 +1,26 @@
+package com.tangem.tap.common.analytics.paramsInterceptor
+
+import com.tangem.core.analytics.AnalyticsEvent
+import com.tangem.core.analytics.api.ParamsInterceptor
+import com.tangem.domain.common.ScanResponse
+
+/**
+[REDACTED_AUTHOR]
+ */
+class LinkedCardContextInterceptor(
+    private val scanResponse: ScanResponse,
+    val parent: LinkedCardContextInterceptor? = null,
+) : ParamsInterceptor {
+
+    private val contextInterceptor = CardContextInterceptor(scanResponse)
+
+    override fun id(): String = LinkedCardContextInterceptor.id()
+
+    override fun canBeAppliedTo(event: AnalyticsEvent): Boolean = contextInterceptor.canBeAppliedTo(event)
+
+    override fun intercept(params: MutableMap<String, String>) = contextInterceptor.intercept(params)
+
+    companion object {
+        fun id(): String = LinkedCardContextInterceptor::class.java.simpleName
+    }
+}
--- a/app/src/main/java/com/tangem/tap/common/chat/ChatManager.kt
+++ b/app/src/main/java/com/tangem/tap/common/chat/ChatManager.kt
@ -0,0 +1,53 @@
+package com.tangem.tap.common.chat
+
+import android.content.Context
+import android.os.Build
+import com.tangem.tap.ForegroundActivityObserver
+import com.tangem.datasource.config.models.ChatConfig
+import com.tangem.tap.common.chat.opener.ChatOpener
+import com.tangem.datasource.config.models.SprinklrConfig
+import com.tangem.datasource.config.models.ZendeskConfig
+import com.tangem.tap.common.chat.opener.implementation.SprinklrChatOpener
+import com.tangem.tap.common.chat.opener.implementation.ZendeskChatOpener
+import com.tangem.tap.common.redux.AppState
+import com.tangem.tap.persistence.PreferencesStorage
+import org.rekotlin.Store
+
+class ChatManager(
+    private val preferencesStorage: PreferencesStorage,
+    private val foregroundActivityObserver: ForegroundActivityObserver,
+    private val store: Store<AppState>,
+) {
+    private val openers = mutableMapOf<ChatConfig, ChatOpener>()
+
+    fun open(config: ChatConfig, feedbackDataBuilder: (Context) -> String) {
+        val opener = openers.getOrPut(config) {
+            when (config) {
+                is SprinklrConfig -> SprinklrChatOpener(getSprinklrUserId(), config, store, foregroundActivityObserver)
+                is ZendeskConfig -> ZendeskChatOpener(getZendeskUserId(), config, foregroundActivityObserver)
+            }
+        }
+
+        opener.open(feedbackDataBuilder)
+    }
+
+    private fun getZendeskUserId(): String {
+        if (preferencesStorage.zendeskFirstLaunchTime == null) {
+            preferencesStorage.zendeskFirstLaunchTime = System.currentTimeMillis()
+        }
+
+        return getChatUserId(preferencesStorage.zendeskFirstLaunchTime!!)
+    }
+
+    private fun getSprinklrUserId(): String {
+        if (preferencesStorage.sprinklrFirstLaunchTime == null) {
+            preferencesStorage.sprinklrFirstLaunchTime = System.currentTimeMillis()
+        }
+
+        return getChatUserId(preferencesStorage.sprinklrFirstLaunchTime!!)
+    }
+
+    private fun getChatUserId(firstLaunchTimeMillis: Long): String {
+        return "${firstLaunchTimeMillis}${Build.MODEL}".hashCode().toString()
+    }
+}
--- a/app/src/main/java/com/tangem/tap/common/chat/opener/ChatOpener.kt
+++ b/app/src/main/java/com/tangem/tap/common/chat/opener/ChatOpener.kt
@ -0,0 +1,7 @@
+package com.tangem.tap.common.chat.opener
+
+import android.content.Context
+
+internal interface ChatOpener {
+    fun open(feedbackDataBuilder: (Context) -> String)
+}
--- a/app/src/main/java/com/tangem/tap/common/chat/opener/implementation/SprinklrChatOpener.kt
+++ b/app/src/main/java/com/tangem/tap/common/chat/opener/implementation/SprinklrChatOpener.kt
@ -0,0 +1,27 @@
+package com.tangem.tap.common.chat.opener.implementation
+
+import android.content.Context
+import android.content.Intent
+import com.tangem.tap.ForegroundActivityObserver
+import com.tangem.tap.common.chat.opener.ChatOpener
+import com.tangem.datasource.config.models.SprinklrConfig
+import com.tangem.tap.common.redux.AppState
+import com.tangem.tap.features.sprinklr.redux.SprinklrAction
+import com.tangem.tap.features.sprinklr.ui.SprinklrActivity
+import com.tangem.tap.withForegroundActivity
+import org.rekotlin.Store
+
+internal class SprinklrChatOpener(
+    private val userId: String,
+    private val config: SprinklrConfig,
+    private val store: Store<AppState>,
+    private val foregroundActivityObserver: ForegroundActivityObserver,
+) : ChatOpener {
+    override fun open(feedbackDataBuilder: (Context) -> String) {
+        store.dispatch(SprinklrAction.Init(userId, config))
+        foregroundActivityObserver.withForegroundActivity { activity ->
+            val intent = Intent(activity, SprinklrActivity::class.java)
+            activity.startActivity(intent)
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/common/chat/opener/implementation/ZendeskChatOpener.kt
+++ b/app/src/main/java/com/tangem/tap/common/chat/opener/implementation/ZendeskChatOpener.kt
@ -0,0 +1,72 @@
+package com.tangem.tap.common.chat.opener.implementation
+
+import android.content.Context
+import com.tangem.core.analytics.Analytics
+import com.tangem.domain.common.LogConfig
+import com.tangem.tap.ForegroundActivityObserver
+import com.tangem.tap.common.chat.opener.ChatOpener
+import com.tangem.datasource.config.models.ZendeskConfig
+import com.tangem.tap.withForegroundActivity
+import com.tangem.wallet.R
+import com.zendesk.logger.Logger
+import zendesk.chat.Chat
+import zendesk.chat.ChatConfiguration
+import zendesk.chat.ChatEngine
+import zendesk.chat.ChatProvidersConfiguration
+import zendesk.chat.VisitorInfo
+import zendesk.configurations.Configuration
+import zendesk.messaging.MessagingActivity
+
+internal class ZendeskChatOpener(
+    private val userId: String,
+    private val config: ZendeskConfig,
+    private val foregroundActivityObserver: ForegroundActivityObserver,
+) : ChatOpener {
+    private var isInitialized = false
+
+    override fun open(feedbackDataBuilder: (Context) -> String) {
+        foregroundActivityObserver.withForegroundActivity { activity ->
+            initZendeskIfNeeded(activity.applicationContext)
+            setChatVisitorInfo()
+            setChatVisitorNote(feedbackDataBuilder(activity))
+            showMessagingActivity(activity)
+        }
+    }
+
+    private fun initZendeskIfNeeded(context: Context) {
+        if (isInitialized) return
+        isInitialized = true
+
+        Chat.INSTANCE.init(context, config.accountKey, config.appId)
+        Logger.setLoggable(LogConfig.zendesk)
+    }
+
+    private fun setChatVisitorInfo() {
+        val visitorInfo = VisitorInfo.builder().withName("User $userId").build()
+
+        Chat.INSTANCE.chatProvidersConfiguration =
+            ChatProvidersConfiguration.builder().withVisitorInfo(visitorInfo).build()
+    }
+
+    private fun setChatVisitorNote(note: String) {
+        Chat.INSTANCE.providers()?.profileProvider()?.setVisitorNote(note)
+    }
+
+    private fun showMessagingActivity(context: Context) {
+        Analytics.send(com.tangem.tap.common.analytics.events.Chat.ScreenOpened())
+        MessagingActivity.builder()
+            .withMultilineResponseOptionsEnabled(false)
+            .withBotLabelStringRes(R.string.chat_bot_name)
+            .withBotAvatarDrawable(R.mipmap.ic_launcher)
+            .withEngines(ChatEngine.engine())
+            .show(context, buildChatConfig())
+    }
+
+    private fun buildChatConfig(): Configuration {
+        return ChatConfiguration.builder()
+            .withOfflineFormEnabled(true)
+            .withAgentAvailabilityEnabled(true)
+            .withPreChatFormEnabled(false)
+            .build()
+    }
+}
--- a/app/src/main/java/com/tangem/tap/common/extensions/Analytics.kt
+++ b/app/src/main/java/com/tangem/tap/common/extensions/Analytics.kt
@ -0,0 +1,43 @@
+package com.tangem.tap.common.extensions
+
+import com.tangem.core.analytics.Analytics
+import com.tangem.domain.common.ScanResponse
+import com.tangem.tap.common.analytics.paramsInterceptor.LinkedCardContextInterceptor
+
+/**
+[REDACTED_AUTHOR]
+ */
+
+/**
+ * Sets the new context
+ */
+fun Analytics.setContext(scanResponse: ScanResponse) {
+    addParamsInterceptor(LinkedCardContextInterceptor(scanResponse))
+}
+
+/**
+ * Erases the context
+ */
+fun Analytics.eraseContext() {
+    removeParamsInterceptor(LinkedCardContextInterceptor.id())
+}
+
+/**
+ * Adds a new context and keeps a previous context as the parent of the new one
+ */
+fun Analytics.addContext(scanResponse: ScanResponse) {
+    val currentContext = removeParamsInterceptor(LinkedCardContextInterceptor.id()) as? LinkedCardContextInterceptor
+    val newContext = LinkedCardContextInterceptor(scanResponse, parent = currentContext)
+
+    addParamsInterceptor(newContext)
+}
+
+/**
+ * Removes the current context and restores the previous one if it was present.
+ */
+fun Analytics.removeContext() {
+    val currentContext = removeParamsInterceptor(LinkedCardContextInterceptor.id()) as? LinkedCardContextInterceptor
+    val previousContext = currentContext?.parent ?: return
+
+    addParamsInterceptor(previousContext)
+}
--- a/app/src/main/java/com/tangem/tap/common/extensions/ImageRequest.kt
+++ b/app/src/main/java/com/tangem/tap/common/extensions/ImageRequest.kt
@ -0,0 +1,32 @@
+package com.tangem.tap.common.extensions
+
+import android.widget.ImageView
+import coil.ImageLoader
+import coil.imageLoader
+import coil.load
+import coil.request.Disposable
+import coil.request.ImageRequest
+import com.tangem.tap.features.wallet.redux.Artwork
+import com.tangem.wallet.R
+
+/**
+[REDACTED_AUTHOR]
+ */
+fun ImageRequest.Builder.cardImageData(any: Any?): ImageRequest.Builder = apply {
+    data(any?.parseData())
+}
+
+fun ImageView.loadCardImage(
+    data: Any?,
+    imageLoader: ImageLoader = context.imageLoader,
+    builder: ImageRequest.Builder.() -> Unit = {},
+): Disposable = this.load(
+    data = data?.parseData(),
+    imageLoader = imageLoader,
+    builder = builder,
+)
+
+private fun Any?.parseData(): Any? = when {
+    this is String && this == Artwork.SALT_PAY_URL -> R.drawable.img_salt_pay_visa
+    else -> this
+}
--- a/app/src/main/java/com/tangem/tap/common/extensions/WalletManager.kt
+++ b/app/src/main/java/com/tangem/tap/common/extensions/WalletManager.kt
@ -2,6 +2,9 @@ package com.tangem.tap.common.extensions

 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.BlockchainSdkError
+import com.tangem.blockchain.common.Token
+import com.tangem.blockchain.common.TransactionData
+import com.tangem.blockchain.common.TransactionHistoryProvider
 import com.tangem.blockchain.common.Wallet
 import com.tangem.blockchain.common.WalletManager
 import com.tangem.common.services.Result
@ -10,6 +13,7 @@ import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.extensions.amountToCreateAccount
 import com.tangem.tap.domain.getFirstToken
 import com.tangem.tap.features.demo.isDemoCard
+import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.AddressData
 import com.tangem.tap.features.wallet.redux.reducers.createAddressesData
 import com.tangem.tap.network.NetworkConnectivity
@ -31,6 +35,9 @@ suspend fun WalletManager.safeUpdate(): Result<Wallet> = try {
        Result.Success(wallet)
    } else {
        update()
+        if (wallet.blockchain == Blockchain.SaltPay && this is TransactionHistoryProvider) {
+            this.getTransactionHistory(wallet.address, wallet.blockchain, wallet.getTokens())
+        }
        Result.Success(wallet)
    }
 } catch (exception: Exception) {
@ -76,10 +83,33 @@ fun WalletManager?.getAddressData(): AddressData? {
    return if (addressDataList.isEmpty()) null else addressDataList[0]
 }

+fun WalletManager.getTxHistory(currency: Currency): List<TransactionData> = wallet.getTxHistory(currency)
+
+fun WalletManager.getBlockchainTxHistory(): List<TransactionData> = wallet.getBlockchainTxHistory()
+
+fun WalletManager.getTokenTxHistory(token: Token): List<TransactionData> = wallet.getTokenTxHistory(token)
+
 fun <T> WalletManager.Companion.stub(): T {
    val wallet = Wallet(Blockchain.Unknown, setOf(), Wallet.PublicKey(byteArrayOf(), null, null), setOf())
    return object : WalletManager(wallet) {
        override val currentHost: String = ""
        override suspend fun update() {}
    } as T
+}
+
+fun Wallet.getTxHistory(currency: Currency): List<TransactionData> {
+    return (currency as? Currency.Token)?.let { this.getTokenTxHistory(it.token) }
+        ?: getBlockchainTxHistory()
+}
+
+fun Wallet.getBlockchainTxHistory(): List<TransactionData> {
+    return historyTransactions.filter {
+        it.contractAddress.isNullOrEmpty()
+    }
+}
+
+fun Wallet.getTokenTxHistory(token: Token): List<TransactionData> {
+    return historyTransactions.filter {
+        it.contractAddress == token.contractAddress
+    }
 }
--- a/app/src/main/java/com/tangem/tap/common/feedback/FeedbackManager.kt
+++ b/app/src/main/java/com/tangem/tap/common/feedback/FeedbackManager.kt
@ -1,24 +1,14 @@
 package com.tangem.tap.common.feedback

 import android.content.Context
-import android.os.Build
-import com.tangem.core.analytics.Analytics
 import com.tangem.domain.common.TapWorkarounds
+import com.tangem.tap.common.chat.ChatManager
+import com.tangem.datasource.config.models.ChatConfig
 import com.tangem.tap.common.extensions.sendEmail
 import com.tangem.tap.common.log.TangemLogCollector
-import com.tangem.datasource.config.models.ZendeskConfig
 import com.tangem.tap.foregroundActivityObserver
-import com.tangem.tap.persistence.PreferencesStorage
 import com.tangem.tap.withForegroundActivity
-import com.tangem.wallet.R
 import timber.log.Timber
-import zendesk.chat.Chat
-import zendesk.chat.ChatConfiguration
-import zendesk.chat.ChatEngine
-import zendesk.chat.ChatProvidersConfiguration
-import zendesk.chat.VisitorInfo
-import zendesk.configurations.Configuration
-import zendesk.messaging.MessagingActivity
 import java.io.File
 import java.io.FileWriter
 import java.io.StringWriter
@ -29,19 +19,8 @@ import java.io.StringWriter
 class FeedbackManager(
    val infoHolder: AdditionalFeedbackInfo,
    private val logCollector: TangemLogCollector,
-    private val preferencesStorage: PreferencesStorage,
+    private val chatManager: ChatManager,
 ) {
-    private var lastUsedConfigForInitialization: ZendeskConfig? = null
-
-    var chatInitializer: ((ZendeskConfig) -> Unit)? = null
-
-    fun initChat(zendeskConfig: ZendeskConfig) {
-        // prevent double initialization with the same config
-        if (lastUsedConfigForInitialization == zendeskConfig) return
-
-        lastUsedConfigForInitialization = zendeskConfig
-        chatInitializer?.invoke(zendeskConfig)
-    }

    fun sendEmail(feedbackData: FeedbackData, onFail: ((Exception) -> Unit)? = null) {
        feedbackData.prepare(infoHolder)
@ -57,12 +36,12 @@ class FeedbackManager(
        }
    }

-    fun openChat(feedbackData: FeedbackData) {
-        feedbackData.prepare(infoHolder)
-        foregroundActivityObserver.withForegroundActivity { activity ->
-            setChatVisitorInfo()
-            setChatVisitorNote(activity, feedbackData)
-            showMessagingActivity(activity)
+    fun openChat(config: ChatConfig, feedbackData: FeedbackData) {
+        chatManager.open(config) { context ->
+            feedbackData.run {
+                prepare(infoHolder)
+                joinTogether(context, infoHolder)
+            }
        }
    }

@ -85,47 +64,6 @@ class FeedbackManager(
        }
    }

-    private fun setChatVisitorInfo() {
-        if (preferencesStorage.chatFirstLaunchTime == null) {
-            preferencesStorage.chatFirstLaunchTime = System.currentTimeMillis()
-        }
-        val chatUserId = (preferencesStorage.chatFirstLaunchTime.toString() + Build.MODEL).hashCode()
-        val visitorInfo = VisitorInfo.builder()
-            .withName("User $chatUserId")
-            .build()
-
-        Chat.INSTANCE.chatProvidersConfiguration = ChatProvidersConfiguration.builder()
-            .withVisitorInfo(visitorInfo)
-            .build()
-    }
-
-    private fun setChatVisitorNote(
-        context: Context,
-        feedbackData: FeedbackData,
-    ) {
-        Chat.INSTANCE.providers()
-            ?.profileProvider()
-            ?.setVisitorNote(feedbackData.joinTogether(context, infoHolder))
-    }
-
-    private fun showMessagingActivity(context: Context) {
-        Analytics.send(com.tangem.tap.common.analytics.events.Chat.ScreenOpened())
-        MessagingActivity.builder()
-            .withMultilineResponseOptionsEnabled(false)
-            .withBotLabelStringRes(R.string.chat_bot_name)
-            .withBotAvatarDrawable(R.mipmap.ic_launcher)
-            .withEngines(ChatEngine.engine())
-            .show(context, buildChatConfig())
-    }
-
-    private fun buildChatConfig(): Configuration {
-        return ChatConfiguration.builder()
-            .withOfflineFormEnabled(true)
-            .withAgentAvailabilityEnabled(true)
-            .withPreChatFormEnabled(false)
-            .build()
-    }
-
    private fun getSupportEmail(): String {
        return if (TapWorkarounds.isStart2CoinIssuer(infoHolder.cardIssuer)) {
            S2C_SUPPORT_EMAIL
--- a/app/src/main/java/com/tangem/tap/common/redux/AppReducer.kt
+++ b/app/src/main/java/com/tangem/tap/common/redux/AppReducer.kt
@ -13,11 +13,12 @@ import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWallet
 import com.tangem.tap.features.saveWallet.redux.SaveWalletReducer
 import com.tangem.tap.features.send.redux.reducers.SendScreenReducer
 import com.tangem.tap.features.shop.redux.ShopReducer
+import com.tangem.tap.features.sprinklr.redux.SprinklrReducer
 import com.tangem.tap.features.tokens.redux.TokensReducer
 import com.tangem.tap.features.wallet.redux.reducers.WalletReducer
-import com.tangem.tap.proxy.AppStateHolder
 import com.tangem.tap.features.walletSelector.redux.WalletSelectorReducer
 import com.tangem.tap.features.welcome.redux.WelcomeReducer
+import com.tangem.tap.proxy.AppStateHolder
 import org.rekotlin.Action

 fun appReducer(action: Action, state: AppState?, appStateHolder: AppStateHolder): AppState {
@ -42,6 +43,7 @@ fun appReducer(action: Action, state: AppState?, appStateHolder: AppStateHolder)
        welcomeState = WelcomeReducer.reduce(action, state),
        saveWalletState = SaveWalletReducer.reduce(action, state),
        walletSelectorState = WalletSelectorReducer.reduce(action, state),
+        sprinklrState = SprinklrReducer.reduce(action, state),
    )
 }

--- a/app/src/main/java/com/tangem/tap/common/redux/AppState.kt
+++ b/app/src/main/java/com/tangem/tap/common/redux/AppState.kt
@ -31,6 +31,8 @@ import com.tangem.tap.features.send.redux.middlewares.SendMiddleware
 import com.tangem.tap.features.send.redux.states.SendState
 import com.tangem.tap.features.shop.redux.ShopMiddleware
 import com.tangem.tap.features.shop.redux.ShopState
+import com.tangem.tap.features.sprinklr.redux.SprinklrMiddleware
+import com.tangem.tap.features.sprinklr.redux.SprinklrState
 import com.tangem.tap.features.tokens.redux.TokensMiddleware
 import com.tangem.tap.features.tokens.redux.TokensState
 import com.tangem.tap.features.wallet.redux.WalletState
@ -61,6 +63,7 @@ data class AppState(
    val welcomeState: WelcomeState = WelcomeState(),
    val saveWalletState: SaveWalletState = SaveWalletState(),
    val walletSelectorState: WalletSelectorState = WalletSelectorState(),
+    val sprinklrState: SprinklrState = SprinklrState(),
 ) : StateType {

    val domainState: DomainState
@ -101,6 +104,7 @@ data class AppState(
                WalletSelectorMiddleware().middleware,
                LockUserWalletsTimerMiddleware().middleware,
                AccessCodeRequestPolicyMiddleware().middleware,
+                SprinklrMiddleware().middleware,
            )
        }
    }
--- a/app/src/main/java/com/tangem/tap/common/redux/global/GlobalAction.kt
+++ b/app/src/main/java/com/tangem/tap/common/redux/global/GlobalAction.kt
@ -4,6 +4,8 @@ import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.WalletManager
 import com.tangem.common.CompletionResult
 import com.tangem.common.core.TangemError
+import com.tangem.datasource.config.ConfigManager
+import com.tangem.datasource.config.models.ChatConfig
 import com.tangem.domain.common.ScanResponse
 import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.common.feedback.FeedbackData
@ -13,9 +15,7 @@ import com.tangem.tap.common.redux.ErrorAction
 import com.tangem.tap.common.redux.NotificationAction
 import com.tangem.tap.common.redux.StateDialog
 import com.tangem.tap.common.redux.ToastNotificationAction
-import com.tangem.datasource.config.models.ZendeskConfig
 import com.tangem.tap.domain.TapError
-import com.tangem.datasource.config.ConfigManager
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessage
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessagesManager
 import com.tangem.tap.features.details.redux.SecurityOption
@ -36,18 +36,20 @@ sealed class GlobalAction : Action {
    sealed class Onboarding : GlobalAction() {
        /**
         * Initiate an onboarding process.
-         * For SaltPay cards it's additionally checks for unfinished backup.
-         * For resuming unfinished backup for standard Wallet cards see CheckForUnfinishedBackup and
-         * StartForUnfinishedBackup
+         * For resuming unfinished backup of standard Wallet and SaltPay cards see
+         * BackupAction.CheckForUnfinishedBackup, GlobalAction.Onboarding.StartForUnfinishedBackup
         */
        data class Start(val scanResponse: ScanResponse, val canSkipBackup: Boolean = true) : Onboarding()

        /**
-         * Initiate resuming of unfinished backup only for standard Wallet cards.
-         * For SaltPay cards unfinished backup resumed after scanning the card on HomeScreen through Onboarding.Start.
-         * See more Onboarding.Start, CheckForUnfinishedBackup
+         * Initiate resuming of unfinished backup for standard Wallet and SaltPay cards.
+         * See more BackupAction.CheckForUnfinishedBackup
         */
-        data class StartForUnfinishedBackup(val addedBackupCardsCount: Int) : Onboarding()
+        data class StartForUnfinishedBackup(
+            val addedBackupCardsCount: Int,
+            val isSaltPayVisa: Boolean,
+        ) : Onboarding()
+
        object Stop : Onboarding()
    }

@ -87,7 +89,7 @@ sealed class GlobalAction : Action {
    data class SetFeedbackManager(val feedbackManager: FeedbackManager) : GlobalAction()

    data class SendEmail(val feedbackData: FeedbackData) : GlobalAction()
-    data class OpenChat(val feedbackData: FeedbackData, val zendeskConfig: ZendeskConfig? = null) : GlobalAction()
+    data class OpenChat(val feedbackData: FeedbackData, val chatConfig: ChatConfig? = null) : GlobalAction()
    data class UpdateFeedbackInfo(val walletManagers: List<WalletManager>) : GlobalAction()

    object ExchangeManager : GlobalAction() {
--- a/app/src/main/java/com/tangem/tap/common/redux/global/GlobalMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/common/redux/global/GlobalMiddleware.kt
@ -3,8 +3,11 @@ package com.tangem.tap.common.redux.global
 import com.tangem.common.CompletionResult
 import com.tangem.common.core.TangemSdkError
 import com.tangem.common.extensions.guard
-import com.tangem.common.extensions.ifNotNull
+import com.tangem.datasource.config.models.Config
+import com.tangem.domain.common.CardDTO
 import com.tangem.domain.common.LogConfig
+import com.tangem.domain.common.ProductType
+import com.tangem.domain.common.ScanResponse
 import com.tangem.domain.common.extensions.withMainContext
 import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
 import com.tangem.tap.common.extensions.dispatchDialogShow
@ -14,16 +17,22 @@ import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessagesManager
 import com.tangem.tap.features.send.redux.SendAction
 import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.network.exchangeServices.BuyExchangeService
 import com.tangem.tap.network.exchangeServices.CardExchangeRules
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
-import com.tangem.tap.network.exchangeServices.mercuryo.MercuryoApi
+import com.tangem.tap.network.exchangeServices.ExchangeService
+import com.tangem.tap.network.exchangeServices.mercuryo.MercuryoEnvironment
 import com.tangem.tap.network.exchangeServices.mercuryo.MercuryoService
 import com.tangem.tap.network.exchangeServices.moonpay.MoonPayService
+import com.tangem.tap.network.exchangeServices.utorg.UtorgAuthProvider
+import com.tangem.tap.network.exchangeServices.utorg.UtorgEnvironment
+import com.tangem.tap.network.exchangeServices.utorg.UtorgExchangeService
 import com.tangem.tap.preferencesStorage
 import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.tap.tangemSdkManager
 import com.tangem.tap.userTokensRepository
+import com.tangem.wallet.BuildConfig
 import kotlinx.coroutines.launch
 import org.rekotlin.Action
 import org.rekotlin.DispatchFunction
@ -98,17 +107,16 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
            val scanResponse = globalState.scanResponse ?: globalState.onboardingState.onboardingManager?.scanResponse

            // if config not set -> try to get it based on a scanResponse.productType
-            val unsafeZendeskConfig = action.zendeskConfig ?: when {
-                scanResponse?.cardTypesResolver?.isSaltPay() == true -> config.saltPayConfig?.zendesk
+            val unsafeChatConfig = action.chatConfig ?: when {
+                scanResponse?.cardTypesResolver?.isSaltPay() == true -> config.saltPayConfig?.sprinklr
                else -> config.zendesk
            }

-            val zendeskConfig = unsafeZendeskConfig.guard {
+            val chatConfig = unsafeChatConfig.guard {
                store.dispatchDebugErrorNotification("ZendeskConfig not initialized")
                return
            }
-            feedbackManager.initChat(zendeskConfig)
-            feedbackManager.openChat(action.feedbackData)
+            feedbackManager.openChat(chatConfig, action.feedbackData)
        }
        is GlobalAction.UpdateWalletSignedHashes -> {
            store.dispatch(WalletAction.Warnings.CheckRemainingSignatures(action.remainingSignatures))
@ -119,38 +127,23 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
        }
        is GlobalAction.ExchangeManager.Init -> {
            val appStateSafe = appState() ?: return
-            val config = appStateSafe.globalState.configManager?.config
-            ifNotNull(
-                config?.mercuryoWidgetId,
-                config?.mercuryoSecret,
-                config?.moonPayApiKey,
-                config?.moonPayApiSecretKey,
-            ) { mercuryoWidgetId, mercuryoSecret, moonPayKey, moonPaySecretKey ->
-                scope.launch {
-                    val buyService = MercuryoService(
-                        apiVersion = MercuryoApi.API_VERSION,
-                        mercuryoWidgetId = mercuryoWidgetId,
-                        secret = mercuryoSecret,
-                        logEnabled = LogConfig.network.mercuryoService,
-                    )
-                    val sellService = MoonPayService(
-                        apiKey = moonPayKey,
-                        secretKey = moonPaySecretKey,
-                        logEnabled = LogConfig.network.moonPayService,
-                    )
-                    val cardProvider = {
-                        store.state.globalState.scanResponse?.card
-                            ?: store.state.globalState.onboardingState.onboardingManager?.scanResponse?.card
-                    }
+            val config = appStateSafe.globalState.configManager?.config ?: return

-                    val exchangeManager = CurrencyExchangeManager(
-                        buyService = buyService,
-                        sellService = sellService,
-                        primaryRules = CardExchangeRules(cardProvider),
-                    )
-                    store.dispatchOnMain(GlobalAction.ExchangeManager.Init.Success(exchangeManager))
-                    store.dispatchOnMain(GlobalAction.ExchangeManager.Update)
+            scope.launch {
+                val scanResponseProvider: () -> ScanResponse? = {
+                    store.state.globalState.scanResponse
+                        ?: store.state.globalState.onboardingState.onboardingManager?.scanResponse
                }
+                val productTypeProvider: () -> ProductType? = { scanResponseProvider.invoke()?.productType }
+                val cardProvider: () -> CardDTO? = { scanResponseProvider.invoke()?.card }
+
+                val exchangeManager = CurrencyExchangeManager(
+                    buyService = makeBuyExchangeService(config, productTypeProvider),
+                    sellService = makeSellExchangeService(config),
+                    primaryRules = CardExchangeRules(cardProvider),
+                )
+                store.dispatchOnMain(GlobalAction.ExchangeManager.Init.Success(exchangeManager))
+                store.dispatchOnMain(GlobalAction.ExchangeManager.Update)
            }
        }
        is GlobalAction.ExchangeManager.Init.Success -> {}
@ -202,4 +195,38 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
            }
        }
    }
+}
+
+private fun makeSellExchangeService(config: Config): ExchangeService {
+    return MoonPayService(
+        apiKey = config.moonPayApiKey,
+        secretKey = config.moonPayApiSecretKey,
+        logEnabled = LogConfig.network.moonPayService,
+    )
+}
+
+private fun makeBuyExchangeService(config: Config, productTypeProvider: () -> ProductType?): ExchangeService {
+    return BuyExchangeService(
+        productTypeProvider = productTypeProvider,
+        mercuryoService = makeMercuryoExchangeService(config),
+        utorgService = makeUtorgExchangeService(config),
+    )
+}
+
+private fun makeMercuryoExchangeService(config: Config): MercuryoService {
+    val mercuryoEnvironment = MercuryoEnvironment.prod(config.mercuryoWidgetId, config.mercuryoSecret)
+    return MercuryoService(mercuryoEnvironment)
+}
+
+private fun makeUtorgExchangeService(config: Config): UtorgExchangeService {
+    val saltPayConfig = requireNotNull(config.saltPayConfig)
+
+    val utorgAuthProvider = UtorgAuthProvider(saltPayConfig.kycProvider.sidValue)
+    val utorgEnvironment = if (BuildConfig.DEBUG) {
+        UtorgEnvironment.stage(utorgAuthProvider, LogConfig.network.utorgService)
+        // UtorgEnvironment.mock()
+    } else {
+        UtorgEnvironment.prod(utorgAuthProvider)
+    }
+    return UtorgExchangeService(utorgEnvironment)
 }