Updated on 2026-08-14

2025-12-30 10:56:55 +03:00 · 2025-12-30 10:56:55 +03:00 · cc3401a412
commit cc3401a412
parent 0d683cbd45 8d813113bd
943 changed files with 15667 additions and 6451 deletions
--- a/app/src/androidTest/kotlin/com/tangem/common/ApplicationInjectionExecutionRule.kt
+++ b/app/src/androidTest/kotlin/com/tangem/common/ApplicationInjectionExecutionRule.kt
@ -7,23 +7,91 @@ import dagger.hilt.android.testing.OnComponentReadyRunner
 import org.junit.rules.TestRule
 import org.junit.runner.Description
 import org.junit.runners.model.Statement
+import timber.log.Timber

-class ApplicationInjectionExecutionRule : TestRule {
+class ApplicationInjectionExecutionRule(
+    private val toggleStates: Map<String, Boolean>
+) : TestRule {

    private val tangemApplication: TangemApplication
        get() = ApplicationProvider.getApplicationContext()

+    private var originalFeatureTogglesValues: Map<String, String>? = null
+
    override fun apply(base: Statement, description: Description): Statement {
        return object : Statement() {
            override fun evaluate() {
+                saveOriginalFeatureToggles()
+                overrideFeatureToggles()
+
                OnComponentReadyRunner.addListener(
                    tangemApplication, ApplicationEntryPoint::class.java
                ) { _: ApplicationEntryPoint ->
                    tangemApplication.preInit()
                    tangemApplication.init()
                }
-                base.evaluate()
+
+                try {
+                    base.evaluate()
+                } finally {
+                    restoreOriginalFeatureToggles()
+                }
            }
        }
    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun saveOriginalFeatureToggles() {
+        try {
+            val featureTogglesClass = Class.forName("com.tangem.core.configtoggle.FeatureToggles")
+            val valuesField = featureTogglesClass.getDeclaredField("values")
+            valuesField.isAccessible = true
+            originalFeatureTogglesValues = valuesField.get(null) as Map<String, String>
+        } catch (e: Exception) {
+            Timber.e("Failed to save original toggles values: ${e.message}")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun overrideFeatureToggles() {
+        try {
+            val featureTogglesClass = Class.forName("com.tangem.core.configtoggle.FeatureToggles")
+            val valuesField = featureTogglesClass.getDeclaredField("values")
+            valuesField.isAccessible = true
+
+            val originalValues = originalFeatureTogglesValues ?:
+            (valuesField.get(null) as Map<String, String>)
+
+            val newValues = originalValues.toMutableMap()
+
+            toggleStates.forEach { (toggle, enabled) ->
+                if (enabled) {
+                    newValues[toggle] = "1.0.0"
+                } else {
+                    newValues.remove(toggle)
+                }
+            }
+
+            valuesField.set(null, newValues)
+
+            Timber.i("FeatureToggles.values updated: $toggleStates")
+
+        } catch (e: Exception) {
+            Timber.e("FeatureToggles.values didn't change with error: ${e.message}")
+        }
+    }
+
+    private fun restoreOriginalFeatureToggles() {
+        try {
+            if (originalFeatureTogglesValues != null) {
+                val featureTogglesClass = Class.forName("com.tangem.core.configtoggle.FeatureToggles")
+                val valuesField = featureTogglesClass.getDeclaredField("values")
+                valuesField.isAccessible = true
+                valuesField.set(null, originalFeatureTogglesValues)
+                Timber.i("FeatureToggles.values restored")
+            }
+        } catch (e: Exception) {
+            Timber.e("FeatureToggles.values didn't restored with error: ${e.message}")
+        }
+    }
 }
--- a/app/src/androidTest/kotlin/com/tangem/common/BaseTestCase.kt
+++ b/app/src/androidTest/kotlin/com/tangem/common/BaseTestCase.kt
@ -16,8 +16,6 @@ import com.tangem.common.allure.FailedStepScreenshotInterceptor
 import com.tangem.common.constants.TestConstants.ALLURE_LABEL_NAME
 import com.tangem.common.constants.TestConstants.ALLURE_LABEL_VALUE
 import com.tangem.common.rules.ApiEnvironmentRule
-import com.tangem.core.configtoggle.feature.FeatureTogglesManager
-import com.tangem.core.configtoggle.feature.MutableFeatureTogglesManager
 import com.tangem.datasource.api.common.config.managers.ApiConfigsManager
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.datasource.local.preferences.PreferencesKeys
@ -53,9 +51,6 @@ abstract class BaseTestCase : TestCase(
    @Inject
    lateinit var appPreferencesStore: AppPreferencesStore

-    @Inject
-    lateinit var featureTogglesManager: FeatureTogglesManager
-
    @Inject
    lateinit var promoRepository: PromoRepository

@ -75,7 +70,7 @@ abstract class BaseTestCase : TestCase(
    @JvmField
    val ruleChain: TestRule = RuleChain
        .outerRule(hiltRule)
-        .around(ApplicationInjectionExecutionRule())
+        .around(applicationInjectionRule())
        .around(permissionRule)
        .around(apiEnvironmentRule)
        .around(composeTestRule)
@ -110,7 +105,6 @@ abstract class BaseTestCase : TestCase(
        apiEnvironmentRule.setup(apiConfigsManager)
        ActivityScenario.launch(MainActivity::class.java)
        Intents.init()
-        setFeatureToggles()
        additionalBeforeSection()
    }.after {
        additionalAfterSection()
@ -141,14 +135,15 @@ abstract class BaseTestCase : TestCase(

    fun waitForIdle() = composeTestRule.waitForIdle()

-    private fun setFeatureToggles() {
-        runBlocking {
-            with(featureTogglesManager as MutableFeatureTogglesManager) {
-                changeToggle("NEW_TOKEN_RECEIVE_ENABLED", true)
-                changeToggle("WALLET_BALANCE_FETCHER_ENABLED", true)
-                changeToggle("SWAP_REDESIGN_ENABLED", true)
-                changeToggle("NEW_ONRAMP_MAIN_ENABLED", true)
-            }
-        }
+    private fun applicationInjectionRule(): ApplicationInjectionExecutionRule {
+        return ApplicationInjectionExecutionRule(
+            toggleStates = mapOf(
+                "NEW_TOKEN_RECEIVE_ENABLED" to true,
+                "WALLET_BALANCE_FETCHER_ENABLED" to true,
+                "SWAP_REDESIGN_ENABLED" to true,
+                "NEW_ONRAMP_MAIN_ENABLED" to true,
+                "HOT_WALLET_ENABLED" to true
+            )
+        )
    }
 }
--- a/app/src/androidTest/kotlin/com/tangem/scenarios/BaseScenarios.kt
+++ b/app/src/androidTest/kotlin/com/tangem/scenarios/BaseScenarios.kt
@ -26,8 +26,11 @@ fun BaseTestCase.scanCard(
    step("Click on 'Accept' button") {
        onDisclaimerScreen { acceptButton.clickWithAssertion() }
    }
-    step("Click on 'Scan' button") {
-        onStoriesScreen { scanButton.clickWithAssertion() }
+    step("Click on 'Get started' button") {
+        onStoriesScreen { getStartedButton.clickWithAssertion() }
+    }
+    step("Click on 'Scan card or ring' button") {
+        onCreateWalletStartScreen { scanCardOrRingButton.clickWithAssertion() }
    }
    if (alreadyActivatedDialogIsShown) {
        step("Click on 'This is my wallet' button") {
--- a/app/src/androidTest/kotlin/com/tangem/screens/CreateWalletStartPageObject.kt
+++ b/app/src/androidTest/kotlin/com/tangem/screens/CreateWalletStartPageObject.kt
@ -0,0 +1,23 @@
+package com.tangem.screens
+
+import androidx.compose.ui.test.SemanticsNodeInteractionsProvider
+import com.tangem.common.BaseTestCase
+import com.tangem.core.ui.test.BaseButtonTestTags
+import io.github.kakaocup.compose.node.element.ComposeScreen
+import io.github.kakaocup.compose.node.element.ComposeScreen.Companion.onComposeScreen
+import io.github.kakaocup.compose.node.element.KNode
+import io.github.kakaocup.kakao.common.utilities.getResourceString
+import com.tangem.features.onboarding.v2.impl.R as OnboardingImplR
+
+class CreateWalletStartPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
+    ComposeScreen<CreateWalletStartPageObject>(semanticsProvider = semanticsProvider) {
+
+    val scanCardOrRingButton: KNode = child {
+        hasTestTag(BaseButtonTestTags.TEXT)
+        hasText(getResourceString(OnboardingImplR.string.welcome_unlock_card))
+        useUnmergedTree = true
+    }
+}
+
+internal fun BaseTestCase.onCreateWalletStartScreen(function: CreateWalletStartPageObject.() -> Unit) =
+    onComposeScreen(composeTestRule, function)
--- a/app/src/androidTest/kotlin/com/tangem/screens/DetailsPageObject.kt
+++ b/app/src/androidTest/kotlin/com/tangem/screens/DetailsPageObject.kt
@ -42,6 +42,7 @@ class DetailsPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
        hasTestTag(DetailsScreenTestTags.SCREEN_ITEM)
        hasText(getResourceString(R.string.app_settings_title))
    }
+
    val contactSupportButton: KNode = child {
        hasTestTag(DetailsScreenTestTags.SCREEN_ITEM)
        hasText(getResourceString(R.string.common_contact_support))
@ -50,6 +51,11 @@ class DetailsPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
        hasTestTag(DetailsScreenTestTags.SCREEN_ITEM)
        hasText(getResourceString(R.string.disclaimer_title))
    }
+
+    val versionName: KNode = child {
+        hasTestTag(DetailsScreenTestTags.VERSION_NAME)
+        useUnmergedTree = true
+    }
 }

 internal fun BaseTestCase.onDetailsScreen(function: DetailsPageObject.() -> Unit) =
--- a/app/src/androidTest/kotlin/com/tangem/screens/SendPageObject.kt
+++ b/app/src/androidTest/kotlin/com/tangem/screens/SendPageObject.kt
@ -10,6 +10,7 @@ import io.github.kakaocup.compose.node.element.ComposeScreen.Companion.onCompose
 import io.github.kakaocup.compose.node.element.KNode
 import io.github.kakaocup.kakao.common.utilities.getResourceString
 import com.tangem.features.send.v2.impl.R as SendR
+import androidx.compose.ui.test.hasText as withText

 class SendPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
    ComposeScreen<SendPageObject>(semanticsProvider = semanticsProvider) {
@ -38,6 +39,11 @@ class SendPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
        useUnmergedTree = true
    }

+    val amountErrorText: KNode = child {
+        hasTestTag(SendScreenTestTags.AMOUNT_ERROR_TEXT)
+        useUnmergedTree = true
+    }
+
    val equivalentInputAmount: KNode = child {
        hasTestTag(SendScreenTestTags.EQUIVALENT_INPUT_AMOUNT)
        useUnmergedTree = true
@ -69,8 +75,8 @@ class SendPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
    }

    val nextButton: KNode = child {
-        hasTestTag(BaseButtonTestTags.TEXT)
-        hasText(getResourceString(SendR.string.common_next))
+        hasTestTag(BaseButtonTestTags.BUTTON)
+        hasAnyDescendant(withText(getResourceString(SendR.string.common_next)))
        useUnmergedTree = true
    }

--- a/app/src/androidTest/kotlin/com/tangem/screens/StoriesPageObject.kt
+++ b/app/src/androidTest/kotlin/com/tangem/screens/StoriesPageObject.kt
@ -2,20 +2,20 @@ package com.tangem.screens

 import androidx.compose.ui.test.SemanticsNodeInteractionsProvider
 import com.tangem.common.BaseTestCase
-import com.tangem.core.ui.test.StoriesScreenTestTags
+import com.tangem.core.ui.test.BaseButtonTestTags
+import com.tangem.features.onboarding.v2.impl.R
 import io.github.kakaocup.compose.node.element.ComposeScreen
 import io.github.kakaocup.compose.node.element.ComposeScreen.Companion.onComposeScreen
 import io.github.kakaocup.compose.node.element.KNode
+import io.github.kakaocup.kakao.common.utilities.getResourceString

 class StoriesPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
    ComposeScreen<StoriesPageObject>(semanticsProvider = semanticsProvider) {

-    val scanButton: KNode = child {
-        hasTestTag(StoriesScreenTestTags.SCAN_BUTTON)
-    }
-
-    val orderButton: KNode = child {
-        hasTestTag(StoriesScreenTestTags.ORDER_BUTTON)
+    val getStartedButton: KNode = child {
+        hasTestTag(BaseButtonTestTags.TEXT)
+        hasText(getResourceString(R.string.common_get_started))
+        useUnmergedTree = true
    }
 }

--- a/app/src/androidTest/kotlin/com/tangem/tests/DetailsTest.kt
+++ b/app/src/androidTest/kotlin/com/tangem/tests/DetailsTest.kt
@ -4,10 +4,7 @@ import com.tangem.common.BaseTestCase
 import com.tangem.common.extensions.clickWithAssertion
 import com.tangem.domain.models.scan.ProductType
 import com.tangem.scenarios.openMainScreen
-import com.tangem.screens.onDetailsScreen
-import com.tangem.screens.onReferralProgramScreen
-import com.tangem.screens.onTopBar
-import com.tangem.screens.onWalletSettingsScreen
+import com.tangem.screens.*
 import dagger.hilt.android.testing.HiltAndroidTest
 import io.qameta.allure.kotlin.AllureId
 import io.qameta.allure.kotlin.junit4.DisplayName
@ -31,9 +28,6 @@ class DetailsTest : BaseTestCase() {
                step("Assert 'Wallet connect' button is visible") {
                    walletConnectButton.assertIsDisplayed()
                }
-                step("Assert 'Scan card' button is visible") {
-                    scanCardButton.assertIsDisplayed()
-                }
                step("Assert 'Buy Tangem card' button is visible") {
                    buyTangemButton.assertIsDisplayed()
                }
@ -131,9 +125,6 @@ class DetailsTest : BaseTestCase() {
                step("Assert 'Wallet connect' button does not exist") {
                    walletConnectButton.assertIsNotDisplayed()
                }
-                step("Assert 'Scan card' button is visible") {
-                    scanCardButton.assertIsDisplayed()
-                }
                step("Assert 'Buy Tangem card' button is visible") {
                    buyTangemButton.assertIsDisplayed()
                }
--- a/app/src/androidTest/kotlin/com/tangem/tests/FeedbackTest.kt
+++ b/app/src/androidTest/kotlin/com/tangem/tests/FeedbackTest.kt
@ -139,8 +139,11 @@ class FeedbackTest : BaseTestCase() {
            step("Set scanning error") {
                MockProvider.setEmulateError(TangemSdkError.TagLost())
            }
-            step("Click on 'Scan' button") {
-                onStoriesScreen { scanButton.performClick() }
+            step("Click on 'Get started' button") {
+                onStoriesScreen { getStartedButton.clickWithAssertion() }
+            }
+            step("Click on 'Scan card or ring' button") {
+                onCreateWalletStartScreen { scanCardOrRingButton.clickWithAssertion() }
            }
            step("Force show 'Scan warning' dialog"){
                runOnUiThread {
@ -178,8 +181,11 @@ class FeedbackTest : BaseTestCase() {
            step("Click on 'Accept' button") {
                onDisclaimerScreen { acceptButton.clickWithAssertion() }
            }
-            step("Click on 'Scan' button") {
-                onStoriesScreen { scanButton.clickWithAssertion() }
+            step("Click on 'Get started' button") {
+                onStoriesScreen { getStartedButton.clickWithAssertion() }
+            }
+            step("Click on 'Scan card or ring' button") {
+                onCreateWalletStartScreen { scanCardOrRingButton.clickWithAssertion() }
            }
            step("Check 'Already used Wallet' dialog") {
                checkAlreadyUsedWalletDialog()
--- a/app/src/androidTest/kotlin/com/tangem/tests/ScanErrorTest.kt
+++ b/app/src/androidTest/kotlin/com/tangem/tests/ScanErrorTest.kt
@ -1,39 +0,0 @@
-package com.tangem.tests
-
-import com.tangem.common.BaseTestCase
-import com.tangem.common.extensions.clickWithAssertion
-import com.tangem.screens.onDisclaimerScreen
-import com.tangem.screens.onMainScreen
-import com.tangem.screens.onStoriesScreen
-import com.tangem.tap.domain.sdk.mocks.MockProvider
-import dagger.hilt.android.testing.HiltAndroidTest
-import org.junit.Test
-
-@HiltAndroidTest
-class ScanErrorTest : BaseTestCase() {
-
-    @Test
-    fun goToMainTest() =
-        setupHooks().run {
-            onDisclaimerScreen {
-                step("Click on 'Accept' button") {
-                    acceptButton.clickWithAssertion()
-                }
-            }
-            onStoriesScreen {
-                step("Click on 'Scan' button emulating scan error") {
-                    MockProvider.setEmulateError()
-                    scanButton.clickWithAssertion()
-                }
-                step("Click on 'Scan' button again without emulating error") {
-                    MockProvider.resetEmulateError()
-                    scanButton.clickWithAssertion()
-                }
-            }
-            onMainScreen {
-                step("Make sure wallet screen is visible") {
-                    assertIsDisplayed()
-                }
-            }
-        }
-}
--- a/app/src/androidTest/kotlin/com/tangem/tests/StoriesTest.kt
+++ b/app/src/androidTest/kotlin/com/tangem/tests/StoriesTest.kt
@ -1,37 +0,0 @@
-package com.tangem.tests
-
-import android.content.Intent.ACTION_VIEW
-import com.tangem.common.BaseTestCase
-import com.tangem.common.extensions.clickWithAssertion
-import com.tangem.screens.onDisclaimerScreen
-import com.tangem.screens.onStoriesScreen
-import dagger.hilt.android.testing.HiltAndroidTest
-import io.github.kakaocup.kakao.intent.KIntent
-
-@HiltAndroidTest
-class StoriesTest : BaseTestCase() {
-
-    // @Test
-    fun clickOnOrderButtonTest() =
-        setupHooks().run {
-            val buyWalletUrl = "https://buy.tangem.com/"
-            onDisclaimerScreen {
-                step("Click on 'Accept' button") {
-                    acceptButton.clickWithAssertion()
-                }
-            }
-            onStoriesScreen {
-                step("Click on 'Order' button") {
-                    orderButton.clickWithAssertion()
-                }
-                step("Assert: browser opened") {
-                    val expectedIntent = KIntent {
-                        hasAction(ACTION_VIEW)
-                        hasData { toString().startsWith(buyWalletUrl) }
-                    }
-                    expectedIntent.intended()
-                    device.uiDevice.pressBack()
-                }
-            }
-        }
-}
--- a/app/src/androidTest/kotlin/com/tangem/tests/TermsOfServiceTest.kt
+++ b/app/src/androidTest/kotlin/com/tangem/tests/TermsOfServiceTest.kt
@ -37,8 +37,7 @@ class TermsOfServiceTest : BaseTestCase() {
            }
            step("Assert 'Stories' screen is opened") {
                onStoriesScreen {
-                    scanButton.assertIsDisplayed()
-                    orderButton.assertIsDisplayed()
+                    getStartedButton.assertIsDisplayed()
                }
            }
        }
@ -91,8 +90,7 @@ class TermsOfServiceTest : BaseTestCase() {
            }
            step("Assert 'Stories' screen is opened") {
                onStoriesScreen {
-                    scanButton.assertIsDisplayed()
-                    orderButton.assertIsDisplayed()
+                    getStartedButton.assertIsDisplayed()
                }
            }
            step("Stop app") {
@ -103,8 +101,7 @@ class TermsOfServiceTest : BaseTestCase() {
            }
            step("Assert 'Stories' screen is opened") {
                onStoriesScreen {
-                    scanButton.assertIsDisplayed()
-                    orderButton.assertIsDisplayed()
+                    getStartedButton.assertIsDisplayed()
                }
            }
        }
--- a/app/src/androidTest/kotlin/com/tangem/tests/send/addressScreen/RecentBlockTest.kt
+++ b/app/src/androidTest/kotlin/com/tangem/tests/send/addressScreen/RecentBlockTest.kt
@ -276,7 +276,10 @@ class RecentBlockTest : BaseTestCase() {
            }
            step("Swipe up") {
                waitForIdle()
-                swipeVertical(SwipeDirection.UP, startHeightRatio = 0.6f)
+                onSendAddressScreen {
+                    swipeVertical(SwipeDirection.UP, startHeightRatio = 0.6f)
+                    swipeVertical(SwipeDirection.UP, startHeightRatio = 0.6f)
+                }
            }
            step("Check recent address item №7") {
                checkRecentAddressItem(address = recipientAddressBase + "f", description = recentTransactionAmount2)
--- a/app/src/androidTest/kotlin/com/tangem/tests/send/amountScreen/SendAmountScreenTest.kt
+++ b/app/src/androidTest/kotlin/com/tangem/tests/send/amountScreen/SendAmountScreenTest.kt
@ -0,0 +1,145 @@
+package com.tangem.tests.send.amountScreen
+
+import android.view.KeyEvent
+import com.tangem.common.BaseTestCase
+import com.tangem.common.utils.setClipboardText
+import com.tangem.scenarios.*
+import com.tangem.screens.*
+import com.tangem.wallet.R
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.github.kakaocup.kakao.common.utilities.getResourceString
+import io.qameta.allure.kotlin.AllureId
+import io.qameta.allure.kotlin.junit4.DisplayName
+import org.junit.Test
+
+@HiltAndroidTest
+class SendAmountScreenTest : BaseTestCase() {
+
+    @AllureId("4761")
+    @DisplayName("Send (amount screen): validate different amounts")
+    @Test
+    fun validateDifferentAmountsTest() {
+        val tokenName = "Ethereum"
+        val manualSendAmount = "1"
+        val clipboardSendAmount = "0.5"
+        val invalidAmount = "2"
+        val errorText = getResourceString(R.string.send_validation_amount_exceeds_balance)
+        val context = device.context
+
+        setupHooks().run {
+            step("Open 'Send' screen") {
+                openSendScreen(tokenName)
+            }
+            step("Type '$manualSendAmount' in input text field") {
+                onSendScreen {
+                    amountInputTextField.performClick()
+                    amountInputTextField.performTextReplacement(manualSendAmount)
+                }
+            }
+            step("Assert send amount = '$manualSendAmount'") {
+                onSendScreen { amountInputTextField.assertTextContains(manualSendAmount, substring = true) }
+            }
+            step("Assert 'Next' button is enabled") {
+                onSendScreen { nextButton.assertIsEnabled() }
+            }
+            step("Press system 'Delete' button") {
+                waitForIdle()
+                device.uiDevice.pressDelete()
+            }
+            step("Set clipboard text") {
+                setClipboardText(context, clipboardSendAmount)
+            }
+            step("Click on input text field") {
+                onSendScreen { amountInputTextField.performClick() }
+            }
+            step("Paste from clipboard") {
+                device.uiDevice.pressKeyCode(KeyEvent.KEYCODE_V, KeyEvent.META_CTRL_ON)
+            }
+            step("Assert send amount = '$clipboardSendAmount'") {
+                onSendScreen { amountInputTextField.assertTextContains(clipboardSendAmount, substring = true) }
+            }
+            step("Assert 'Next' button is enabled") {
+                onSendScreen { nextButton.assertIsEnabled() }
+            }
+            step("Press system 'Delete' button") {
+                waitForIdle()
+                device.uiDevice.pressDelete()
+            }
+            step("Type '$invalidAmount' in input text field") {
+                onSendScreen {
+                    amountInputTextField.performClick()
+                    amountInputTextField.performTextReplacement(invalidAmount)
+                }
+            }
+            step("Assert send amount = '$invalidAmount'") {
+                onSendScreen { amountInputTextField.assertTextContains(invalidAmount, substring = true) }
+            }
+            step("Assert amount error contains text '$errorText'") {
+                onSendScreen { amountErrorText.assertTextContains(errorText) }
+            }
+            step("Assert 'Next' button is disabled") {
+                onSendScreen { nextButton.assertIsNotEnabled() }
+            }
+            step("Click on 'Max' button") {
+                onSendScreen { maxButton.performClick() }
+            }
+            step("Assert send amount = '$manualSendAmount'") {
+                onSendScreen { amountInputTextField.assertTextContains(manualSendAmount, substring = true) }
+            }
+            step("Assert 'Next' button is enabled") {
+                onSendScreen { nextButton.assertIsEnabled() }
+            }
+            step("Click on 'Close' button") {
+                onSendScreen { closeButton.performClick() }
+            }
+            step("Assert 'Token Details' screen is displayed") {
+                onTokenDetailsScreen { screenContainer.assertIsDisplayed() }
+            }
+        }
+    }
+
+    @AllureId("4762")
+    @DisplayName("Send (amount screen): switch equivalent")
+    @Test
+    fun switchEquivalentTest() {
+        val tokenName = "Ethereum"
+        val tokenAmount = "1"
+        val fiatAmount = "$2,535.63"
+
+        setupHooks().run {
+            step("Open 'Send' screen") {
+                openSendScreen(tokenName)
+            }
+            step("Type '$tokenAmount' in input text field") {
+                onSendScreen {
+                    amountInputTextField.performClick()
+                    amountInputTextField.performTextReplacement(tokenAmount)
+                }
+            }
+            step("Assert send amount = '$tokenAmount'") {
+                onSendScreen { amountInputTextField.assertTextContains(tokenAmount, substring = true) }
+            }
+            step("Assert equivalent amount = '$fiatAmount'") {
+                onSendScreen { equivalentInputAmount.assertTextContains(fiatAmount, substring = true) }
+            }
+            step("Click on 'Exchange' button") {
+                onSendScreen { exchangeIcon.performClick() }
+            }
+            step("Assert send amount = '$fiatAmount'") {
+                onSendScreen { amountInputTextField.assertTextContains(fiatAmount, substring = true) }
+            }
+            step("Assert equivalent amount = '$tokenAmount'") {
+                onSendScreen { equivalentInputAmount.assertTextContains(tokenAmount, substring = true) }
+            }
+            step("Click on 'Exchange' button") {
+                onSendScreen { exchangeIcon.performClick() }
+            }
+            step("Assert send amount = '$tokenAmount'") {
+                onSendScreen { amountInputTextField.assertTextContains(tokenAmount, substring = true) }
+            }
+            step("Assert equivalent amount = '$fiatAmount'") {
+                onSendScreen { equivalentInputAmount.assertTextContains(fiatAmount, substring = true) }
+            }
+        }
+    }
+}
--- a/app/src/androidTest/kotlin/com/tangem/tests/send/warnings/SolanaWarningsTest.kt
+++ b/app/src/androidTest/kotlin/com/tangem/tests/send/warnings/SolanaWarningsTest.kt
@ -22,7 +22,7 @@ class SolanaWarningsTest : BaseTestCase() {
    private val tokenName = "Solana"
    private val amountToLeaveLessThanRent = "0.0016941"
    private val amountToLeaveGreaterThanRent = "0.0000941"
-    private val amountToLeaveRentOnly = "0.00168934"
+    private val amountToLeaveRentOnly = "0.001689338"
    private val rentAmount = "SOL 0.00089088"

    private val invalidAmountTitle = getResourceString(R.string.send_notification_invalid_amount_title)
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@ -19,7 +19,7 @@
    <uses-feature android:name="android.hardware.camera.autofocus" />
    <uses-feature
        android:name="android.hardware.nfc"
-        android:required="true" />
+        android:required="false" />

    <queries>
        <intent>
--- a/app/src/main/java/com/tangem/tap/MainActivity.kt
+++ b/app/src/main/java/com/tangem/tap/MainActivity.kt
@ -367,7 +367,7 @@ class MainActivity : AppCompatActivity(), ActivityResultCallbackHolder {

        val isFromPush = intent.extras?.containsKey(OPENED_FROM_GCM_PUSH) == true
        if (isFromPush) {
-            analyticsEventsHandler.send(Push.PushNotificationOpened)
+            analyticsEventsHandler.send(Push.PushNotificationOpened())
        }

        handleDeepLink(intent = intent, isFromOnNewIntent = true)
--- a/app/src/main/java/com/tangem/tap/TangemApplication.kt
+++ b/app/src/main/java/com/tangem/tap/TangemApplication.kt
@ -19,6 +19,7 @@ import com.tangem.common.routing.AppRouter
 import com.tangem.core.abtests.manager.ABTestsManager
 import com.tangem.core.analytics.Analytics
 import com.tangem.core.analytics.api.ParamsInterceptor
+import com.tangem.core.analytics.filter.AppsFlyerEventFilter
 import com.tangem.core.analytics.filter.OneTimeEventFilter
 import com.tangem.core.analytics.models.AnalyticsEvent
 import com.tangem.core.analytics.models.AnalyticsParam
@ -328,7 +329,7 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.

        ExceptionHandler.append(blockchainExceptionHandler)

-        if (LogConfig.network.blockchainSdkNetwork) {
+        if (LogConfig.network.isBlockchainSdkNetworkLogEnabled) {
            BlockchainSdkRetrofitBuilder.interceptors = listOf(
                createNetworkLoggingInterceptor(),
                ChuckerInterceptor(this),
@ -423,6 +424,7 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
        factory.addHandlerBuilder(AppsFlyerAnalyticsHandler.Builder())

        factory.addFilter(oneTimeEventFilter)
+        factory.addFilter(AppsFlyerEventFilter())

        val buildData = AnalyticsHandlerBuilder.Data(
            application = application,
--- a/app/src/main/java/com/tangem/tap/common/analytics/DefaultTrackingContextProxy.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/DefaultTrackingContextProxy.kt
@ -25,8 +25,6 @@ internal class DefaultTrackingContextProxy(private val abTestsManager: ABTestsMa
    override fun setContext(scanResponse: ScanResponse) {
        val userWalletId = UserWalletIdBuilder.scanResponse(scanResponse).build()

-        Analytics.setContext(userWalletId, scanResponse)
-
        abTestsManager.setUserProperties(
            userId = calculateUserIdHash(userWalletId),
            batch = scanResponse.card.batchId,
--- 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
@ -12,12 +12,6 @@ sealed class AnalyticsParam {
        class Amount(amount: com.tangem.blockchain.common.Amount) : CurrencyType(amount.currencySymbol)
    }

-    sealed class CardBalanceState(val value: String) {
-        data object Empty : CardBalanceState("Empty")
-        data object Full : CardBalanceState("Full")
-        companion object
-    }
-
    sealed class RateApp(val value: String) {
        data object Liked : RateApp("Liked")
        data object Closed : RateApp("Close")
--- 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
@ -11,85 +11,5 @@ sealed class Onboarding(
    params: Map<String, String> = emptyMap(),
 ) : AnalyticsEvent(category, event, params) {

-    class Started : Onboarding("Onboarding", "Onboarding Started")
    class Finished : Onboarding("Onboarding", "Onboarding Finished")
-
-    sealed class CreateWallet(
-        event: String,
-        params: Map<String, String> = emptyMap(),
-    ) : Onboarding("Onboarding / Create Wallet", event, params) {
-
-        class ScreenOpened : CreateWallet("Create Wallet Screen Opened")
-        class ButtonCreateWallet : CreateWallet("Button - Create Wallet")
-        class WalletCreatedSuccessfully(
-            creationType: AnalyticsParam.WalletCreationType = AnalyticsParam.WalletCreationType.PrivateKey,
-            seedPhraseLength: Int? = null,
-        ) : CreateWallet(
-            event = "Wallet Created Successfully",
-            params = buildMap {
-                put(AnalyticsParam.CREATION_TYPE, creationType.value)
-
-                if (seedPhraseLength != null) put(AnalyticsParam.SEED_PHRASE_LENGTH, seedPhraseLength.toString())
-            },
-        )
-    }
-
-    sealed class Backup(
-        event: String,
-        params: Map<String, String> = emptyMap(),
-    ) : Onboarding("Onboarding / Backup", event, params) {
-
-        class ScreenOpened : Backup("Backup Screen Opened")
-        class Started : Backup("Backup Started")
-        class Skipped : Backup("Backup Skipped")
-        class SettingAccessCodeStarted : Backup("Setting Access Code Started")
-        class AccessCodeEntered : Backup("Access Code Entered")
-        class AccessCodeReEntered : Backup("Access Code Re-entered")
-
-        class Finished(cardsCount: Int) : Backup(
-            event = "Backup Finished",
-            params = mapOf("Cards count" to "$cardsCount"),
-        )
-
-        object ResetCancelEvent : Backup(
-            event = "Reset Card Notification",
-            params = mapOf("Option" to "Cancel"),
-        )
-
-        object ResetPerformEvent : Backup(
-            event = "Reset Card Notification",
-            params = mapOf("Option" to "Reset"),
-        )
-    }
-
-    sealed class Topup(
-        event: String,
-        params: Map<String, String> = emptyMap(),
-    ) : Onboarding("Onboarding / Top Up", event, params) {
-
-        class ScreenOpened : Topup("Activation Screen Opened")
-
-        class ButtonBuyCrypto(currency: AnalyticsParam.CurrencyType) : Topup(
-            event = "Button - Buy Crypto",
-            params = mapOf(AnalyticsParam.CURRENCY to currency.value),
-        )
-
-        class ButtonShowWalletAddress : Topup("Button - Show the Wallet Address")
-    }
-
-    sealed class Twins(
-        event: String,
-        params: Map<String, String> = emptyMap(),
-    ) : Onboarding("Onboarding / Twins", event, params) {
-
-        class ScreenOpened : Twins("Twinning Screen Opened")
-        class SetupStarted : Twins("Twin Setup Started")
-        class SetupFinished : Twins("Twin Setup Finished")
-    }
-
-    class EnableBiometrics(state: AnalyticsParam.OnOffState) : Onboarding(
-        category = "Onboarding / Biometric",
-        event = "Enable Biometric",
-        params = mapOf("State" to state.value),
-    )
 }
--- a/app/src/main/java/com/tangem/tap/common/analytics/events/Push.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/events/Push.kt
@ -8,5 +8,5 @@ internal sealed class Push(event: String) : AnalyticsEvent(
    params = emptyMap(),
 ) {

-    data object PushNotificationOpened : Push(event = "Push Notification Opened")
+    class PushNotificationOpened : Push(event = "Push Notification Opened")
 }
--- a/app/src/main/java/com/tangem/tap/common/analytics/events/Settings.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/events/Settings.kt
@ -67,7 +67,7 @@ sealed class Settings(
            params = mapOf("State" to state.value),
        )

-        object ButtonEnableBiometricAuthentication : AppSettings(event = "Button - Enable Biometric Authentication")
+        class ButtonEnableBiometricAuthentication : AppSettings(event = "Button - Enable Biometric Authentication")

        class MainCurrencyChanged(currencyType: String) : AppSettings(
            event = "Main Currency Changed",
@ -79,7 +79,7 @@ sealed class Settings(
            params = mapOf("State" to theme.value),
        )

-        object EnableBiometrics : AppSettings(event = "Notice - Enable Biometric")
+        class EnableBiometrics : AppSettings(event = "Notice - Enable Biometric")

        class HideBalanceChanged(state: AnalyticsParam.OnOffState) : AppSettings(
            event = "Hide Balance Changed",
--- 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
@ -10,8 +10,6 @@ sealed class SignIn(
    params: Map<String, String> = emptyMap(),
 ) : AnalyticsEvent("Sign In", event, params) {

-    class ScreenOpened : SignIn(event = "Sign In Screen Opened")
-
    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/handlers/amplitude/AmplitudeAnalyticsHandler.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/amplitude/AmplitudeAnalyticsHandler.kt
@ -2,6 +2,7 @@ package com.tangem.tap.common.analytics.handlers.amplitude

 import com.tangem.core.analytics.api.AnalyticsHandler
 import com.tangem.core.analytics.api.AnalyticsUserIdHandler
+import com.tangem.core.analytics.models.AnalyticsEvent
 import com.tangem.tap.common.analytics.api.AnalyticsHandlerBuilder

 class AmplitudeAnalyticsHandler(
@ -9,7 +10,6 @@ class AmplitudeAnalyticsHandler(
 ) : AnalyticsHandler, AnalyticsUserIdHandler {

    override fun id(): String = ID
-
    override fun setUserId(userId: String) {
        client.setUserId(userId)
    }
@ -18,8 +18,8 @@ class AmplitudeAnalyticsHandler(
        client.clearUserId()
    }

-    override fun send(eventId: String, params: Map<String, String>) {
-        client.logEvent(eventId, params)
+    override fun send(event: AnalyticsEvent) {
+        client.logEvent(event.id, event.params)
    }

    companion object {
@ -29,7 +29,7 @@ class AmplitudeAnalyticsHandler(
    class Builder : AnalyticsHandlerBuilder {
        override fun build(data: AnalyticsHandlerBuilder.Data): AnalyticsHandler {
            return AmplitudeAnalyticsHandler(
-                client = if (data.logConfig.amplitude) {
+                client = if (data.logConfig.isAmplitudeLogEnabled) {
                    AmplitudeLogClient(data.jsonConverter)
                } else {
                    AmplitudeClient(data.application, data.config.amplitudeApiKey)
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/appsflyer/AppsFlyerAnalyticsClient.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/appsflyer/AppsFlyerAnalyticsClient.kt
@ -3,8 +3,10 @@ package com.tangem.tap.common.analytics.handlers.appsflyer
 import android.content.Context
 import com.appsflyer.AppsFlyerLib
 import com.tangem.core.analytics.api.EventLogger
+import com.tangem.core.analytics.api.UserIdHolder
+import com.tangem.tap.common.analytics.handlers.firebase.UnderscoreAnalyticsEventConverter

-interface AppsFlyerAnalyticsClient : EventLogger
+interface AppsFlyerAnalyticsClient : EventLogger, UserIdHolder

 internal class AppsFlyerClient(
    private val context: Context,
@ -13,6 +15,7 @@ internal class AppsFlyerClient(
 ) : AppsFlyerAnalyticsClient {

    private val appsFlyerLib: AppsFlyerLib = AppsFlyerLib.getInstance()
+    private val eventConverter = UnderscoreAnalyticsEventConverter()

    init {
        appsFlyerLib.init(key, null, context)
@ -20,7 +23,19 @@ internal class AppsFlyerClient(
        appsFlyerLib.start(context)
    }

+    override fun setUserId(userId: String) {
+        appsFlyerLib.setCustomerUserId(userId)
+    }
+
+    override fun clearUserId() {
+        appsFlyerLib.setCustomerUserId(null)
+    }
+
    override fun logEvent(event: String, params: Map<String, String>) {
-        appsFlyerLib.logEvent(context, event, params)
+        appsFlyerLib.logEvent(
+            context,
+            event,
+            eventConverter.convertEventParams(params),
+        )
    }
 }
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/appsflyer/AppsFlyerAnalyticsHandler.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/appsflyer/AppsFlyerAnalyticsHandler.kt
@ -1,21 +1,38 @@
 package com.tangem.tap.common.analytics.handlers.appsflyer

 import com.tangem.core.analytics.api.AnalyticsHandler
+import com.tangem.core.analytics.api.AnalyticsUserIdHandler
 import com.tangem.core.analytics.models.AnalyticsEvent
+import com.tangem.core.analytics.models.AppsFlyerIncludedEvent
+import com.tangem.core.analytics.models.AppsFlyerOnlyEvent
 import com.tangem.tap.common.analytics.api.AnalyticsHandlerBuilder

 class AppsFlyerAnalyticsHandler(
    private val client: AppsFlyerAnalyticsClient,
-) : AnalyticsHandler {
+) : AnalyticsHandler, AnalyticsUserIdHandler {

    override fun id(): String = ID

-    override fun send(eventId: String, params: Map<String, String>) {
-        client.logEvent(eventId, params)
+    override fun send(event: AnalyticsEvent) {
+        when (event) {
+            is AppsFlyerOnlyEvent -> {
+                client.logEvent(event.id, event.params)
+            }
+            is AppsFlyerIncludedEvent -> {
+                client.logEvent(
+                    event = AnalyticsEvent(category = event.category, event = event.appsFlyerReplacedEvent).id,
+                    params = event.params,
+                )
+            }
+        }
    }

-    override fun send(event: AnalyticsEvent) {
-        super.send(event)
+    override fun setUserId(userId: String) {
+        client.setUserId(userId)
+    }
+
+    override fun clearUserId() {
+        client.clearUserId()
    }

    companion object {
@ -23,12 +40,10 @@ class AppsFlyerAnalyticsHandler(
    }

    class Builder : AnalyticsHandlerBuilder {
-        override fun build(data: AnalyticsHandlerBuilder.Data): AnalyticsHandler? = null
-        // disabled for now until analytics strategy is defined
-        // when {
-        // !data.isDebug -> AppsFlyerClient(data.application, data.config.appsFlyerApiKey, data.config.appsAppId)
-        // data.isDebug && data.logConfig.appsflyer -> AppsFlyerLogClient(data.jsonConverter)
-        // else -> null
-        // }?.let { AppsFlyerAnalyticsHandler(it) }
+        override fun build(data: AnalyticsHandlerBuilder.Data): AnalyticsHandler? = when {
+            !data.isDebug -> AppsFlyerClient(data.application, data.config.appsFlyerApiKey, data.config.appsAppId)
+            data.isDebug && data.logConfig.isAppsflyerLogEnabled -> AppsFlyerLogClient(data.jsonConverter)
+            else -> null
+        }?.let { AppsFlyerAnalyticsHandler(it) }
    }
 }
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/appsflyer/AppsFlyerLogClient.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/appsflyer/AppsFlyerLogClient.kt
@ -12,4 +12,12 @@ internal class AppsFlyerLogClient(
    override fun logEvent(event: String, params: Map<String, String>) {
        logger.logEvent(event, params)
    }
+
+    override fun setUserId(userId: String) {
+        // No-op
+    }
+
+    override fun clearUserId() {
+        // No-op
+    }
 }
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/firebase/FirebaseAnalyticsHandler.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/firebase/FirebaseAnalyticsHandler.kt
@ -1,8 +1,8 @@
 package com.tangem.tap.common.analytics.handlers.firebase

 import com.tangem.core.analytics.api.AnalyticsErrorHandler
-import com.tangem.core.analytics.api.AnalyticsHandler
 import com.tangem.core.analytics.api.AnalyticsExceptionHandler
+import com.tangem.core.analytics.api.AnalyticsHandler
 import com.tangem.core.analytics.api.AnalyticsUserIdHandler
 import com.tangem.core.analytics.models.AnalyticsEvent
 import com.tangem.core.analytics.models.ExceptionAnalyticsEvent
@ -25,8 +25,8 @@ class FirebaseAnalyticsHandler(
        client.clearUserId()
    }

-    override fun send(eventId: String, params: Map<String, String>) {
-        client.logEvent(eventId, params)
+    override fun send(event: AnalyticsEvent) {
+        client.logEvent(event.id, event.params)
    }

    override fun sendException(event: ExceptionAnalyticsEvent) {
@ -49,7 +49,7 @@ class FirebaseAnalyticsHandler(
    class Builder : AnalyticsHandlerBuilder {
        override fun build(data: AnalyticsHandlerBuilder.Data): AnalyticsHandler? = when {
            !data.isDebug -> FirebaseClient()
-            data.isDebug && data.logConfig.firebase -> FirebaseLogClient(data.jsonConverter)
+            data.isDebug && data.logConfig.isFirebaseLogEnabled -> FirebaseLogClient(data.jsonConverter)
            else -> null
        }?.let { FirebaseAnalyticsHandler(it) }
    }
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/firebase/FirebaseClient.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/firebase/FirebaseClient.kt
@ -20,7 +20,7 @@ internal class FirebaseClient : FirebaseAnalyticsClient {
    private val fbAnalytics = Firebase.analytics
    private val fbCrashlytics = Firebase.crashlytics

-    private val eventConverter = FirebaseAnalyticsEventConverter()
+    private val eventConverter = UnderscoreAnalyticsEventConverter()

    override fun setUserId(userId: String) {
        Firebase.analytics.setUserId(userId)
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/firebase/UnderscoreAnalyticsEventConverter.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/firebase/UnderscoreAnalyticsEventConverter.kt
@ -1,6 +1,6 @@
 package com.tangem.tap.common.analytics.handlers.firebase

-internal class FirebaseAnalyticsEventConverter {
+internal class UnderscoreAnalyticsEventConverter {

    fun convertEventName(event: String): String {
        return convertString(event, FIREBASE_EVENT_NAME_MAX_LENGTH)
--- 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
@ -3,6 +3,7 @@ package com.tangem.tap.common.analytics.paramsInterceptor
 import com.tangem.core.analytics.api.ParamsInterceptor
 import com.tangem.core.analytics.models.AnalyticsEvent
 import com.tangem.core.analytics.models.AnalyticsParam
+import com.tangem.core.analytics.models.event.SignIn
 import com.tangem.domain.card.analytics.IntroductionProcess
 import com.tangem.domain.card.analytics.ParamCardCurrencyConverter
 import com.tangem.domain.card.common.util.cardTypesResolver
@ -30,7 +31,12 @@ class CardContextInterceptor(

    override fun canBeAppliedTo(event: AnalyticsEvent): Boolean {
        return when (event) {
-            is IntroductionProcess.ButtonScanCard -> false
+            is IntroductionProcess.ButtonScanCard,
+            is IntroductionProcess.ButtonScanCardLegacy,
+            is SignIn.ScreenOpened,
+            is SignIn.ButtonAddWallet,
+            -> false
+            is SignIn.ErrorBiometricUpdated -> !event.isFromUnlockAll
            else -> true
        }
    }
--- a/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/HotWalletContextInterceptor.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/HotWalletContextInterceptor.kt
@ -3,6 +3,8 @@ package com.tangem.tap.common.analytics.paramsInterceptor
 import com.tangem.core.analytics.api.ParamsInterceptor
 import com.tangem.core.analytics.models.AnalyticsEvent
 import com.tangem.core.analytics.models.AnalyticsParam
+import com.tangem.core.analytics.models.event.SignIn
+import com.tangem.domain.card.analytics.IntroductionProcess

 class HotWalletContextInterceptor(
    val parent: ParamsInterceptor? = null,
@ -10,10 +12,23 @@ class HotWalletContextInterceptor(

    override fun id(): String = HotWalletContextInterceptor.id()

-    override fun canBeAppliedTo(event: AnalyticsEvent): Boolean = true
+    override fun canBeAppliedTo(event: AnalyticsEvent): Boolean {
+        return when (event) {
+            is SignIn.ScreenOpened,
+            is SignIn.ButtonAddWallet,
+            is SignIn.ButtonUnlockAllWithBiometric,
+            is IntroductionProcess.ButtonScanCard,
+            -> false
+            is SignIn.ErrorBiometricUpdated -> !event.isFromUnlockAll
+            else -> true
+        }
+    }

    override fun intercept(params: MutableMap<String, String>) {
        params[AnalyticsParam.PRODUCT_TYPE] = AnalyticsParam.ProductType.MobileWallet.value
+        params.remove(AnalyticsParam.BATCH)
+        params.remove(AnalyticsParam.FIRMWARE)
+        params.remove(AnalyticsParam.CURRENCY)
    }

    companion object {
--- a/app/src/main/java/com/tangem/tap/core/security/DefaultDeviceSecurityInfoProvider.kt
+++ b/app/src/main/java/com/tangem/tap/core/security/DefaultDeviceSecurityInfoProvider.kt
@ -0,0 +1,13 @@
+package com.tangem.tap.core.security
+
+import com.dexprotector.rtc.RtcStatus
+import com.tangem.security.DeviceSecurityInfoProvider
+
+internal class DefaultDeviceSecurityInfoProvider : DeviceSecurityInfoProvider {
+    override val isRooted: Boolean
+        get() = RtcStatus.getRtcStatus().root
+    override val isBootloaderUnlocked: Boolean
+        get() = RtcStatus.getRtcStatus().unlockedBootloader
+    override val isXposed: Boolean
+        get() = RtcStatus.getRtcStatus().xposed
+}
--- a/app/src/main/java/com/tangem/tap/data/DefaultTangemPayStorage.kt
+++ b/app/src/main/java/com/tangem/tap/data/DefaultTangemPayStorage.kt
@ -6,6 +6,7 @@ import com.tangem.datasource.di.NetworkMoshi
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.datasource.local.preferences.PreferencesKeys
 import com.tangem.datasource.local.preferences.utils.getObjectMapSync
+import com.tangem.datasource.local.preferences.utils.getSyncOrDefault
 import com.tangem.datasource.local.preferences.utils.getSyncOrNull
 import com.tangem.datasource.local.preferences.utils.store
 import com.tangem.datasource.local.visa.TangemPayStorage
@ -21,6 +22,7 @@ import javax.inject.Singleton
 private const val AUTH_TOKENS_DEFAULT_KEY = "tangem_pay_default_key"
 private const val WITHDRAW_ORDER_ID_KEY = "tangem_pay_withdraw_order_id_key"

+@Suppress("TooManyFunctions")
@Singleton
 internal class DefaultTangemPayStorage @Inject constructor(
    @ApplicationContext applicationContext: Context,
@ -53,6 +55,12 @@ internal class DefaultTangemPayStorage @Inject constructor(
        }
    }

+    override suspend fun clearCustomerWalletAddress(userWalletId: UserWalletId) {
+        withContext(dispatcherProvider.io) {
+            appPreferencesStore.store(PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId), "")
+        }
+    }
+
    override suspend fun storeAuthTokens(customerWalletAddress: String, tokens: TangemPayAuthTokens) =
        withContext(dispatcherProvider.io) {
            val json = tokensAdapter.toJson(tokens)
@ -70,6 +78,10 @@ internal class DefaultTangemPayStorage @Inject constructor(
                ?.let(tokensAdapter::fromJson)
        }

+    override suspend fun clearAuthTokens(customerWalletAddress: String) {
+        secureStorage.delete(createAuthTokensKey(customerWalletAddress))
+    }
+
    override suspend fun storeOrderId(customerWalletAddress: String, orderId: String) {
        withContext(dispatcherProvider.io) {
            appPreferencesStore.store(PreferencesKeys.getTangemPayOrderIdKey(customerWalletAddress), orderId)
@ -109,14 +121,6 @@ internal class DefaultTangemPayStorage @Inject constructor(
        return appPreferencesStore.getSyncOrNull(PreferencesKeys.getTangemPayCheckCustomerByWalletId(userWalletId))
    }

-    override suspend fun clearAll(userWalletId: UserWalletId, customerWalletAddress: String) =
-        withContext(dispatcherProvider.io) {
-            secureStorage.delete(createAuthTokensKey(customerWalletAddress))
-            appPreferencesStore.store(PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId), "")
-            appPreferencesStore.store(PreferencesKeys.getTangemPayOrderIdKey(customerWalletAddress), "")
-            appPreferencesStore.store(PreferencesKeys.getTangemPayAddToWalletKey(customerWalletAddress), false)
-        }
-
    override suspend fun storeWithdrawOrder(userWalletId: UserWalletId, orderId: String) {
        appPreferencesStore.editData { mutablePreferences ->
            val orders = mutablePreferences.getObjectMap<String>(PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY)
@ -144,6 +148,42 @@ internal class DefaultTangemPayStorage @Inject constructor(
        }
    }

+    override suspend fun storeHideOnboardingBanner(userWalletId: UserWalletId, hide: Boolean) {
+        withContext(dispatcherProvider.io) {
+            appPreferencesStore.store(PreferencesKeys.getTangemPayHideOnboardingKey(userWalletId), hide)
+        }
+    }
+
+    override suspend fun getHideMainOnboardingBanner(userWalletId: UserWalletId): Boolean {
+        return withContext(dispatcherProvider.io) {
+            appPreferencesStore.getSyncOrNull(
+                key = PreferencesKeys.getTangemPayHideOnboardingKey(userWalletId),
+            ) == true
+        }
+    }
+
+    override suspend fun storeTangemPayEligibility(eligibility: Boolean) {
+        withContext(dispatcherProvider.io) {
+            appPreferencesStore.store(key = PreferencesKeys.TANGEM_PAY_ELIGIBILITY_KEY, value = eligibility)
+        }
+    }
+
+    override suspend fun getTangemPayEligibility(): Boolean {
+        return withContext(dispatcherProvider.io) {
+            appPreferencesStore.getSyncOrDefault(key = PreferencesKeys.TANGEM_PAY_ELIGIBILITY_KEY, default = false)
+        }
+    }
+
+    override suspend fun clearAll(userWalletId: UserWalletId, customerWalletAddress: String) =
+        withContext(dispatcherProvider.io) {
+            secureStorage.delete(createAuthTokensKey(customerWalletAddress))
+            appPreferencesStore.store(PreferencesKeys.getTangemPayCheckCustomerByWalletId(userWalletId), false)
+            appPreferencesStore.store(PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId), "")
+            appPreferencesStore.store(PreferencesKeys.getTangemPayOrderIdKey(customerWalletAddress), "")
+            appPreferencesStore.store(PreferencesKeys.getTangemPayAddToWalletKey(customerWalletAddress), false)
+            appPreferencesStore.store(PreferencesKeys.getTangemPayHideOnboardingKey(userWalletId), false)
+        }
+
    private fun createAuthTokensKey(address: String): String = "${AUTH_TOKENS_DEFAULT_KEY}_$address"

    private fun createWithdrawOrderIdKey(userWalletId: UserWalletId): String = "${WITHDRAW_ORDER_ID_KEY}_$userWalletId"
--- a/app/src/main/java/com/tangem/tap/di/core/security/SecurityModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/core/security/SecurityModule.kt
@ -0,0 +1,20 @@
+package com.tangem.tap.di.core.security
+
+import com.tangem.security.DeviceSecurityInfoProvider
+import com.tangem.tap.core.security.DefaultDeviceSecurityInfoProvider
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object SecurityModule {
+
+    @Provides
+    @Singleton
+    fun provideDeviceSecurityInfoProvider(): DeviceSecurityInfoProvider {
+        return DefaultDeviceSecurityInfoProvider()
+    }
+}
--- a/app/src/main/java/com/tangem/tap/di/domain/AccountDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/AccountDomainModule.kt
@ -67,11 +67,13 @@ internal object AccountDomainModule {
        accountsCRUDRepository: AccountsCRUDRepository,
        mainAccountTokensMigration: MainAccountTokensMigration,
        cryptoCurrencyBalanceFetcher: CryptoCurrencyBalanceFetcher,
+        singleAccountListFetcher: SingleAccountListFetcher,
    ): RecoverCryptoPortfolioUseCase {
        return RecoverCryptoPortfolioUseCase(
            crudRepository = accountsCRUDRepository,
            mainAccountTokensMigration = mainAccountTokensMigration,
            cryptoCurrencyBalanceFetcher = cryptoCurrencyBalanceFetcher,
+            singleAccountListFetcher = singleAccountListFetcher,
        )
    }

--- a/app/src/main/java/com/tangem/tap/di/domain/HotWalletDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/HotWalletDomainModule.kt
@ -1,6 +1,8 @@
 package com.tangem.tap.di.domain

 import com.tangem.domain.hotwallet.GetAccessCodeSkippedUseCase
+import com.tangem.domain.hotwallet.IsHotWalletCreationSupported
+import com.tangem.domain.hotwallet.IsAccessCodeSimpleUseCase
 import com.tangem.domain.hotwallet.SetAccessCodeSkippedUseCase
 import com.tangem.domain.hotwallet.repository.HotWalletRepository
 import dagger.Module
@ -24,4 +26,18 @@ internal object HotWalletDomainModule {
    fun provideSetAccessCodeSkippedUseCase(hotWalletRepository: HotWalletRepository): SetAccessCodeSkippedUseCase {
        return SetAccessCodeSkippedUseCase(hotWalletRepository)
    }
+
+    @Provides
+    @Singleton
+    fun provideIsAccessCodeSimpleUseCase(): IsAccessCodeSimpleUseCase {
+        return IsAccessCodeSimpleUseCase()
+    }
+
+    @Provides
+    @Singleton
+    fun provideIsWalletCreationSupportedUseCase(
+        hotWalletRepository: HotWalletRepository,
+    ): IsHotWalletCreationSupported {
+        return IsHotWalletCreationSupported(hotWalletRepository)
+    }
 }
--- a/app/src/main/java/com/tangem/tap/di/domain/ManageTokensDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/ManageTokensDomainModule.kt
@ -6,7 +6,7 @@ import com.tangem.domain.managetokens.repository.ManageTokensRepository
 import com.tangem.domain.networks.multi.MultiNetworkStatusFetcher
 import com.tangem.domain.quotes.multi.MultiQuoteStatusFetcher
 import com.tangem.domain.staking.StakingIdFactory
-import com.tangem.domain.staking.multi.MultiYieldBalanceFetcher
+import com.tangem.domain.staking.multi.MultiStakingBalanceFetcher
 import com.tangem.domain.tokens.repository.CurrenciesRepository
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.derivations.DerivationsRepository
@ -74,7 +74,7 @@ internal object ManageTokensDomainModule {
        derivationsRepository: DerivationsRepository,
        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
-        multiYieldBalanceFetcher: MultiYieldBalanceFetcher,
+        multiStakingBalanceFetcher: MultiStakingBalanceFetcher,
        stakingIdFactory: StakingIdFactory,
        dispatchers: CoroutineDispatcherProvider,
    ): SaveManagedTokensUseCase {
@ -85,7 +85,7 @@ internal object ManageTokensDomainModule {
            derivationsRepository = derivationsRepository,
            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
-            multiYieldBalanceFetcher = multiYieldBalanceFetcher,
+            multiStakingBalanceFetcher = multiStakingBalanceFetcher,
            stakingIdFactory = stakingIdFactory,
            parallelUpdatingScope = CoroutineScope(SupervisorJob() + dispatchers.default),
        )
--- a/app/src/main/java/com/tangem/tap/di/domain/MarketsDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/MarketsDomainModule.kt
@ -8,10 +8,10 @@ import com.tangem.domain.networks.multi.MultiNetworkStatusFetcher
 import com.tangem.domain.promo.PromoRepository
 import com.tangem.domain.quotes.multi.MultiQuoteStatusFetcher
 import com.tangem.domain.quotes.single.SingleQuoteStatusSupplier
-import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.staking.StakingIdFactory
-import com.tangem.domain.staking.multi.MultiYieldBalanceFetcher
+import com.tangem.domain.staking.multi.MultiStakingBalanceFetcher
 import com.tangem.domain.tokens.repository.CurrenciesRepository
+import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.derivations.DerivationsRepository
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.features.hotwallet.HotWalletFeatureToggles
@ -36,6 +36,14 @@ object MarketsDomainModule {
        return GetMarketsTokenListFlowUseCase(marketsTokenRepository = marketsTokenRepository)
    }

+    @Provides
+    @Singleton
+    fun provideGetTopFiveMarketTokenUseCase(
+        marketsTokenRepository: MarketsTokenRepository,
+    ): GetTopFiveMarketTokenUseCase {
+        return GetTopFiveMarketTokenUseCase(marketsTokenRepository = marketsTokenRepository)
+    }
+
    @Provides
    @Singleton
    fun provideGetTokenPriceChartUseCase(marketsTokenRepository: MarketsTokenRepository): GetTokenPriceChartUseCase {
@ -65,20 +73,22 @@ object MarketsDomainModule {
    fun provideSaveMarketTokensUseCase(
        derivationsRepository: DerivationsRepository,
        marketsTokenRepository: MarketsTokenRepository,
+        walletManagersFacade: WalletManagersFacade,
        currenciesRepository: CurrenciesRepository,
        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
-        multiYieldBalanceFetcher: MultiYieldBalanceFetcher,
+        multiStakingBalanceFetcher: MultiStakingBalanceFetcher,
        stakingIdFactory: StakingIdFactory,
        dispatchers: CoroutineDispatcherProvider,
    ): SaveMarketTokensUseCase {
        return SaveMarketTokensUseCase(
            derivationsRepository = derivationsRepository,
            marketsTokenRepository = marketsTokenRepository,
+            walletManagersFacade = walletManagersFacade,
            currenciesRepository = currenciesRepository,
            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
-            multiYieldBalanceFetcher = multiYieldBalanceFetcher,
+            multiStakingBalanceFetcher = multiStakingBalanceFetcher,
            stakingIdFactory = stakingIdFactory,
            parallelUpdatingScope = CoroutineScope(SupervisorJob() + dispatchers.default),
        )
@ -118,13 +128,11 @@ object MarketsDomainModule {

    @Provides
    @Singleton
-    fun provideGetStakingNotificationMaxApyUseCase(
-        settingsRepository: SettingsRepository,
+    fun provideShouldShowYieldModeMarketPromoUseCase(
        promoRepository: PromoRepository,
        marketsTokenRepository: MarketsTokenRepository,
-    ): GetStakingNotificationMaxApyUseCase {
-        return GetStakingNotificationMaxApyUseCase(
-            settingsRepository = settingsRepository,
+    ): ShouldShowYieldModeMarketPromoUseCase {
+        return ShouldShowYieldModeMarketPromoUseCase(
            promoRepository = promoRepository,
            marketsTokenRepository = marketsTokenRepository,
        )
--- a/app/src/main/java/com/tangem/tap/di/domain/NFTDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/NFTDomainModule.kt
@ -1,11 +1,11 @@
 package com.tangem.tap.di.domain

 import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
-import com.tangem.domain.account.status.supplier.SingleAccountStatusListSupplier
 import com.tangem.domain.account.supplier.SingleAccountListSupplier
 import com.tangem.domain.networks.single.SingleNetworkStatusSupplier
 import com.tangem.domain.nft.*
 import com.tangem.domain.nft.repository.NFTRepository
+import com.tangem.domain.nft.utils.NFTCleaner
 import com.tangem.domain.quotes.single.SingleQuoteStatusFetcher
 import com.tangem.domain.quotes.single.SingleQuoteStatusSupplier
 import com.tangem.domain.tokens.MultiWalletCryptoCurrenciesSupplier
@ -27,12 +27,12 @@ internal object NFTDomainModule {
    fun providesGetNFTCollectionsUseCase(
        currenciesRepository: CurrenciesRepository,
        nftRepository: NFTRepository,
-        singleAccountStatusListSupplier: SingleAccountStatusListSupplier,
+        singleAccountListSupplier: SingleAccountListSupplier,
        accountsFeatureToggles: AccountsFeatureToggles,
    ): GetNFTCollectionsUseCase = GetNFTCollectionsUseCase(
        currenciesRepository = currenciesRepository,
        nftRepository = nftRepository,
-        singleAccountStatusListSupplier = singleAccountStatusListSupplier,
+        singleAccountListSupplier = singleAccountListSupplier,
        accountsFeatureToggles = accountsFeatureToggles,
    )

@ -67,12 +67,12 @@ internal object NFTDomainModule {
    @Singleton
    fun providesGetNFTAvailableNetworksUseCase(
        nftRepository: NFTRepository,
-        singleAccountStatusListSupplier: SingleAccountStatusListSupplier,
+        singleAccountListSupplier: SingleAccountListSupplier,
        currenciesRepository: CurrenciesRepository,
    ): GetNFTNetworksUseCase = GetNFTNetworksUseCase(
        currenciesRepository = currenciesRepository,
        nftRepository = nftRepository,
-        singleAccountStatusListSupplier = singleAccountStatusListSupplier,
+        singleAccountListSupplier = singleAccountListSupplier,
    )

    @Provides
@ -126,13 +126,13 @@ internal object NFTDomainModule {
    @Singleton
    fun provideDisableWalletNFTUseCase(
        walletsRepository: WalletsRepository,
-        nftRepository: NFTRepository,
        multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
+        nftCleaner: NFTCleaner,
    ): DisableWalletNFTUseCase {
        return DisableWalletNFTUseCase(
            walletsRepository = walletsRepository,
-            nftRepository = nftRepository,
            multiWalletCryptoCurrenciesSupplier = multiWalletCryptoCurrenciesSupplier,
+            nftCleaner = nftCleaner,
        )
    }

@ -145,13 +145,13 @@ internal object NFTDomainModule {
    @Provides
    @Singleton
    fun provideClearNFTCacheUseCase(
-        nftRepository: NFTRepository,
+        nftCleaner: NFTCleaner,
        currenciesRepository: CurrenciesRepository,
        accountsFeatureToggles: AccountsFeatureToggles,
        singleAccountListSupplier: SingleAccountListSupplier,
    ): ObserveAndClearNFTCacheIfNeedUseCase {
        return ObserveAndClearNFTCacheIfNeedUseCase(
-            nftRepository = nftRepository,
+            nftCleaner = nftCleaner,
            currenciesRepository = currenciesRepository,
            accountsFeatureToggles = accountsFeatureToggles,
            singleAccountListSupplier = singleAccountListSupplier,
--- a/app/src/main/java/com/tangem/tap/di/domain/NewsDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/NewsDomainModule.kt
@ -1,10 +1,7 @@
 package com.tangem.tap.di.domain

 import com.tangem.domain.news.repository.NewsRepository
-import com.tangem.domain.news.usecase.GetNewsCategoriesUseCase
-import com.tangem.domain.news.usecase.GetNewsListBatchFlowUseCase
-import com.tangem.domain.news.usecase.ObserveNewsDetailsUseCase
-import com.tangem.domain.news.usecase.ManageTrendingNewsUseCase
+import com.tangem.domain.news.usecase.*
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@ -38,4 +35,10 @@ internal object NewsDomainModule {
    fun provideGetNewsListBatchFlowUseCase(repository: NewsRepository): GetNewsListBatchFlowUseCase {
        return GetNewsListBatchFlowUseCase(repository)
    }
+
+    @Provides
+    @Singleton
+    fun provideFetchTrendingNewsUseCase(repository: NewsRepository): FetchTrendingNewsUseCase {
+        return FetchTrendingNewsUseCase(repository)
+    }
 }
--- a/app/src/main/java/com/tangem/tap/di/domain/StakingDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/StakingDomainModule.kt
@ -2,7 +2,7 @@ package com.tangem.tap.di.domain

 import com.tangem.domain.staking.*
 import com.tangem.domain.staking.repositories.*
-import com.tangem.domain.staking.single.SingleYieldBalanceFetcher
+import com.tangem.domain.staking.single.SingleStakingBalanceFetcher
 import com.tangem.domain.staking.usecase.StakingAvailabilityListUseCase
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import dagger.Module
@ -107,11 +107,11 @@ internal object StakingDomainModule {
    @Provides
    @Singleton
    fun provideFetchStakingYieldBalanceUseCase(
-        singleYieldBalanceFetcher: SingleYieldBalanceFetcher,
+        singleStakingBalanceFetcher: SingleStakingBalanceFetcher,
        stakingIdFactory: StakingIdFactory,
    ): FetchStakingYieldBalanceUseCase {
        return FetchStakingYieldBalanceUseCase(
-            singleYieldBalanceFetcher = singleYieldBalanceFetcher,
+            singleStakingBalanceFetcher = singleStakingBalanceFetcher,
            stakingIdFactory = stakingIdFactory,
        )
    }
--- a/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
@ -12,15 +12,18 @@ import com.tangem.domain.quotes.QuotesRepository
 import com.tangem.domain.quotes.multi.MultiQuoteStatusFetcher
 import com.tangem.domain.quotes.single.SingleQuoteStatusSupplier
 import com.tangem.domain.staking.StakingIdFactory
-import com.tangem.domain.staking.multi.MultiYieldBalanceFetcher
-import com.tangem.domain.staking.multi.MultiYieldBalanceSupplier
+import com.tangem.domain.staking.multi.MultiStakingBalanceFetcher
+import com.tangem.domain.staking.multi.MultiStakingBalanceSupplier
 import com.tangem.domain.staking.repositories.StakingRepository
-import com.tangem.domain.staking.single.SingleYieldBalanceFetcher
-import com.tangem.domain.staking.single.SingleYieldBalanceSupplier
+import com.tangem.domain.staking.single.SingleStakingBalanceFetcher
+import com.tangem.domain.staking.single.SingleStakingBalanceSupplier
 import com.tangem.domain.tokens.*
 import com.tangem.domain.tokens.operations.BaseCurrencyStatusOperations
 import com.tangem.domain.tokens.operations.CachedCurrenciesStatusesOperations
-import com.tangem.domain.tokens.repository.*
+import com.tangem.domain.tokens.repository.CurrenciesRepository
+import com.tangem.domain.tokens.repository.CurrencyChecksRepository
+import com.tangem.domain.tokens.repository.TokenReceiveWarningsViewedRepository
+import com.tangem.domain.tokens.repository.YieldSupplyWarningsViewedRepository
 import com.tangem.domain.tokens.wallet.WalletBalanceFetcher
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.tap.domain.tokens.DefaultTokensFeatureToggles
@ -40,17 +43,19 @@ internal object TokensDomainModule {
    @Singleton
    fun provideAddCryptoCurrenciesUseCase(
        currenciesRepository: CurrenciesRepository,
+        walletManagersFacade: WalletManagersFacade,
        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
-        singleYieldBalanceFetcher: SingleYieldBalanceFetcher,
+        singleStakingBalanceFetcher: SingleStakingBalanceFetcher,
        multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
        stakingIdFactory: StakingIdFactory,
    ): AddCryptoCurrenciesUseCase {
        return AddCryptoCurrenciesUseCase(
            currenciesRepository = currenciesRepository,
+            walletManagersFacade = walletManagersFacade,
            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
-            singleYieldBalanceFetcher = singleYieldBalanceFetcher,
+            singleStakingBalanceFetcher = singleStakingBalanceFetcher,
            multiWalletCryptoCurrenciesSupplier = multiWalletCryptoCurrenciesSupplier,
            stakingIdFactory = stakingIdFactory,
        )
@ -148,7 +153,7 @@ internal object TokensDomainModule {
        currenciesRepository: CurrenciesRepository,
        singleNetworkStatusFetcher: SingleNetworkStatusFetcher,
        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
-        singleYieldBalanceFetcher: SingleYieldBalanceFetcher,
+        singleStakingBalanceFetcher: SingleStakingBalanceFetcher,
        multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
        stakingIdFactory: StakingIdFactory,
    ): FetchCurrencyStatusUseCase {
@ -156,7 +161,7 @@ internal object TokensDomainModule {
            currenciesRepository = currenciesRepository,
            singleNetworkStatusFetcher = singleNetworkStatusFetcher,
            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
-            singleYieldBalanceFetcher = singleYieldBalanceFetcher,
+            singleStakingBalanceFetcher = singleStakingBalanceFetcher,
            multiWalletCryptoCurrenciesSupplier = multiWalletCryptoCurrenciesSupplier,
            stakingIdFactory = stakingIdFactory,
        )
@ -339,8 +344,8 @@ internal object TokensDomainModule {
        singleNetworkStatusSupplier: SingleNetworkStatusSupplier,
        multiNetworkStatusSupplier: MultiNetworkStatusSupplier,
        singleQuoteStatusSupplier: SingleQuoteStatusSupplier,
-        singleYieldBalanceSupplier: SingleYieldBalanceSupplier,
-        multiYieldBalanceSupplier: MultiYieldBalanceSupplier,
+        singleStakingBalanceSupplier: SingleStakingBalanceSupplier,
+        multiStakingBalanceSupplier: MultiStakingBalanceSupplier,
        multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
        stakingIdFactory: StakingIdFactory,
    ): BaseCurrencyStatusOperations {
@ -350,8 +355,8 @@ internal object TokensDomainModule {
            singleNetworkStatusSupplier = singleNetworkStatusSupplier,
            multiNetworkStatusSupplier = multiNetworkStatusSupplier,
            singleQuoteStatusSupplier = singleQuoteStatusSupplier,
-            singleYieldBalanceSupplier = singleYieldBalanceSupplier,
-            multiYieldBalanceSupplier = multiYieldBalanceSupplier,
+            singleStakingBalanceSupplier = singleStakingBalanceSupplier,
+            multiStakingBalanceSupplier = multiStakingBalanceSupplier,
            multiWalletCryptoCurrenciesSupplier = multiWalletCryptoCurrenciesSupplier,
            stakingIdFactory = stakingIdFactory,
        )
@ -371,7 +376,7 @@ internal object TokensDomainModule {
        multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
-        multiYieldBalanceFetcher: MultiYieldBalanceFetcher,
+        multiStakingBalanceFetcher: MultiStakingBalanceFetcher,
        stakingIdFactory: StakingIdFactory,
        dispatchers: CoroutineDispatcherProvider,
    ): WalletBalanceFetcher {
@ -381,7 +386,7 @@ internal object TokensDomainModule {
            multiWalletCryptoCurrenciesSupplier = multiWalletCryptoCurrenciesSupplier,
            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
-            multiYieldBalanceFetcher = multiYieldBalanceFetcher,
+            multiStakingBalanceFetcher = multiStakingBalanceFetcher,
            stakingIdFactory = stakingIdFactory,
            dispatchers = dispatchers,
        )
--- a/app/src/main/java/com/tangem/tap/di/domain/YieldSupplyDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/YieldSupplyDomainModule.kt
@ -1,10 +1,10 @@
 package com.tangem.tap.di.domain

 import com.tangem.domain.blockaid.BlockAidGasEstimate
-import com.tangem.domain.transaction.FeeRepository
-import com.tangem.domain.transaction.error.FeeErrorResolver
 import com.tangem.domain.quotes.QuotesRepository
 import com.tangem.domain.tokens.repository.CurrenciesRepository
+import com.tangem.domain.transaction.FeeRepository
+import com.tangem.domain.transaction.error.FeeErrorResolver
 import com.tangem.domain.yield.supply.YieldSupplyErrorResolver
 import com.tangem.domain.yield.supply.YieldSupplyRepository
 import com.tangem.domain.yield.supply.YieldSupplyTransactionRepository
@ -16,6 +16,7 @@ import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
 import javax.inject.Singleton

+@Suppress("TooManyFunctions")
@Module
@InstallIn(SingletonComponent::class)
 internal object YieldSupplyDomainModule {
@ -225,4 +226,12 @@ internal object YieldSupplyDomainModule {
    fun provideYieldSupplyGetDustMinAmountUseCase(): YieldSupplyGetDustMinAmountUseCase {
        return YieldSupplyGetDustMinAmountUseCase()
    }
+
+    @Provides
+    @Singleton
+    fun provideYieldSupplyGetAvailabilityUseCase(
+        yieldSupplyRepository: YieldSupplyRepository,
+    ): YieldSupplyGetAvailabilityUseCase {
+        return YieldSupplyGetAvailabilityUseCase(yieldSupplyRepository)
+    }
 }
--- a/app/src/main/java/com/tangem/tap/domain/TapWalletManager.kt
+++ b/app/src/main/java/com/tangem/tap/domain/TapWalletManager.kt
@ -33,6 +33,9 @@ class TapWalletManager(
            .apply { join() }
    }

+    /**
+     * [REDACTED_TODO_COMMENT]
+     */
    private suspend fun loadUserWalletData(userWallet: UserWallet) {
        val trackingContextProxy = store.inject(DaggerGraphState::trackingContextProxy)
        trackingContextProxy.setContext(userWallet)
--- a/app/src/main/java/com/tangem/tap/domain/scanCard/LegacyScanProcessor.kt
+++ b/app/src/main/java/com/tangem/tap/domain/scanCard/LegacyScanProcessor.kt
@ -164,7 +164,7 @@ internal class LegacyScanProcessor @Inject constructor(
    ) {
        if (error is TangemSdkError.CardVerificationFailed) {
            analyticsEventHandler.send(
-                event = OnboardingAnalyticsEvent.Onboarding.OfflineAttestationFailed(
+                event = OnboardingAnalyticsEvent.Error.OfflineAttestationFailed(
                    analyticsSource,
                ),
            )
--- a/app/src/main/java/com/tangem/tap/domain/sdk/impl/DefaultTangemSdkManager.kt
+++ b/app/src/main/java/com/tangem/tap/domain/sdk/impl/DefaultTangemSdkManager.kt
@ -3,6 +3,9 @@ package com.tangem.tap.domain.sdk.impl
 import android.content.res.Resources
 import androidx.annotation.DrawableRes
 import androidx.annotation.StringRes
+import arrow.core.Either
+import arrow.core.left
+import arrow.core.right
 import com.tangem.Log
 import com.tangem.Message
 import com.tangem.TangemSdk
@ -24,6 +27,7 @@ import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.pay.WithdrawalSignatureResult
 import com.tangem.domain.visa.model.*
 import com.tangem.domain.wallets.derivations.derivationStyleProvider
 import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
@ -515,24 +519,47 @@ internal class DefaultTangemSdkManager(
    }

    override suspend fun tangemPayProduceInitialCredentials(
-        cardId: String,
-    ): CompletionResult<TangemPayInitialCredentials> {
+        preflightReadFilter: PreflightReadFilter,
+    ): Either<Throwable, TangemPayInitialCredentials> {
        return coroutineScope {
-            runTaskAsyncReturnOnMain(
+            val result = runTaskAsyncReturnOnMain(
                runnable = tangemPayChallengeTaskFactory.create(coroutineScope = this),
-                cardId = cardId,
+                cardId = null,
                initialMessage = Message(resources.getStringSafe(R.string.initial_message_tap_header)),
+                preflightReadFilter = preflightReadFilter,
            )
+
+            return@coroutineScope when (result) {
+                is CompletionResult.Failure<*> -> result.error.left()
+                is CompletionResult.Success<TangemPayInitialCredentials> -> result.data.right()
+            }
        }
    }

-    override suspend fun getWithdrawalSignature(cardId: String, hash: String): CompletionResult<String> {
+    override suspend fun getWithdrawalSignature(
+        hash: String,
+        preflightReadFilter: PreflightReadFilter,
+    ): Either<Throwable, WithdrawalSignatureResult> {
        return coroutineScope {
-            runTaskAsyncReturnOnMain(
-                runnable = TangemPaySignWithdrawalHashTask(cardId = cardId, hash = hash.hexToBytes()),
-                cardId = cardId,
+            val result = runTaskAsyncReturnOnMain(
+                runnable = TangemPaySignWithdrawalHashTask(hash = hash.hexToBytes()),
+                cardId = null,
                initialMessage = Message(resources.getStringSafe(R.string.initial_message_tap_header)),
+                preflightReadFilter = preflightReadFilter,
            )
+
+            return@coroutineScope when (result) {
+                is CompletionResult.Failure<*> -> {
+                    if (result.error is TangemSdkError.UserCancelled) {
+                        WithdrawalSignatureResult.Cancelled.right()
+                    } else {
+                        result.error.left()
+                    }
+                }
+                is CompletionResult.Success<String> -> {
+                    WithdrawalSignatureResult.Success(result.data).right()
+                }
+            }
        }
    }
    // endregion
--- a/app/src/main/java/com/tangem/tap/domain/sdk/impl/MockTangemSdkManager.kt
+++ b/app/src/main/java/com/tangem/tap/domain/sdk/impl/MockTangemSdkManager.kt
@ -3,6 +3,7 @@ package com.tangem.tap.domain.sdk.impl
 import android.content.res.Resources
 import androidx.annotation.DrawableRes
 import androidx.annotation.StringRes
+import arrow.core.Either
 import com.tangem.Message
 import com.tangem.common.CompletionResult
 import com.tangem.common.KeyPair
@ -18,7 +19,11 @@ import com.tangem.crypto.hdWallet.bip32.ExtendedPublicKey
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.visa.model.*
+import com.tangem.domain.pay.WithdrawalSignatureResult
+import com.tangem.domain.visa.model.TangemPayInitialCredentials
+import com.tangem.domain.visa.model.VisaActivationInput
+import com.tangem.domain.visa.model.VisaDataForApprove
+import com.tangem.domain.visa.model.VisaSignedDataByCustomerWallet
 import com.tangem.operations.derivation.DerivationTaskResponse
 import com.tangem.operations.preflightread.PreflightReadFilter
 import com.tangem.operations.wallet.CreateWalletResponse
@ -214,12 +219,15 @@ class MockTangemSdkManager(
    }

    override suspend fun tangemPayProduceInitialCredentials(
-        cardId: String,
-    ): CompletionResult<TangemPayInitialCredentials> {
+        preflightReadFilter: PreflightReadFilter,
+    ): Either<Throwable, TangemPayInitialCredentials> {
        error("Not implemented")
    }

-    override suspend fun getWithdrawalSignature(cardId: String, hash: String): CompletionResult<String> {
+    override suspend fun getWithdrawalSignature(
+        hash: String,
+        preflightReadFilter: PreflightReadFilter,
+    ): Either<Throwable, WithdrawalSignatureResult> {
        error("Not implemented")
    }

--- a/app/src/main/java/com/tangem/tap/domain/tasks/visa/TangemPayGenerateAddressAndSignChallengeTask.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tasks/visa/TangemPayGenerateAddressAndSignChallengeTask.kt
@ -3,7 +3,6 @@ package com.tangem.tap.domain.tasks.visa
 import arrow.core.getOrElse
 import com.tangem.common.CompletionResult
 import com.tangem.common.card.CardWallet
-import com.tangem.common.card.EllipticCurve
 import com.tangem.common.core.CardSession
 import com.tangem.common.core.CardSessionRunnable
 import com.tangem.common.core.CompletionCallback
@ -11,7 +10,7 @@ import com.tangem.common.core.TangemSdkError
 import com.tangem.core.error.ext.tangemError
 import com.tangem.crypto.hdWallet.bip32.ExtendedPublicKey
 import com.tangem.domain.card.common.visa.VisaUtilities
-import com.tangem.domain.visa.datasource.VisaAuthRemoteDataSource
+import com.tangem.domain.visa.datasource.TangemPayRemoteDataSource
 import com.tangem.domain.visa.error.VisaActivationError
 import com.tangem.domain.visa.model.TangemPayInitialCredentials
 import com.tangem.domain.visa.model.VisaDataToSignByCustomerWallet
@ -31,7 +30,7 @@ import kotlinx.coroutines.withContext
 class TangemPayGenerateAddressAndSignChallengeTask @AssistedInject constructor(
    @Assisted private val coroutineScope: CoroutineScope,
    private val dispatchersProvider: CoroutineDispatcherProvider,
-    private val visaAuthRemoteDataSource: VisaAuthRemoteDataSource,
+    private val tangemPayRemoteDataSource: TangemPayRemoteDataSource,
 ) : CardSessionRunnable<TangemPayInitialCredentials> {

    override fun run(session: CardSession, callback: CompletionCallback<TangemPayInitialCredentials>) {
@ -42,17 +41,19 @@ class TangemPayGenerateAddressAndSignChallengeTask @AssistedInject constructor(

    private suspend fun runSuspend(session: CardSession): CompletionResult<TangemPayInitialCredentials> {
        val card = session.environment.card ?: return CompletionResult.Failure(TangemSdkError.MissingPreflightRead())
-        val wallet = card.wallets.firstOrNull { it.curve == EllipticCurve.Secp256k1 }
+        val wallet = card.wallets.firstOrNull { it.curve == VisaUtilities.curve }
            ?: return CompletionResult.Failure(VisaActivationError.MissingWallet.tangemError)

        val address = when (val derivationResult = runDerivationTask(session, wallet)) {
            is CompletionResult.Failure<*> -> return CompletionResult.Failure(derivationResult.error)
-            is CompletionResult.Success<ExtendedPublicKey> -> generateAddressFromExtendedKey(derivationResult.data)
+            is CompletionResult.Success<ExtendedPublicKey> -> VisaUtilities.generateAddressFromExtendedKey(
+                extendedPublicKey = derivationResult.data,
+            )
        }

        val userWalletId = UserWalletIdBuilder.walletPublicKey(wallet.publicKey)
        val challenge = withContext(dispatchersProvider.io) {
-            visaAuthRemoteDataSource.getCustomerWalletAuthChallenge(
+            tangemPayRemoteDataSource.getCustomerWalletAuthChallenge(
                customerWalletAddress = address,
                customerWalletId = userWalletId.stringValue,
            )
@ -61,7 +62,6 @@ class TangemPayGenerateAddressAndSignChallengeTask @AssistedInject constructor(
        val dataToSign = VisaDataToSignByCustomerWallet(hashToSign = challenge.challenge)
        val approveResult = runVisaCustomerWalletApproveTask(
            session = session,
-            cardId = card.cardId,
            targetAddress = address,
            dataToSign = dataToSign,
        )
@ -71,7 +71,7 @@ class TangemPayGenerateAddressAndSignChallengeTask @AssistedInject constructor(
        }

        val authTokens = withContext(dispatchersProvider.io) {
-            visaAuthRemoteDataSource.getTokenWithCustomerWallet(
+            tangemPayRemoteDataSource.getTokenWithCustomerWallet(
                sessionId = challenge.session.sessionId,
                signature = signedData.signature,
                nonce = signedData.dataToSign.hashToSign,
@ -102,14 +102,13 @@ class TangemPayGenerateAddressAndSignChallengeTask @AssistedInject constructor(

    private suspend fun runVisaCustomerWalletApproveTask(
        session: CardSession,
-        cardId: String,
        targetAddress: String,
        dataToSign: VisaDataToSignByCustomerWallet,
    ): CompletionResult<VisaSignedDataByCustomerWallet> {
        val deferred = CompletableDeferred<CompletionResult<VisaSignedDataByCustomerWallet>>()
        val task = VisaCustomerWalletApproveTask(
            visaDataForApprove = VisaCustomerWalletApproveTask.Input(
-                cardId = cardId,
+                cardId = null,
                targetAddress = targetAddress,
                hashToSign = dataToSign.hashToSign,
                sign = dataToSign::sign,
@ -119,14 +118,6 @@ class TangemPayGenerateAddressAndSignChallengeTask @AssistedInject constructor(
        return deferred.await()
    }

-    private fun generateAddressFromExtendedKey(extendedPublicKey: ExtendedPublicKey): String {
-        val derivationData = VisaUtilities.visaBlockchain.makeAddressesFromExtendedPublicKey(
-            extendedPublicKey = extendedPublicKey,
-            cachedIndex = null,
-        )
-        return derivationData.address
-    }
-
    @AssistedFactory
    interface Factory {
        fun create(coroutineScope: CoroutineScope): TangemPayGenerateAddressAndSignChallengeTask
--- a/app/src/main/java/com/tangem/tap/domain/tasks/visa/TangemPaySignWithdrawalHashTask.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tasks/visa/TangemPaySignWithdrawalHashTask.kt
@ -1,15 +1,11 @@
 package com.tangem.tap.domain.tasks.visa

-import com.tangem.blockchain.common.UnmarshalHelper
 import com.tangem.common.CompletionResult
 import com.tangem.common.card.Card
-import com.tangem.common.card.EllipticCurve
 import com.tangem.common.core.CardSession
 import com.tangem.common.core.CardSessionRunnable
 import com.tangem.common.core.CompletionCallback
 import com.tangem.common.core.TangemSdkError
-import com.tangem.common.extensions.toDecompressedPublicKey
-import com.tangem.common.extensions.toHexString
 import com.tangem.core.error.ext.tangemError
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.crypto.hdWallet.bip32.ExtendedPublicKey
@ -18,10 +14,7 @@ import com.tangem.domain.visa.error.VisaActivationError
 import com.tangem.operations.derivation.DeriveWalletPublicKeyTask
 import com.tangem.operations.sign.SignHashCommand

-class TangemPaySignWithdrawalHashTask(
-    private val cardId: String,
-    private val hash: ByteArray,
-) : CardSessionRunnable<String> {
+class TangemPaySignWithdrawalHashTask(private val hash: ByteArray) : CardSessionRunnable<String> {

    override fun run(session: CardSession, callback: CompletionCallback<String>) {
        val card = session.environment.card ?: run {
@ -29,18 +22,13 @@ class TangemPaySignWithdrawalHashTask(
            return
        }

-        if (card.cardId != cardId) {
-            callback(CompletionResult.Failure(VisaActivationError.CardIdNotMatched.tangemError))
-            return
-        }
-
        proceedSign(card, session, callback)
    }

    private fun proceedSign(card: Card, session: CardSession, callback: CompletionCallback<String>) {
        val derivationPath = VisaUtilities.customDerivationPath

-        val wallet = card.wallets.firstOrNull { it.curve == EllipticCurve.Secp256k1 } ?: run {
+        val wallet = card.wallets.firstOrNull { it.curve == VisaUtilities.curve } ?: run {
            callback(CompletionResult.Failure(VisaActivationError.MissingWallet.tangemError))
            return
        }
@ -71,7 +59,7 @@ class TangemPaySignWithdrawalHashTask(
    private fun signData(
        targetWalletPublicKey: ByteArray,
        derivationPath: DerivationPath?,
-        extendedPublicKey: ExtendedPublicKey?,
+        extendedPublicKey: ExtendedPublicKey,
        session: CardSession,
        callback: CompletionCallback<String>,
    ) {
@ -84,12 +72,11 @@ class TangemPaySignWithdrawalHashTask(
        signTask.run(session) { result ->
            when (result) {
                is CompletionResult.Success -> {
-                    val rsvSignature = UnmarshalHelper.unmarshalSignatureExtended(
+                    val rsvSignature = VisaUtilities.unmarshallSignature(
                        signature = result.data.signature,
                        hash = hash,
-                        publicKey = extendedPublicKey?.publicKey?.toDecompressedPublicKey()
-                            ?: targetWalletPublicKey.toDecompressedPublicKey(),
-                    ).asRSVLegacyEVM().toHexString().lowercase()
+                        extendedPublicKey = extendedPublicKey,
+                    )

                    callback(CompletionResult.Success(rsvSignature))
                }
--- a/app/src/main/java/com/tangem/tap/domain/tasks/visa/VisaCustomerWalletApproveTask.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tasks/visa/VisaCustomerWalletApproveTask.kt
@ -1,28 +1,19 @@
 package com.tangem.tap.domain.tasks.visa

-import arrow.core.getOrElse
-import com.tangem.blockchain.blockchains.ethereum.EthereumUtils.toKeccak
-import com.tangem.blockchain.common.UnmarshalHelper
 import com.tangem.common.CompletionResult
 import com.tangem.common.card.Card
 import com.tangem.common.card.CardWallet
-import com.tangem.common.card.EllipticCurve
 import com.tangem.common.core.CardSession
 import com.tangem.common.core.CardSessionRunnable
 import com.tangem.common.core.CompletionCallback
 import com.tangem.common.core.TangemSdkError
-import com.tangem.common.extensions.toDecompressedPublicKey
-import com.tangem.common.extensions.toHexString
 import com.tangem.core.error.ext.tangemError
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.crypto.hdWallet.bip32.ExtendedPublicKey
 import com.tangem.domain.card.common.visa.VisaUtilities
 import com.tangem.domain.card.common.visa.VisaWalletPublicKeyUtility
-import com.tangem.domain.card.common.visa.VisaWalletPublicKeyUtility.findKeyWithoutDerivation
-import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.visa.error.VisaActivationError
 import com.tangem.domain.visa.model.VisaSignedDataByCustomerWallet
-import com.tangem.operations.ScanTask
 import com.tangem.operations.derivation.DeriveWalletPublicKeyTask
 import com.tangem.operations.sign.SignHashCommand

@ -46,11 +37,7 @@ class VisaCustomerWalletApproveTask(
            return
        }

-        if (card.settings.isHDWalletAllowed) {
-            proceedApprove(card, session, callback)
-        } else {
-            proceedApproveWithLegacyCard(card, session, callback)
-        }
+        proceedApprove(card, session, callback)
    }

    private fun proceedApprove(
@ -60,7 +47,7 @@ class VisaCustomerWalletApproveTask(
    ) {
        val derivationPath = VisaUtilities.customDerivationPath

-        val wallet = card.wallets.firstOrNull { it.curve == EllipticCurve.Secp256k1 } ?: run {
+        val wallet = card.wallets.firstOrNull { it.curve == VisaUtilities.curve } ?: run {
            callback(CompletionResult.Failure(VisaActivationError.MissingWallet.tangemError))
            return
        }
@ -114,43 +101,15 @@ class VisaCustomerWalletApproveTask(
        )
    }

-    private fun proceedApproveWithLegacyCard(
-        card: Card,
-        session: CardSession,
-        callback: CompletionCallback<VisaSignedDataByCustomerWallet>,
-    ) {
-        val publicKey = findKeyWithoutDerivation(
-            targetAddress = visaDataForApprove.targetAddress,
-            card = CardDTO(card),
-        ).getOrElse { error ->
-            callback(CompletionResult.Failure(error.tangemError))
-            return
-        }
-
-        signApproveData(
-            targetWalletPublicKey = publicKey,
-            derivationPath = null,
-            extendedPublicKey = null,
-            session = session,
-            callback = callback,
-        )
-    }
-
-    // TODO: [REDACTED_TASK_KEY] - Get this public function from Blockchain SDK
-    private fun hashPersonalMessage(message: ByteArray): ByteArray {
-        val prefix = "\u0019Ethereum Signed Message:\n${message.size}".toByteArray()
-        return (prefix + message).toKeccak()
-    }
-
    private fun signApproveData(
        targetWalletPublicKey: ByteArray,
        derivationPath: DerivationPath?,
-        extendedPublicKey: ExtendedPublicKey?,
+        extendedPublicKey: ExtendedPublicKey,
        session: CardSession,
        callback: CompletionCallback<VisaSignedDataByCustomerWallet>,
    ) {
-        val content = "Tangem Pay wants to sign in with your account. Nonce: ${visaDataForApprove.hashToSign}"
-        val hash = hashPersonalMessage(content.toByteArray(Charsets.UTF_8))
+        val content = VisaUtilities.signWithNonceMessage(visaDataForApprove.hashToSign)
+        val hash = VisaUtilities.hashPersonalMessage(content.toByteArray(Charsets.UTF_8))

        val signTask = SignHashCommand(
            hash = hash,
@ -161,35 +120,13 @@ class VisaCustomerWalletApproveTask(
        signTask.run(session) { result ->
            when (result) {
                is CompletionResult.Success -> {
-                    val rsvSignature = UnmarshalHelper.unmarshalSignatureExtended(
+                    val rsvSignature = VisaUtilities.unmarshallSignature(
                        signature = result.data.signature,
                        hash = hash,
-                        publicKey = extendedPublicKey?.publicKey?.toDecompressedPublicKey()
-                            ?: targetWalletPublicKey.toDecompressedPublicKey(),
-                    ).asRSVLegacyEVM().toHexString().lowercase()
-
-                    scanCard(
-                        session = session,
-                        callback = callback,
-                        signedData = visaDataForApprove.sign(rsvSignature, visaDataForApprove.targetAddress),
+                        extendedPublicKey = extendedPublicKey,
                    )
-                }
-                is CompletionResult.Failure -> {
-                    callback(CompletionResult.Failure(result.error))
-                }
-            }
-        }
-    }

-    private fun scanCard(
-        signedData: VisaSignedDataByCustomerWallet,
-        session: CardSession,
-        callback: CompletionCallback<VisaSignedDataByCustomerWallet>,
-    ) {
-        val scanTask = ScanTask()
-        scanTask.run(session) { result ->
-            when (result) {
-                is CompletionResult.Success -> {
+                    val signedData = visaDataForApprove.sign(rsvSignature, visaDataForApprove.targetAddress)
                    callback(CompletionResult.Success(signedData))
                }
                is CompletionResult.Failure -> {
--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/di/UserWalletsListManagerModule.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/di/UserWalletsListManagerModule.kt
@ -7,8 +7,10 @@ import com.tangem.common.authentication.storage.AuthenticatedStorage
 import com.tangem.common.json.TangemSdkAdapter
 import com.tangem.common.services.secure.SecureStorage
 import com.tangem.core.analytics.api.AnalyticsEventHandler
+import com.tangem.core.analytics.utils.TrackingContextProxy
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.domain.common.wallets.UserWalletsListRepository
+import com.tangem.domain.hotwallet.repository.HotWalletRepository
 import com.tangem.domain.models.scan.serialization.*
 import com.tangem.domain.visa.model.VisaActivationRemoteState
 import com.tangem.domain.visa.model.VisaCardActivationStatus
@ -125,6 +127,9 @@ internal object UserWalletsListManagerModule {
        appPreferencesStore: AppPreferencesStore,
        hotWalletAccessCodeAttemptsRepository: HotWalletAccessCodeAttemptsRepository,
        tangemHotSdk: TangemHotSdk,
+        trackingContextProxy: TrackingContextProxy,
+        analyticsEventHandler: AnalyticsEventHandler,
+        hotWalletRepository: HotWalletRepository,
    ): UserWalletsListRepository {
        val moshi = buildMoshi()
        val secureStorage = buildSecureStorage(applicationContext = applicationContext)
@ -172,6 +177,9 @@ internal object UserWalletsListManagerModule {
            savePersistentInformation = ProviderSuspend { true }, // Always save persistent information for now
            hotWalletAccessCodeAttemptsRepository = hotWalletAccessCodeAttemptsRepository,
            tangemHotSdk = tangemHotSdk,
+            trackingContextProxy = trackingContextProxy,
+            analyticsEventHandler = analyticsEventHandler,
+            hotWalletRepository = hotWalletRepository,
        )
    }

--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt
@ -7,12 +7,16 @@ import arrow.core.raise.either
 import arrow.core.right
 import com.tangem.common.*
 import com.tangem.common.core.TangemSdkError
+import com.tangem.core.analytics.api.AnalyticsEventHandler
+import com.tangem.core.analytics.models.Basic
+import com.tangem.core.analytics.utils.TrackingContextProxy
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.datasource.local.preferences.PreferencesKeys
 import com.tangem.datasource.local.preferences.utils.getSyncOrDefault
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.common.wallets.UserWalletsListRepository.LockMethod
 import com.tangem.domain.common.wallets.error.*
+import com.tangem.domain.hotwallet.repository.HotWalletRepository
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.domain.models.wallet.isLocked
@ -50,6 +54,9 @@ internal class DefaultUserWalletsListRepository(
    private val appPreferencesStore: AppPreferencesStore,
    private val hotWalletAccessCodeAttemptsRepository: HotWalletAccessCodeAttemptsRepository,
    private val tangemHotSdk: TangemHotSdk,
+    private val trackingContextProxy: TrackingContextProxy,
+    private val analyticsEventHandler: AnalyticsEventHandler,
+    private val hotWalletRepository: HotWalletRepository,
 ) : UserWalletsListRepository {

    override val userWallets = MutableStateFlow<List<UserWallet>?>(null)
@ -204,7 +211,7 @@ internal class DefaultUserWalletsListRepository(

        userWalletEncryptionKeysRepository.delete(userWalletIds)

-        removeHotWalletsFromSDK(userWalletIds)
+        removeHotWalletsFromSDKAndRepos(userWalletIds)

        userWallets.update { currentWallets ->
            val updatedWallets = currentWallets?.filter { userWalletIds.contains(it.walletId).not() }
@ -235,6 +242,7 @@ internal class DefaultUserWalletsListRepository(
        when (unlockMethod) {
            UserWalletsListRepository.UnlockMethod.Biometric -> {
                unlockAllWallets().bind()
+                trackSignInEvent(userWallet, Basic.SignedIn.SignInType.Biometric)
                select(userWalletId)
            }
            UserWalletsListRepository.UnlockMethod.AccessCode -> {
@ -263,7 +271,10 @@ internal class DefaultUserWalletsListRepository(
                removePasswordAttempts(userWallet)

                sensitiveInformationRepository.getAll(listOf(encryptionKey))
-                    .doOnSuccess { sensitiveInfo -> updateWallets { it?.updateWith(sensitiveInfo) } }
+                    .doOnSuccess { sensitiveInfo ->
+                        updateWallets { it?.updateWith(sensitiveInfo) }
+                        trackSignInEvent(userWallet, Basic.SignedIn.SignInType.AccessCode)
+                    }
                    .doOnFailure { error -> raise(UnlockWalletError.UnableToUnlock.RawException(error)) }
            }
            is UserWalletsListRepository.UnlockMethod.Scan -> {
@ -291,7 +302,10 @@ internal class DefaultUserWalletsListRepository(
                )

                sensitiveInformationRepository.getAll(listOf(encryptionKey))
-                    .doOnSuccess { sensitiveInfo -> updateWallets { it?.updateWith(sensitiveInfo) } }
+                    .doOnSuccess { sensitiveInfo ->
+                        updateWallets { it?.updateWith(sensitiveInfo) }
+                        trackSignInEvent(userWallet, Basic.SignedIn.SignInType.Card)
+                    }
                    .doOnFailure { error -> raise(UnlockWalletError.UnableToUnlock.RawException(error)) }
            }
        }
@ -332,6 +346,9 @@ internal class DefaultUserWalletsListRepository(
        sensitiveInformationRepository.getAll(allKeys)
            .doOnSuccess { sensitiveInfo ->
                updateWallets { wallets -> wallets?.updateWith(sensitiveInfo) }
+                selectedUserWallet.value?.let {
+                    trackSignInEvent(it, Basic.SignedIn.SignInType.Biometric)
+                }
            }
            .doOnFailure { error -> raise(UnlockWalletError.UnableToUnlock.RawException(error)) }
    }
@ -373,7 +390,7 @@ internal class DefaultUserWalletsListRepository(
        if (newUserWallet.walletId == oldUserWallet.walletId &&
            oldUserWallet is UserWallet.Hot && newUserWallet is UserWallet.Cold
        ) {
-            removeHotWalletsFromSDK(walletIds = listOf(oldUserWallet.walletId))
+            removeHotWalletsFromSDKAndRepos(walletIds = listOf(oldUserWallet.walletId))
            // When upgrading from Hot to Cold, if biometric lock is available, set it
            if (hasBiometry()) {
                setLock(newUserWallet.walletId, LockMethod.Biometric, changeUnsecured = true)
@ -384,13 +401,14 @@ internal class DefaultUserWalletsListRepository(
        }
    }

-    private suspend fun removeHotWalletsFromSDK(walletIds: List<UserWalletId>) {
+    private suspend fun removeHotWalletsFromSDKAndRepos(walletIds: List<UserWalletId>) {
        val hotWalletsToDelete = userWalletsSync()
            .filterIsInstance<UserWallet.Hot>()
            .filter { walletIds.contains(it.walletId) }

-        hotWalletsToDelete.forEach {
-            tangemHotSdk.delete(it.hotWalletId)
+        hotWalletsToDelete.forEach { wallet ->
+            hotWalletRepository.setAccessCodeSkipped(wallet.walletId, false) // In case the wallet is added again
+            tangemHotSdk.delete(wallet.hotWalletId)
        }
    }

@ -508,4 +526,14 @@ internal class DefaultUserWalletsListRepository(

        return lastOrNull()
    }
+
+    private fun trackSignInEvent(userWallet: UserWallet, type: Basic.SignedIn.SignInType) {
+        trackingContextProxy.addContext(userWallet)
+        analyticsEventHandler.send(
+            event = Basic.SignedIn(
+                signInType = type,
+                walletsCount = userWallets.value?.size ?: 0,
+            ),
+        )
+    }
 }
--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/UserWalletEncryptionKeysRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/UserWalletEncryptionKeysRepository.kt
@ -4,6 +4,7 @@ import com.squareup.moshi.JsonAdapter
 import com.squareup.moshi.Moshi
 import com.squareup.moshi.Types
 import com.tangem.common.authentication.storage.AuthenticatedStorage
+import com.tangem.common.core.TangemSdkError
 import com.tangem.common.services.secure.SecureStorage
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.hot.sdk.android.crypto.AESEncryptionProtocol
@ -96,7 +97,13 @@ internal class UserWalletEncryptionKeysRepository(
            StorageKey.UserWalletEncryptionKey(userWalletId).name
        }

-        authenticatedStorage.get(keys).mapNotNull {
+        val result = authenticatedStorage.get(keys)
+
+        if (keys.isNotEmpty() && result.isEmpty()) {
+            throw TangemSdkError.KeystoreInvalidated(Exception("Keys is empty"))
+        }
+
+        result.mapNotNull {
            it.value.decodeToKey()
        }
    }
--- a/app/src/main/java/com/tangem/tap/features/details/redux/DetailsMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/redux/DetailsMiddleware.kt
@ -196,7 +196,7 @@ class DetailsMiddleware {
        }

        private fun enrollBiometrics() {
-            Analytics.send(Settings.AppSettings.ButtonEnableBiometricAuthentication)
+            Analytics.send(Settings.AppSettings.ButtonEnableBiometricAuthentication())
            store.inject(DaggerGraphState::settingsManager).openBiometricSettings()
        }

--- a/app/src/main/java/com/tangem/tap/features/details/ui/appsettings/analytics/AppSettingsItemsAnalyticsSender.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/appsettings/analytics/AppSettingsItemsAnalyticsSender.kt
@ -25,7 +25,7 @@ internal class AppSettingsItemsAnalyticsSender @Inject constructor(

    private fun getEvent(item: AppSettingsScreenState.Item): AnalyticsEvent? {
        return when (item.id) {
-            AppSettingsItemsFactory.ID_ENROLL_BIOMETRICS_CARD -> Settings.AppSettings.EnableBiometrics
+            AppSettingsItemsFactory.ID_ENROLL_BIOMETRICS_CARD -> Settings.AppSettings.EnableBiometrics()
            else -> null
        }
    }
--- a/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/CardSettingsScreen.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/CardSettingsScreen.kt
@ -16,6 +16,7 @@ import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.tooling.preview.Preview
+import com.tangem.core.ui.extensions.resolveReference
 import com.tangem.core.ui.extensions.stringResourceSafe
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
@ -24,6 +25,9 @@ import com.tangem.tap.features.details.ui.common.DetailsMainButton
 import com.tangem.tap.features.details.ui.common.SettingsScreensScaffold
 import com.tangem.wallet.R

+private const val CARD_PLACEHOLDER_SECONDARY_ROTATION = -15f
+private const val CARD_PLACEHOLDER_PRIMARY_ROTATION = -1f
+
@Composable
 internal fun CardSettingsScreen(state: CardSettingsScreenState, modifier: Modifier = Modifier) {
    val isCardReadingNeeded = state.cardDetails == null
@ -42,74 +46,82 @@ internal fun CardSettingsScreen(state: CardSettingsScreenState, modifier: Modifi
    )
 }

-@Suppress("MagicNumber")
@Composable
 private fun CardSettingsReadCard(onScanCardClick: () -> Unit) {
    Column(
-        modifier = Modifier.fillMaxSize(),
+        modifier = Modifier
+            .fillMaxSize()
+            .verticalScroll(rememberScrollState()),
    ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(bottom = TangemTheme.dimens.spacing40)
-                .testTag(DeviceSettingsScreenTestTags.IMAGE_BLOCK),
-        ) {
-            Image(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(
-                        start = TangemTheme.dimens.spacing80,
-                        end = TangemTheme.dimens.spacing80,
-                        top = TangemTheme.dimens.spacing70,
-                    )
-                    .rotate(-15f),
-                painter = painterResource(id = R.drawable.card_placeholder_secondary),
-                contentDescription = null,
-                contentScale = ContentScale.FillWidth,
-            )
-            Image(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(
-                        start = TangemTheme.dimens.spacing60,
-                        end = TangemTheme.dimens.spacing60,
-                    )
-                    .rotate(-1f),
-                painter = painterResource(id = R.drawable.card_placeholder_black),
-                contentDescription = null,
-                contentScale = ContentScale.FillWidth,
-            )
-        }
+        CardPlaceholderImages()
        Spacer(modifier = Modifier.weight(1f))
-        Column(
+        ScanCardContent(onScanCardClick = onScanCardClick)
+    }
+}
+
+@Composable
+private fun CardPlaceholderImages() {
+    Box(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(bottom = TangemTheme.dimens.spacing40)
+            .testTag(DeviceSettingsScreenTestTags.IMAGE_BLOCK),
+    ) {
+        Image(
            modifier = Modifier
                .fillMaxWidth()
                .padding(
-                    start = TangemTheme.dimens.spacing16,
-                    end = TangemTheme.dimens.spacing16,
-                    bottom = TangemTheme.dimens.spacing32,
-                ),
-        ) {
-            Text(
-                text = stringResourceSafe(id = R.string.scan_card_settings_title),
-                color = TangemTheme.colors.text.primary1,
-                style = TangemTheme.typography.h3,
-            )
-            Spacer(modifier = Modifier.size(TangemTheme.dimens.size20))
-            Text(
-                text = stringResourceSafe(id = R.string.scan_card_settings_message),
-                color = TangemTheme.colors.text.secondary,
-                style = TangemTheme.typography.body1,
-                modifier = Modifier
-                    .verticalScroll(rememberScrollState())
-                    .weight(weight = 1f, fill = false),
-            )
-            Spacer(modifier = Modifier.size(TangemTheme.dimens.size32))
-            DetailsMainButton(
-                title = stringResourceSafe(id = R.string.scan_card_settings_button),
-                onClick = onScanCardClick,
-            )
-        }
+                    start = TangemTheme.dimens.spacing80,
+                    end = TangemTheme.dimens.spacing80,
+                    top = TangemTheme.dimens.spacing70,
+                )
+                .rotate(CARD_PLACEHOLDER_SECONDARY_ROTATION),
+            painter = painterResource(id = R.drawable.card_placeholder_secondary),
+            contentDescription = null,
+            contentScale = ContentScale.FillWidth,
+        )
+        Image(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                    start = TangemTheme.dimens.spacing60,
+                    end = TangemTheme.dimens.spacing60,
+                )
+                .rotate(CARD_PLACEHOLDER_PRIMARY_ROTATION),
+            painter = painterResource(id = R.drawable.card_placeholder_black),
+            contentDescription = null,
+            contentScale = ContentScale.FillWidth,
+        )
+    }
+}
+
+@Composable
+private fun ScanCardContent(onScanCardClick: () -> Unit) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(
+                start = TangemTheme.dimens.spacing16,
+                end = TangemTheme.dimens.spacing16,
+                bottom = TangemTheme.dimens.spacing32,
+            ),
+    ) {
+        Text(
+            text = stringResourceSafe(id = R.string.scan_card_settings_title),
+            color = TangemTheme.colors.text.primary1,
+            style = TangemTheme.typography.h3,
+        )
+        Spacer(modifier = Modifier.size(TangemTheme.dimens.size20))
+        Text(
+            text = stringResourceSafe(id = R.string.scan_card_settings_message),
+            color = TangemTheme.colors.text.secondary,
+            style = TangemTheme.typography.body1,
+        )
+        Spacer(modifier = Modifier.size(TangemTheme.dimens.size32))
+        DetailsMainButton(
+            title = stringResourceSafe(id = R.string.scan_card_settings_button),
+            onClick = onScanCardClick,
+        )
    }
 }

--- a/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/CardSettingsScreenState.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/CardSettingsScreenState.kt
@ -1,9 +1,7 @@
 package com.tangem.tap.features.details.ui.cardsettings

-import androidx.annotation.StringRes
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.ReadOnlyComposable
-import com.tangem.core.ui.extensions.stringResourceSafe
+import com.tangem.core.ui.extensions.TextReference
+import com.tangem.core.ui.extensions.wrappedList
 import com.tangem.tap.features.details.redux.SecurityOption
 import com.tangem.tap.features.details.ui.securitymode.toTitleRes
 import com.tangem.wallet.R
@ -32,7 +30,7 @@ internal sealed class CardInfo(

    class SignedHashes(hashes: String) : CardInfo(
        titleRes = TextReference.Res(R.string.details_row_title_signed_hashes),
-        subtitle = TextReference.Res(R.string.details_row_subtitle_signed_hashes_format, hashes),
+        subtitle = TextReference.Res(R.string.details_row_subtitle_signed_hashes_format, wrappedList(hashes)),
    )

    class SecurityMode(securityOption: SecurityOption, clickable: Boolean) : CardInfo(
@ -47,7 +45,7 @@ internal sealed class CardInfo(
        isClickable = true,
    )

-    class AccessCodeRecovery(val isEnabled: Boolean) : CardInfo(
+    class AccessCodeRecovery(isEnabled: Boolean) : CardInfo(
        titleRes = TextReference.Res(R.string.card_settings_access_code_recovery_title),
        subtitle = if (isEnabled) {
            TextReference.Res(R.string.common_enabled)
@ -62,22 +60,4 @@ internal sealed class CardInfo(
        subtitle = description,
        isClickable = true,
    )
-}
-
-// TODO("Remove and use the same from coreUI")
-internal sealed interface TextReference {
-    class Res(@StringRes val id: Int, val formatArgs: List<Any> = emptyList()) : TextReference {
-        constructor(@StringRes id: Int, vararg formatArgs: Any) : this(id, formatArgs.toList())
-    }
-
-    class Str(val value: String) : TextReference
-}
-
-@Composable
-@ReadOnlyComposable
-internal fun TextReference.resolveReference(): String {
-    return when (this) {
-        is TextReference.Res -> stringResourceSafe(this.id, *this.formatArgs.toTypedArray())
-        is TextReference.Str -> this.value
-    }
 }
--- a/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/model/CardSettingsModel.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/model/CardSettingsModel.kt
@ -18,6 +18,7 @@ import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.models.wallet.requireColdWallet
+import com.tangem.domain.pay.repository.OnboardingRepository
 import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.wallets.builder.UserWalletIdBuilder
 import com.tangem.domain.wallets.usecase.GetUserWalletUseCase
@ -54,6 +55,7 @@ internal class CardSettingsModel @Inject constructor(
    private val getUserWalletUseCase: GetUserWalletUseCase,
    private val cardSdkConfigRepository: CardSdkConfigRepository,
    private val settingsRepository: SettingsRepository,
+    private val onboardingRepository: OnboardingRepository,
 ) : Model() {

    private val params = paramsContainer.require<CardSettingsComponent.Params>()
@ -218,15 +220,19 @@ internal class CardSettingsModel @Inject constructor(
        } else {
            val card = scanResponse.card

-            store.dispatchNavigationAction {
-                push(
-                    route = AppRoute.ResetToFactory(
-                        userWalletId = userWalletId,
-                        cardId = card.cardId,
-                        isActiveBackupStatus = card.backupStatus?.isActive == true,
-                        backupCardsCount = scanResponse.getBackupCardsCount() ?: 0,
-                    ),
-                )
+            modelScope.launch {
+                val hasTangemPay = onboardingRepository.checkCustomerWallet(userWalletId).getOrNull() == true
+                store.dispatchNavigationAction {
+                    push(
+                        route = AppRoute.ResetToFactory(
+                            userWalletId = userWalletId,
+                            cardId = card.cardId,
+                            isActiveBackupStatus = card.backupStatus?.isActive == true,
+                            backupCardsCount = scanResponse.getBackupCardsCount() ?: 0,
+                            hasTangemPay = hasTangemPay,
+                        ),
+                    )
+                }
            }
        }
    }
--- a/app/src/main/java/com/tangem/tap/features/details/ui/common/utils/ResetToFactory.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/common/utils/ResetToFactory.kt
@ -1,7 +1,7 @@
 package com.tangem.tap.features.details.ui.common.utils

 import com.tangem.domain.card.CardTypesResolver
-import com.tangem.tap.features.details.ui.cardsettings.TextReference
+import com.tangem.core.ui.extensions.TextReference
 import com.tangem.wallet.R

 internal fun getResetToFactoryDescription(
--- a/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/ResetCardScreen.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/ResetCardScreen.kt
@ -17,11 +17,12 @@ import com.tangem.core.ui.extensions.stringResourceSafe
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
 import com.tangem.core.ui.test.ResetCardScreenTestTags
-import com.tangem.tap.features.details.ui.cardsettings.TextReference
-import com.tangem.tap.features.details.ui.cardsettings.resolveReference
+import com.tangem.core.ui.extensions.TextReference
+import com.tangem.core.ui.extensions.resolveReference
 import com.tangem.tap.features.details.ui.common.DetailsMainButton
 import com.tangem.tap.features.details.ui.common.SettingsScreensScaffold
 import com.tangem.wallet.R
+import kotlinx.collections.immutable.persistentListOf
 import com.tangem.tap.features.details.ui.resetcard.ResetCardScreenState.Dialog as ResetCardDialog

@Composable
@ -114,22 +115,11 @@ private fun Description(text: TextReference) {
@Composable
 private fun Conditions(state: ResetCardScreenState) {
    state.warningsToShow.forEach { warning ->
-        when (warning) {
-            ResetCardScreenState.WarningsToReset.LOST_WALLET_ACCESS -> {
-                ConditionCheckBox(
-                    checkedState = state.isAcceptCondition1Checked,
-                    onCheckedChange = state.onAcceptCondition1ToggleClick,
-                    description = TextReference.Res(R.string.reset_card_to_factory_condition_1),
-                )
-            }
-            ResetCardScreenState.WarningsToReset.LOST_PASSWORD_RESTORE -> {
-                ConditionCheckBox(
-                    checkedState = state.isAcceptCondition2Checked,
-                    onCheckedChange = state.onAcceptCondition2ToggleClick,
-                    description = TextReference.Res(R.string.reset_card_to_factory_condition_2),
-                )
-            }
-        }
+        ConditionCheckBox(
+            checkedState = warning.isChecked,
+            onCheckedChange = { state.onToggleWarning(warning.type) },
+            description = warning.description,
+        )
    }
 }

@ -198,7 +188,7 @@ private fun ResetButton(enabled: Boolean, onResetButtonClick: () -> Unit) {
 }

@Composable
-private fun CommonResetDialog(dialog: ResetCardScreenState.Dialog) {
+private fun CommonResetDialog(dialog: ResetCardDialog) {
    BasicDialog(
        title = stringResourceSafe(dialog.titleResId),
        message = stringResourceSafe(dialog.messageResId),
@ -239,14 +229,16 @@ private fun ResetCardScreenSample(modifier: Modifier = Modifier) {
        ResetCardScreen(
            state = ResetCardScreenState(
                isResetButtonEnabled = true,
-                isResetPasswordButtonShown = false,
-                warningsToShow = listOf(ResetCardScreenState.WarningsToReset.LOST_WALLET_ACCESS),
+                warningsToShow = persistentListOf(
+                    ResetCardScreenState.WarningUM(
+                        isChecked = false,
+                        type = ResetCardScreenState.WarningType.LOST_WALLET_ACCESS,
+                        description = TextReference.Res(id = R.string.reset_card_to_factory_condition_1),
+                    ),
+                ),
                descriptionText = TextReference.Res(R.string.reset_card_with_backup_to_factory_message),
-                isAcceptCondition1Checked = false,
-                isAcceptCondition2Checked = false,
-                onAcceptCondition1ToggleClick = {},
-                onAcceptCondition2ToggleClick = {},
                onResetButtonClick = {},
+                onToggleWarning = {},
                dialog = null,
            ),
            onBackClick = {},
--- a/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/ResetCardScreenState.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/ResetCardScreenState.kt
@ -1,18 +1,15 @@
 package com.tangem.tap.features.details.ui.resetcard

 import androidx.annotation.StringRes
-import com.tangem.tap.features.details.ui.cardsettings.TextReference
+import com.tangem.core.ui.extensions.TextReference
 import com.tangem.wallet.R
+import kotlinx.collections.immutable.ImmutableList

 internal data class ResetCardScreenState(
    val isResetButtonEnabled: Boolean,
    val descriptionText: TextReference,
-    val warningsToShow: List<WarningsToReset>,
-    val isResetPasswordButtonShown: Boolean,
-    val isAcceptCondition1Checked: Boolean,
-    val isAcceptCondition2Checked: Boolean,
-    val onAcceptCondition1ToggleClick: (Boolean) -> Unit,
-    val onAcceptCondition2ToggleClick: (Boolean) -> Unit,
+    val warningsToShow: ImmutableList<WarningUM>,
+    val onToggleWarning: (WarningType) -> Unit,
    val onResetButtonClick: () -> Unit,
    val dialog: Dialog?,
 ) {
@ -58,7 +55,13 @@ internal data class ResetCardScreenState(
        }
    }

-    internal enum class WarningsToReset {
-        LOST_WALLET_ACCESS, LOST_PASSWORD_RESTORE
+    internal data class WarningUM(
+        val isChecked: Boolean,
+        val type: WarningType,
+        val description: TextReference,
+    )
+
+    internal enum class WarningType {
+        LOST_WALLET_ACCESS, LOST_PASSWORD_RESTORE, LOST_TANGEM_PAY
    }
 }
--- a/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/api/ResetCardComponent.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/api/ResetCardComponent.kt
@ -11,6 +11,7 @@ interface ResetCardComponent : ComposableContentComponent {
        val cardId: String,
        val isActiveBackupStatus: Boolean,
        val backupCardsCount: Int,
+        val hasTangemPay: Boolean,
    )

    interface Factory : ComponentFactory<Params, ResetCardComponent>
--- a/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/model/ResetCardModel.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/model/ResetCardModel.kt
@ -8,6 +8,7 @@ import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.decompose.di.ModelScoped
 import com.tangem.core.decompose.model.Model
 import com.tangem.core.decompose.model.ParamsContainer
+import com.tangem.core.ui.extensions.TextReference
 import com.tangem.domain.card.DeleteSavedAccessCodesUseCase
 import com.tangem.domain.card.ResetCardUseCase
 import com.tangem.domain.card.ResetCardUserCodeParams
@ -30,6 +31,9 @@ import com.tangem.tap.features.details.ui.resetcard.api.ResetCardComponent
 import com.tangem.tap.store
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.extensions.DELAY_SDK_DIALOG_CLOSE
+import com.tangem.wallet.R
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.update
@ -82,33 +86,22 @@ internal class ResetCardModel @Inject constructor(
    // TODO: move logic to separate domain entity
    private var resetBackupCardCount = 0

+    private var warningsMap = emptyMap<ResetCardScreenState.WarningType, ResetCardScreenState.WarningUM>()
+
    val screenState: MutableStateFlow<ResetCardScreenState> = MutableStateFlow(
        value = getInitialState(),
    )

    private fun getInitialState(): ResetCardScreenState {
-        val shouldShowResetPasswordButton = shouldShowResetPasswordButton()
-        val warningsToShow = buildList {
-            add(ResetCardScreenState.WarningsToReset.LOST_WALLET_ACCESS)
-
-            if (shouldShowResetPasswordButton) {
-                add(ResetCardScreenState.WarningsToReset.LOST_PASSWORD_RESTORE)
-            }
-        }
-
        return ResetCardScreenState(
            isResetButtonEnabled = false,
            descriptionText = getResetToFactoryDescription(
                isActiveBackupStatus = isActiveBackupPrimaryCard,
                typesResolver = currentCardTypesResolver,
            ),
-            warningsToShow = warningsToShow,
-            isResetPasswordButtonShown = shouldShowResetPasswordButton,
-            isAcceptCondition1Checked = false,
-            isAcceptCondition2Checked = false,
-            onAcceptCondition1ToggleClick = ::toggleFirstCondition,
-            onAcceptCondition2ToggleClick = ::toggleSecondCondition,
+            warningsToShow = buildInitialItems(),
            onResetButtonClick = { showDialog(ResetCardDialog.StartResetDialog) },
+            onToggleWarning = ::toggleCondition,
            dialog = null,
        )
    }
@ -119,28 +112,46 @@ internal class ResetCardModel @Inject constructor(
        return isTangemWallet && isActiveBackupPrimaryCard
    }

-    private fun toggleFirstCondition(isAccepted: Boolean) {
-        screenState.update { prevState ->
-            val isResetButtonEnabled = if (prevState.isResetPasswordButtonShown) {
-                isAccepted && prevState.isAcceptCondition2Checked
-            } else {
-                isAccepted
-            }
+    private fun buildInitialItems(): ImmutableList<ResetCardScreenState.WarningUM> {
+        val shouldShowResetPasswordButton = shouldShowResetPasswordButton()
+        val shouldShowResetTangemPayButton = params.hasTangemPay

-            prevState.copy(
-                isAcceptCondition1Checked = isAccepted,
-                isResetButtonEnabled = isResetButtonEnabled,
-            )
+        val lostWalletUM = ResetCardScreenState.WarningUM(
+            isChecked = false,
+            type = ResetCardScreenState.WarningType.LOST_WALLET_ACCESS,
+            description = TextReference.Res(id = R.string.reset_card_to_factory_condition_1),
+        )
+        val lostPasswordUM = ResetCardScreenState.WarningUM(
+            isChecked = false,
+            type = ResetCardScreenState.WarningType.LOST_PASSWORD_RESTORE,
+            description = TextReference.Res(R.string.reset_card_to_factory_condition_2),
+        )
+        val lostTangemPayUM = ResetCardScreenState.WarningUM(
+            isChecked = false,
+            type = ResetCardScreenState.WarningType.LOST_TANGEM_PAY,
+            description = TextReference.Res(R.string.reset_card_to_factory_condition_3),
+        )
+
+        warningsMap = buildMap {
+            put(ResetCardScreenState.WarningType.LOST_WALLET_ACCESS, lostWalletUM)
+            if (shouldShowResetPasswordButton) {
+                put(ResetCardScreenState.WarningType.LOST_PASSWORD_RESTORE, lostPasswordUM)
+            }
+            if (shouldShowResetTangemPayButton) {
+                put(ResetCardScreenState.WarningType.LOST_TANGEM_PAY, lostTangemPayUM)
+            }
        }
+        return warningsMap.values.toImmutableList()
    }

-    private fun toggleSecondCondition(isAccepted: Boolean) {
+    private fun toggleCondition(type: ResetCardScreenState.WarningType) {
        screenState.update { prevState ->
-            val isResetButtonEnabled = prevState.isAcceptCondition1Checked && isAccepted
-
+            warningsMap[type]?.let { current ->
+                warningsMap = warningsMap + (type to current.copy(isChecked = !current.isChecked))
+            }
            prevState.copy(
-                isAcceptCondition2Checked = isAccepted,
-                isResetButtonEnabled = isResetButtonEnabled,
+                warningsToShow = warningsMap.values.toImmutableList(),
+                isResetButtonEnabled = warningsMap.values.all { it.isChecked },
            )
        }
    }
--- a/app/src/main/java/com/tangem/tap/features/main/MainViewModel.kt
+++ b/app/src/main/java/com/tangem/tap/features/main/MainViewModel.kt
@ -6,7 +6,6 @@ import com.tangem.blockchainsdk.BlockchainSDKFactory
 import com.tangem.common.keyboard.KeyboardValidator
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.analytics.models.event.TechAnalyticsEvent
-import com.tangem.core.analytics.utils.TrackingContextProxy
 import com.tangem.core.decompose.di.GlobalUiMessageSender
 import com.tangem.core.decompose.ui.UiMessageSender
 import com.tangem.core.ui.R
@ -81,7 +80,6 @@ internal class MainViewModel @Inject constructor(
    private val getSelectedWalletUseCase: GetSelectedWalletUseCase,
    private val appRouterConfig: AppRouterConfig,
    private val sellService: SellService,
-    private val trackingContextProxy: TrackingContextProxy,
    getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
 ) : ViewModel() {

@ -143,7 +141,7 @@ internal class MainViewModel @Inject constructor(
                }
            }

-            prepareSelectedWalletFeedback()
+            subscribeToSelectedWallet()

            // await while initial route stack is initialized
            appRouterConfig.initializedState.first { it }
@ -172,12 +170,15 @@ internal class MainViewModel @Inject constructor(
        }
    }

-    private fun prepareSelectedWalletFeedback() {
+    private fun subscribeToSelectedWallet() {
        getSelectedWalletUseCase.invoke()
            .mapLeft { emptyFlow<UserWallet>() }
            .onRight { wallet ->
                wallet.distinctUntilChanged()
-                    .onEach { trackingContextProxy.setContext(it) }
+                    .onEach {
+                        // FIXME Do not remove this call without checking implications !!!
+                        appStateHolder.onUserWalletSelected(it)
+                    }
                    .flowOn(dispatchers.io)
                    .launchIn(viewModelScope)
            }
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/UnfinishedBackupFoundDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/UnfinishedBackupFoundDialog.kt
@ -18,12 +18,12 @@ object UnfinishedBackupFoundDialog {
            setTitle(R.string.common_warning)
            setMessage(R.string.welcome_interrupted_backup_alert_message)
            setPositiveButton(R.string.welcome_interrupted_backup_alert_resume) { _, _ ->
-                Analytics.send(OnboardingEvent.Backup.ResumeInterruptedBackup)
+                Analytics.send(OnboardingEvent.Backup.ResumeInterruptedBackup())
                store.dispatch(GlobalAction.HideDialog)
                store.dispatch(BackupAction.ResumeFoundUnfinishedBackup(scanResponse))
            }
            setNegativeButton(R.string.welcome_interrupted_backup_alert_discard) { _, _ ->
-                Analytics.send(OnboardingEvent.Backup.CancelInterruptedBackup)
+                Analytics.send(OnboardingEvent.Backup.CancelInterruptedBackup())
                store.dispatch(GlobalAction.HideDialog)
                store.dispatch(GlobalAction.ShowDialog(BackupDialog.ConfirmDiscardingBackup(scanResponse)))
            }
--- a/app/src/main/java/com/tangem/tap/features/root/RootDetectedWarningComponent.kt
+++ b/app/src/main/java/com/tangem/tap/features/root/RootDetectedWarningComponent.kt
@ -0,0 +1,68 @@
+package com.tangem.tap.features.root
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.arkivanov.essenty.instancekeeper.getOrCreateSimple
+import com.tangem.core.decompose.context.AppComponentContext
+import com.tangem.core.decompose.factory.ComponentFactory
+import com.tangem.core.ui.components.DialogFullScreen
+import com.tangem.core.ui.decompose.ComposableContentComponent
+import com.tangem.domain.settings.repositories.SettingsRepository
+import com.tangem.security.DeviceSecurityInfoProvider
+import com.tangem.security.isSecurityExposed
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+
+@Suppress("UnusedPrivateProperty")
+class RootDetectedWarningComponent @AssistedInject constructor(
+    @Assisted appComponentContext: AppComponentContext,
+    @Assisted params: Unit,
+    private val securityInfoProvider: DeviceSecurityInfoProvider,
+    private val settingsRepository: SettingsRepository,
+) : AppComponentContext by appComponentContext, ComposableContentComponent {
+
+    private val isShown = instanceKeeper.getOrCreateSimple { MutableStateFlow(false) }
+
+    suspend fun tryToShowWarningAndWaitContinuation() {
+        if (isShown.value) return
+
+        if (settingsRepository.isRootDetectedWarningShown().not() && securityInfoProvider.isSecurityExposed()) {
+            isShown.value = true
+        }
+
+        isShown.first { it == false } // Wait until the warning is dismissed
+    }
+
+    @Composable
+    override fun Content(modifier: Modifier) {
+        val isShownState by isShown.collectAsStateWithLifecycle()
+
+        if (isShownState) {
+            DialogFullScreen(onDismissRequest = {}) {
+                RootDetectedWarningContent(
+                    modifier = modifier,
+                    onContinueClick = remember(this) { ::onContinueClick },
+                )
+            }
+        }
+    }
+
+    private fun onContinueClick() {
+        componentScope.launch {
+            settingsRepository.setRootDetectedWarningShown(true)
+            isShown.value = false
+        }
+    }
+
+    @AssistedFactory
+    interface Factory : ComponentFactory<Unit, RootDetectedWarningComponent> {
+        override fun create(context: AppComponentContext, params: Unit): RootDetectedWarningComponent
+    }
+}
--- a/app/src/main/java/com/tangem/tap/features/root/RootDetectedWarningContent.kt
+++ b/app/src/main/java/com/tangem/tap/features/root/RootDetectedWarningContent.kt
@ -0,0 +1,93 @@
+package com.tangem.tap.features.root
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.tangem.core.ui.components.PrimaryButton
+import com.tangem.core.ui.components.SpacerH
+import com.tangem.core.ui.components.icons.HighlightedIcon
+import com.tangem.core.ui.extensions.stringResourceSafe
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.core.ui.res.TangemThemePreview
+import com.tangem.wallet.R
+
+@Composable
+internal fun RootDetectedWarningContent(modifier: Modifier = Modifier, onContinueClick: () -> Unit = {}) {
+    Column(
+        modifier = modifier
+            .fillMaxSize()
+            .background(TangemTheme.colors.background.primary)
+            .statusBarsPadding()
+            .padding(horizontal = 16.dp),
+    ) {
+        Box(
+            modifier = Modifier.weight(1f),
+            contentAlignment = Alignment.Center,
+        ) {
+            InfoBlock(
+                modifier = Modifier.padding(top = 48.dp, bottom = 24.dp),
+            )
+        }
+
+        PrimaryButton(
+            modifier = Modifier
+                .navigationBarsPadding()
+                .padding(bottom = 16.dp)
+                .fillMaxWidth(),
+            text = stringResourceSafe(R.string.common_understand_continue),
+            onClick = onContinueClick,
+        )
+    }
+}
+
+@Composable
+private fun InfoBlock(modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier,
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        HighlightedIcon(
+            icon = R.drawable.ic_alert_circle_24,
+            iconTint = TangemTheme.colors.icon.warning,
+        )
+
+        SpacerH(20.dp)
+
+        Text(
+            text = stringResourceSafe(R.string.root_detected_warning_title),
+            style = TangemTheme.typography.h2,
+            color = TangemTheme.colors.text.primary1,
+            textAlign = TextAlign.Center,
+        )
+
+        SpacerH(12.dp)
+
+        Text(
+            modifier = Modifier.padding(horizontal = 24.dp),
+            text = stringResourceSafe(R.string.root_detected_warning_description),
+            style = TangemTheme.typography.body1,
+            color = TangemTheme.colors.text.secondary,
+            textAlign = TextAlign.Center,
+        )
+    }
+}
+
+@Preview
+@Composable
+private fun Preview() {
+    TangemThemePreview {
+        RootDetectedWarningContent()
+    }
+}
--- a/app/src/main/java/com/tangem/tap/features/welcome/model/WelcomeModel.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/model/WelcomeModel.kt
@ -10,7 +10,7 @@ import com.tangem.core.navigation.finisher.AppFinisher
 import com.tangem.domain.wallets.legacy.UserWalletsListError
 import com.tangem.tap.common.analytics.events.SignIn
 import com.tangem.tap.common.redux.global.GlobalAction
-import com.tangem.tap.features.details.ui.cardsettings.TextReference
+import com.tangem.core.ui.extensions.TextReference
 import com.tangem.tap.features.welcome.component.WelcomeComponent
 import com.tangem.tap.features.welcome.redux.WelcomeAction
 import com.tangem.tap.features.welcome.redux.WelcomeState
@ -45,7 +45,6 @@ internal class WelcomeModel @Inject constructor(
    init {
        subscribeToStoreChanges()
        initGlobalState()
-        analyticsEventsHandler.send(SignIn.ScreenOpened())

        val welcomeAction = when (params.launchMode) {
            is InitScreenLaunchMode.WithCardScan -> WelcomeAction.ProceedWithCard
--- a/app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeMiddleware.kt
@ -58,7 +58,7 @@ internal class WelcomeMiddleware {
            .doOnSuccess { selectedUserWallet ->
                sendSignedInAnalyticsEvent(
                    userWallet = selectedUserWallet,
-                    signInType = Basic.SignedIn.SignInType.Biometric,
+                    signInType = Basic.SignedInLegacy.SignInType.Biometric,
                )

                store.dispatchNavigationAction { replaceAll(AppRoute.Wallet) }
@ -80,7 +80,7 @@ internal class WelcomeMiddleware {
                    store.dispatchWithMain(WelcomeAction.ProceedWithCard.Error(error))
                }
                .doOnSuccess {
-                    sendSignedInAnalyticsEvent(userWallet, signInType = Basic.SignedIn.SignInType.Card)
+                    sendSignedInAnalyticsEvent(userWallet, signInType = Basic.SignedInLegacy.SignInType.Card)

                    store.dispatchNavigationAction { replaceAll(AppRoute.Wallet) }
                    store.dispatchWithMain(WelcomeAction.ProceedWithCard.Success)
@ -89,9 +89,7 @@ internal class WelcomeMiddleware {
        }
    }

-    private fun sendSignedInAnalyticsEvent(userWallet: UserWallet, signInType: Basic.SignedIn.SignInType) {
-        // TODO [REDACTED_TASK_KEY] [Hot Wallet] Analytics
-
+    private fun sendSignedInAnalyticsEvent(userWallet: UserWallet, signInType: Basic.SignedInLegacy.SignInType) {
        if (userWallet !is UserWallet.Cold) {
            return
        }
@ -108,7 +106,7 @@ internal class WelcomeMiddleware {
            val userWalletsListManager = store.inject(DaggerGraphState::generalUserWalletsListManager)

            Analytics.send(
-                event = Basic.SignedIn(
+                event = Basic.SignedInLegacy(
                    currency = currency,
                    batch = scanResponse.card.batchId,
                    signInType = signInType,
--- a/app/src/main/java/com/tangem/tap/features/welcome/ui/WelcomeScreenState.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/ui/WelcomeScreenState.kt
@ -1,6 +1,6 @@
 package com.tangem.tap.features.welcome.ui

-import com.tangem.tap.features.details.ui.cardsettings.TextReference
+import com.tangem.core.ui.extensions.TextReference
 import com.tangem.tap.features.welcome.ui.model.WarningModel

 internal data class WelcomeScreenState(
--- a/app/src/main/java/com/tangem/tap/features/welcome/ui/components/WelcomeScreen.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/ui/components/WelcomeScreen.kt
@ -18,8 +18,8 @@ import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import androidx.compose.ui.unit.dp
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
-import com.tangem.tap.features.details.ui.cardsettings.TextReference
-import com.tangem.tap.features.details.ui.cardsettings.resolveReference
+import com.tangem.core.ui.extensions.TextReference
+import com.tangem.core.ui.extensions.resolveReference
 import com.tangem.tap.features.welcome.component.WelcomeComponent
 import com.tangem.tap.features.welcome.component.impl.PreviewWelcomeComponent
 import com.tangem.tap.features.welcome.ui.WelcomeScreenState
--- a/app/src/main/java/com/tangem/tap/network/auth/DefaultAuthProvider.kt
+++ b/app/src/main/java/com/tangem/tap/network/auth/DefaultAuthProvider.kt
@ -51,7 +51,9 @@ internal class DefaultAuthProvider(
                ApiEnvironment.DEV_2,
                ApiEnvironment.DEV_3,
                -> environmentConfigStorage.getConfigSync().tangemApiKeyDev
-                ApiEnvironment.STAGE -> environmentConfigStorage.getConfigSync().tangemApiKeyStage
+                ApiEnvironment.STAGE_2,
+                ApiEnvironment.STAGE,
+                -> environmentConfigStorage.getConfigSync().tangemApiKeyStage
                ApiEnvironment.PROD -> environmentConfigStorage.getConfigSync().tangemApiKey
            } ?: error("No tangem tech api config provided")
        }
--- a/app/src/main/java/com/tangem/tap/network/auth/DefaultP2PEthPoolAuthProvider.kt
+++ b/app/src/main/java/com/tangem/tap/network/auth/DefaultP2PEthPoolAuthProvider.kt
@ -1,6 +1,7 @@
 package com.tangem.tap.network.auth

 import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
+import com.tangem.domain.staking.model.ethpool.P2PStakingConfig
 import com.tangem.lib.auth.P2PEthPoolAuthProvider

 internal class DefaultP2PEthPoolAuthProvider(
@ -11,6 +12,6 @@ internal class DefaultP2PEthPoolAuthProvider(
        val keys = environmentConfigStorage.getConfigSync().p2pApiKey
            ?: error("No P2P api keys provided")

-        return keys.mainnet
+        return if (P2PStakingConfig.USE_TESTNET) keys.hoodi else keys.mainnet
    }
 }
--- a/app/src/main/java/com/tangem/tap/routing/RootContent.kt
+++ b/app/src/main/java/com/tangem/tap/routing/RootContent.kt
@ -47,6 +47,7 @@ internal fun RootContent(
    modifier: Modifier = Modifier,
    wcContent: @Composable (modifier: Modifier) -> Unit,
    hotAccessCodeContent: @Composable (modifier: Modifier) -> Unit,
+    rootDetectedWarningContent: @Composable (modifier: Modifier) -> Unit,
 ) {
    val context = LocalContext.current

@ -82,6 +83,8 @@ internal fun RootContent(

                hotAccessCodeContent(Modifier.fillMaxSize())

+                rootDetectedWarningContent(Modifier.fillMaxSize())
+
                TangemSnackbarHost(
                    modifier = Modifier
                        .align(Alignment.BottomCenter)
--- a/app/src/main/java/com/tangem/tap/routing/component/impl/DefaultRoutingComponent.kt
+++ b/app/src/main/java/com/tangem/tap/routing/component/impl/DefaultRoutingComponent.kt
@ -11,8 +11,11 @@ import com.arkivanov.essenty.lifecycle.subscribe
 import com.google.android.material.snackbar.Snackbar
 import com.tangem.common.routing.AppRoute
 import com.tangem.common.routing.entity.InitScreenLaunchMode
+import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.analytics.api.AnalyticsExceptionHandler
+import com.tangem.core.analytics.models.Basic
 import com.tangem.core.analytics.models.ExceptionAnalyticsEvent
+import com.tangem.core.analytics.utils.TrackingContextProxy
 import com.tangem.core.decompose.context.AppComponentContext
 import com.tangem.core.decompose.context.child
 import com.tangem.core.decompose.context.childByContext
@ -26,6 +29,7 @@ import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.models.wallet.isLocked
 import com.tangem.domain.onboarding.repository.OnboardingRepository
 import com.tangem.features.hotwallet.HotAccessCodeRequestComponent
+import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.features.hotwallet.accesscoderequest.proxy.HotWalletPasswordRequesterProxy
 import com.tangem.features.walletconnect.components.WcRoutingComponent
 import com.tangem.hot.sdk.TangemHotSdk
@ -34,6 +38,7 @@ import com.tangem.tap.common.SnackbarHandler
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.features.hot.TangemHotSDKProxy
 import com.tangem.tap.features.onboarding.products.wallet.redux.BackupDialog
+import com.tangem.tap.features.root.RootDetectedWarningComponent
 import com.tangem.tap.routing.RootContent
 import com.tangem.tap.routing.component.RoutingComponent
 import com.tangem.tap.routing.component.RoutingComponent.Child
@ -60,9 +65,13 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
    private val tangemHotSDKProxy: TangemHotSDKProxy,
    private val hotAccessCodeRequestComponentFactory: HotAccessCodeRequestComponent.Factory,
    private val hotAccessCodeRequesterProxy: HotWalletPasswordRequesterProxy,
+    private val rootDetectedWarningComponentFactory: RootDetectedWarningComponent.Factory,
    private val userWalletsListRepository: UserWalletsListRepository,
    private val cardRepository: CardRepository,
    private val onboardingRepository: OnboardingRepository,
+    private val hotWalletFeatureToggles: HotWalletFeatureToggles,
+    private val trackingContextProxy: TrackingContextProxy,
+    private val analyticsEventHandler: AnalyticsEventHandler,
    private val analyticsExceptionHandler: AnalyticsExceptionHandler,
 ) : RoutingComponent,
    AppComponentContext by context,
@ -78,6 +87,11 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
            .create(child("hotAccessCodeRequestComponent"), Unit)
    }

+    private val rootDetectedWarningComponent: RootDetectedWarningComponent by lazy {
+        rootDetectedWarningComponentFactory
+            .create(child("rootDetectedWarningComponent"), Unit)
+    }
+
    private val navigation = navigationProvider.getOrCreateTyped<AppRoute>()

    private val stack: Value<ChildStack<AppRoute, Child>> = childStack(
@ -127,6 +141,7 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
    private fun initializeInitialNavigation() {
        if (initialStack.isNullOrEmpty()) {
            componentScope.launch {
+                rootDetectedWarningComponent.tryToShowWarningAndWaitContinuation()
                val initialRoute = resolveInitialRoute()
                router.replaceAll(initialRoute)
            }
@ -151,6 +166,7 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
                )
            }
            else -> {
+                trackSignInEvent()
                AppRoute.Wallet
            }
        }.also {
@ -169,6 +185,7 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
            modifier = modifier,
            wcContent = { wcRoutingComponent.Content(it) },
            hotAccessCodeContent = { hotAccessCodeRequestComponent.Content(it) },
+            rootDetectedWarningContent = { rootDetectedWarningComponent.Content(it) },
        )
    }

@ -235,4 +252,18 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
            store.dispatch(GlobalAction.ShowDialog(BackupDialog.UnfinishedBackupFound(onboardingScanResponse)))
        }
    }
+
+    private suspend fun trackSignInEvent() {
+        if (hotWalletFeatureToggles.isHotWalletEnabled) {
+            val userWallets = userWalletsListRepository.userWalletsSync()
+            val selectedWallet = userWalletsListRepository.selectedUserWalletSync() ?: return
+            trackingContextProxy.addContext(selectedWallet)
+            analyticsEventHandler.send(
+                event = Basic.SignedIn(
+                    signInType = Basic.SignedIn.SignInType.NoSecurity,
+                    walletsCount = userWallets.size,
+                ),
+            )
+        }
+    }
 }
--- a/app/src/main/java/com/tangem/tap/routing/transitions/RoutingTransitionAnimationFactory.kt
+++ b/app/src/main/java/com/tangem/tap/routing/transitions/RoutingTransitionAnimationFactory.kt
@ -14,7 +14,6 @@ object RoutingTransitionAnimationFactory {
    @Suppress("MagicNumber")
    fun create(appRoute: AppRoute): StackAnimator {
        return when (appRoute) {
-            is AppRoute.Onboarding,
            is AppRoute.Welcome,
            is AppRoute.Home,
            -> fade(tween(400)).plus(scale(tween(400)))
--- a/app/src/main/java/com/tangem/tap/routing/utils/ChildFactory.kt
+++ b/app/src/main/java/com/tangem/tap/routing/utils/ChildFactory.kt
@ -40,6 +40,8 @@ import com.tangem.features.tangempay.components.TangemPayDetailsContainerCompone
 import com.tangem.features.tangempay.components.TangemPayOnboardingComponent
 import com.tangem.features.tangempay.components.TangemPayOnboardingComponent.Params.ContinueOnboarding
 import com.tangem.features.tangempay.components.TangemPayOnboardingComponent.Params.Deeplink
+import com.tangem.features.tangempay.components.TangemPayOnboardingComponent.Params.FromBannerOnMain
+import com.tangem.features.tangempay.components.TangemPayOnboardingComponent.Params.FromBannerInSettings
 import com.tangem.features.tokendetails.TokenDetailsComponent
 import com.tangem.features.wallet.WalletEntryComponent
 import com.tangem.features.walletconnect.components.WalletConnectEntryComponent
@ -422,6 +424,7 @@ internal class ChildFactory @Inject constructor(
                        cardId = route.cardId,
                        isActiveBackupStatus = route.isActiveBackupStatus,
                        backupCardsCount = route.backupCardsCount,
+                        hasTangemPay = route.hasTangemPay,
                    ),
                    componentFactory = resetCardComponentFactory,
                )
@ -529,7 +532,9 @@ internal class ChildFactory @Inject constructor(
            is AppRoute.CreateMobileWallet -> {
                createComponentChild(
                    context = context,
-                    params = Unit,
+                    params = CreateMobileWalletComponent.Params(
+                        source = route.source,
+                    ),
                    componentFactory = createMobileWalletComponentFactory,
                )
            }
@ -565,7 +570,7 @@ internal class ChildFactory @Inject constructor(
                    params = CreateWalletBackupComponent.Params(
                        userWalletId = route.userWalletId,
                        isUpgradeFlow = route.isUpgradeFlow,
-                        shouldSetAccessCode = route.setAccessCode,
+                        shouldSetAccessCode = route.shouldSetAccessCode,
                        analyticsSource = route.analyticsSource,
                        analyticsAction = route.analyticsAction,
                    ),
@ -665,6 +670,9 @@ internal class ChildFactory @Inject constructor(
                        )
                        is AppRoute.TangemPayOnboarding.Mode.Deeplink -> Deeplink(
                            deeplink = mode.deeplink,
+                        )
+                        is AppRoute.TangemPayOnboarding.Mode.FromBannerInSettings -> FromBannerInSettings
+                        is AppRoute.TangemPayOnboarding.Mode.FromBannerOnMain -> FromBannerOnMain(
                            userWalletId = mode.userWalletId,
                        )
                    },