Updated on 2026-08-14

app/build.gradle.kts

@@ -167,6 +167,7 @@ dependencies {
     implementation(projects.domain.blockaid)
     implementation(projects.domain.hotWallet)
     implementation(projects.domain.news)
+    implementation(projects.domain.earn)
 
     implementation(projects.common)
     implementation(projects.common.routing)
@@ -220,6 +221,7 @@ dependencies {
     implementation(projects.data.yieldSupply)
     implementation(projects.data.hotWallet)
     implementation(projects.data.news)
+    implementation(projects.data.earn)
 
     /** Features */
     implementation(projects.features.referral.impl)

app/src/androidTest/kotlin/com/tangem/common/BaseTestCase.kt

@@ -84,6 +84,7 @@ abstract class BaseTestCase : TestCase(
      * – and only after that the activity should be launched.
      */
     protected fun setupHooks(
+        additionalBeforeAppLaunchSection: () -> Unit = {},
         additionalBeforeSection: () -> Unit = {},
         additionalAfterSection: () -> Unit = {},
     ) = before {
@@ -91,6 +92,7 @@ abstract class BaseTestCase : TestCase(
         // Setup WireMock redirect for CI with local WireMock instances
         val wiremockUrl = InstrumentationRegistry.getArguments().getString(WIREMOCK_BASE_URL_ARG)
         WireMockRedirectInterceptor.overriddenBaseUrl = wiremockUrl
+        additionalBeforeAppLaunchSection()
         hiltRule.inject()
         runBlocking {
             appPreferencesStore.editData { mutablePreferences ->
@@ -147,7 +149,9 @@ abstract class BaseTestCase : TestCase(
                 "NEW_ONRAMP_MAIN_ENABLED" to true,
                 "HOT_WALLET_ENABLED" to true,
                 "YIELD_SUPPLY_FEATURE_ENABLED" to true,
-                "ACCOUNTS_FEATURE_ENABLED" to true
+                "ACCOUNTS_FEATURE_ENABLED" to true,
+                "FEED_ENABLED" to true,
+                "GASLESS_TRANSACTIONS_ENABLED" to true,
             )
         )
     }

app/src/androidTest/kotlin/com/tangem/common/extensions/CustomAssertsExt.kt

@@ -1,5 +1,9 @@
 package com.tangem.common.extensions
 
+import androidx.compose.ui.test.SemanticsMatcher
+import com.tangem.common.utils.LazyListItemNode
+import com.tangem.core.ui.components.buttons.actions.HasBadgeKey
+import com.tangem.core.ui.components.buttons.actions.IsDimmedKey
 import io.github.kakaocup.compose.node.element.KNode
 
 fun assertElementDoesNotExist(
@@ -22,4 +26,20 @@ fun assertElementDoesNotExist(
             throw e
         }
     }
+}
+
+fun Any.assertIsDimmed(expectedValue: Boolean = true) {
+    val matcher = SemanticsMatcher.expectValue(IsDimmedKey, expectedValue)
+    when (this) {
+        is KNode, is LazyListItemNode -> this.assert(matcher)
+        else -> throw IllegalArgumentException("Unsupported type: ${this::class}")
+    }
+}
+
+fun Any.assertHasBadge(expectedValue: Boolean = true) {
+    val matcher = SemanticsMatcher.expectValue(HasBadgeKey, expectedValue)
+    when (this) {
+        is KNode, is LazyListItemNode -> this.assert(matcher)
+        else -> throw IllegalArgumentException("Unsupported type: ${this::class}")
+    }
 }

app/src/androidTest/kotlin/com/tangem/common/extensions/KNode.kt

@@ -1,5 +1,6 @@
 package com.tangem.common.extensions
 
+import androidx.compose.ui.test.hasText
 import io.github.kakaocup.compose.node.element.KNode
 
 fun KNode.clickWithAssertion() {
@@ -7,3 +8,13 @@ fun KNode.clickWithAssertion() {
     performClick()
 }
 
+fun KNode.assertTextContainsSafe(
+    text: String,
+    substring: Boolean = false,
+    ignoreCase: Boolean = false,
+) {
+    assert(
+        hasText(text = text, substring = substring, ignoreCase = ignoreCase)
+    )
+}
+

app/src/androidTest/kotlin/com/tangem/common/extensions/UiDeviceExt.kt

@@ -2,6 +2,7 @@ package com.tangem.common.extensions
 
 import androidx.test.uiautomator.By
 import com.tangem.common.BaseTestCase
+import com.tangem.common.constants.TestConstants.WAIT_UNTIL_TIMEOUT_LONG
 import com.tangem.wallet.R
 import io.github.kakaocup.kakao.common.utilities.getResourceString
 
@@ -74,8 +75,17 @@ fun BaseTestCase.stopApp(packageName: String) {
 }
 
 fun BaseTestCase.launchApp(packageName: String) {
-    device.apps.waitForAppLaunchAndReady(packageName = packageName)
     device.apps.launch(packageName)
+    device.apps.waitForAppLaunchAndReady(packageName = packageName)
+}
+
+fun BaseTestCase.restartApp(packageName: String) {
+    device.uiDevice.pressHome()
+    device.apps.kill(packageName)
+    waitForIdle()
+    device.apps.launch(packageName)
+    device.apps.waitForAppLaunchAndReady(timeout = WAIT_UNTIL_TIMEOUT_LONG, packageName = packageName)
+    waitForIdle()
 }
 
 enum class SwipeDirection {

app/src/androidTest/kotlin/com/tangem/scenarios/BaseScenarios.kt

@@ -65,8 +65,8 @@ fun BaseTestCase.openMainScreen(
     step("Assert 'Main' screen is displayed") {
         onMainScreen { screenContainer.assertIsDisplayed() }
     }
-    step("Click on 'Market Tooltip' screen") {
-        onMarketsTooltipScreen { contentContainer.clickWithAssertion() }
+    step("Dismiss Market Tooltip by clicking close button") {
+        onMarketsTooltipScreen { closeButton.clickWithAssertion() }
     }
 }
 

app/src/androidTest/kotlin/com/tangem/scenarios/MarketsScenarios.kt

@@ -0,0 +1,26 @@
+package com.tangem.scenarios
+
+import com.tangem.common.BaseTestCase
+import com.tangem.common.extensions.clickWithAssertion
+import com.tangem.screens.onMainScreen
+import com.tangem.screens.onMarketsScreen
+import com.tangem.screens.onMarketsTokenDetailsScreen
+import io.qameta.allure.kotlin.Allure.step
+
+fun BaseTestCase.openMarketTokenDetailsScreen(blockchainName: String, tokenName: String) {
+    step("Open 'Markets' screen") {
+        onMainScreen { searchThroughMarketPlaceholder.performClick() }
+        waitForIdle()
+    }
+    step("Click on 'Search' placeholder") {
+        onMarketsScreen { searchThroughMarketPlaceholder.performClick() }
+    }
+    step("Click on $blockchainName blockchain") {
+        waitForIdle()
+        onMarketsScreen { tokenWithTitle(blockchainName).clickWithAssertion() }
+    }
+    step("Click on $tokenName token") {
+        waitForIdle()
+        onMarketsTokenDetailsScreen { tokenWithTitle(tokenName).clickWithAssertion() }
+    }
+}

app/src/androidTest/kotlin/com/tangem/scenarios/SwapScenarios.kt

@@ -0,0 +1,180 @@
+package com.tangem.scenarios
+
+import androidx.compose.ui.test.click
+import com.tangem.common.BaseTestCase
+import com.tangem.common.extensions.clickWithAssertion
+import com.tangem.screens.*
+import io.github.kakaocup.kakao.common.utilities.getResourceString
+import io.qameta.allure.kotlin.Allure.step
+import com.tangem.common.ui.R as CommonUiR
+
+private val firstStoryIndex = 0
+private val firstStoryTitle = getResourceString(CommonUiR.string.swap_story_first_title)
+private val firstStorySubtitle = getResourceString(CommonUiR.string.swap_story_first_subtitle)
+private val secondStoryIndex = 1
+private val secondStoryTitle = getResourceString(CommonUiR.string.swap_story_second_title)
+private val secondStorySubtitle = getResourceString(CommonUiR.string.swap_story_second_subtitle)
+private val thirdStoryIndex = 2
+private val thirdStoryTitle = getResourceString(CommonUiR.string.swap_story_third_title)
+private val thirdStorySubtitle = getResourceString(CommonUiR.string.swap_story_third_subtitle)
+private val forthStoryIndex = 3
+private val forthStoryTitle = getResourceString(CommonUiR.string.swap_story_forth_title)
+private val forthStorySubtitle = getResourceString(CommonUiR.string.swap_story_forth_subtitle)
+private val fifthStoryIndex = 4
+private val fifthStoryTitle = getResourceString(CommonUiR.string.swap_story_fifth_title)
+private val fifthStorySubtitle = getResourceString(CommonUiR.string.swap_story_fifth_subtitle)
+
+fun BaseTestCase.openSwapScreen(
+    from: SwapEntryPoint,
+    storiesExist: Boolean = true,
+) {
+    when (from) {
+        SwapEntryPoint.MainScreen -> step("Click on 'Swap' button on 'Main' screen") {
+            onMainScreen { swapButton.performClick() }
+        }
+
+        SwapEntryPoint.TokenDetails -> step("Click on 'Swap' button on 'Token details' screen") {
+            onTokenDetailsScreen { swapButton().performClick() }
+        }
+
+        SwapEntryPoint.MarketsTokenDetails -> step("Click on 'Swap' button on 'Markets' token details screen") {
+            onMarketsTokenDetailsScreen { swapPortfolioQuickActionButton.performClick() }
+        }
+
+        SwapEntryPoint.TokenActionsBottomSheet -> step("Click on 'Swap' button on token actions bottom sheet") {
+            onTokenActionsBottomSheet { swapButton.performClick() }
+        }
+    }
+
+    if (storiesExist) {
+        step("Close 'Stories' screen") {
+            onSwapStoriesScreen { closeButton.clickWithAssertion() }
+        }
+    } else {
+        step("Assert 'Stories' screen is not displayed") {
+            onSwapStoriesScreen { container.assertDoesNotExist() }
+        }
+    }
+
+    step("Assert 'Swap' screen title is displayed") {
+        onSwapTokenScreen { title.assertIsDisplayed() }
+    }
+}
+
+fun BaseTestCase.checkStoriesContent(
+    storyIndex: Int,
+    storyTitle: String,
+    storySubtitle: String,
+    ) {
+    step("Assert 'Close' button is displayed") {
+        onSwapStoriesScreen { closeButton.assertIsDisplayed() }
+    }
+    step("Assert progress bar item №${storyIndex + 1} is displayed") {
+        onSwapStoriesScreen { progressBarItem(storyIndex).assertIsDisplayed() }
+    }
+    step("Assert story title is $storyTitle") {
+        onSwapStoriesScreen { title.assertTextContains(storyTitle) }
+    }
+    step("Assert story subtitle is $storySubtitle") {
+        onSwapStoriesScreen { subtitle.assertTextContains(storySubtitle) }
+    }
+}
+
+fun BaseTestCase.checkStoriesChanges() {
+    step("Check title and subtitle for story №${firstStoryIndex + 1}") {
+        checkStoriesContent(
+            storyIndex = firstStoryIndex,
+            storyTitle = firstStoryTitle,
+            storySubtitle = firstStorySubtitle
+        )
+    }
+    step("Click on right side") {
+        onSwapStoriesScreen { container.performTouchInput { click(centerRight) } }
+    }
+    step("Check title and subtitle for story №${secondStoryIndex + 1}") {
+        checkStoriesContent(
+            storyIndex = secondStoryIndex,
+            storyTitle = secondStoryTitle,
+            storySubtitle = secondStorySubtitle
+        )
+    }
+    step("Click on right side") {
+        onSwapStoriesScreen { container.performTouchInput { click(centerRight) } }
+    }
+    step("Check title and subtitle for story №${thirdStoryIndex + 1}") {
+        checkStoriesContent(
+            storyIndex = thirdStoryIndex,
+            storyTitle = thirdStoryTitle,
+            storySubtitle = thirdStorySubtitle
+        )
+    }
+    step("Click on right side") {
+        onSwapStoriesScreen { container.performTouchInput { click(centerRight) } }
+    }
+    step("Check title and subtitle for story №${forthStoryIndex + 1}") {
+        checkStoriesContent(
+            storyIndex = forthStoryIndex,
+            storyTitle = forthStoryTitle,
+            storySubtitle = forthStorySubtitle
+        )
+    }
+    step("Click on right side") {
+        onSwapStoriesScreen { container.performTouchInput { click(centerRight) } }
+    }
+    step("Check title and subtitle for story №${fifthStoryIndex + 1}") {
+        checkStoriesContent(
+            storyIndex = fifthStoryIndex,
+            storyTitle = fifthStoryTitle,
+            storySubtitle = fifthStorySubtitle
+        )
+    }
+    step("Click on left side") {
+        onSwapStoriesScreen { container.performTouchInput { click(centerLeft) } }
+    }
+    step("Check title and subtitle for story №${forthStoryIndex + 1}") {
+        checkStoriesContent(
+            storyIndex = forthStoryIndex,
+            storyTitle = forthStoryTitle,
+            storySubtitle = forthStorySubtitle
+        )
+    }
+    step("Click on left side") {
+        onSwapStoriesScreen { container.performTouchInput { click(centerLeft) } }
+    }
+    step("Check title and subtitle for story №${thirdStoryIndex + 1}") {
+        checkStoriesContent(
+            storyIndex = thirdStoryIndex,
+            storyTitle = thirdStoryTitle,
+            storySubtitle = thirdStorySubtitle
+        )
+    }
+    step("Click on left side") {
+        onSwapStoriesScreen { container.performTouchInput { click(centerLeft) } }
+    }
+    step("Check title and subtitle for story №${secondStoryIndex + 1}") {
+        checkStoriesContent(
+            storyIndex = secondStoryIndex,
+            storyTitle = secondStoryTitle,
+            storySubtitle = secondStorySubtitle
+        )
+    }
+    step("Click on left side") {
+        onSwapStoriesScreen { container.performTouchInput { click(centerLeft) } }
+    }
+    step("Check title and subtitle for story №${firstStoryIndex + 1}") {
+        checkStoriesContent(
+            storyIndex = firstStoryIndex,
+            storyTitle = firstStoryTitle,
+            storySubtitle = firstStorySubtitle
+        )
+    }
+}
+
+sealed class SwapEntryPoint {
+    object MainScreen : SwapEntryPoint()
+    object TokenDetails : SwapEntryPoint()
+    object MarketsTokenDetails : SwapEntryPoint()
+    object TokenActionsBottomSheet : SwapEntryPoint()
+}
+
+

app/src/androidTest/kotlin/com/tangem/screens/DialogPageObject.kt

@@ -45,6 +45,16 @@ class DialogPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
         hasText(getResourceString(R.string.common_continue))
     }
 
+    val addButton: KNode = child {
+        hasTestTag(BaseButtonTestTags.BUTTON)
+        hasText(getResourceString(R.string.common_add))
+    }
+
+    val laterButton: KNode = child {
+        hasTestTag(BaseButtonTestTags.BUTTON)
+        hasText(getResourceString(R.string.common_later))
+    }
+
     val okButton: KNode = child {
         hasTestTag(BaseButtonTestTags.BUTTON)
         hasText(getResourceString(R.string.common_ok))

app/src/androidTest/kotlin/com/tangem/screens/MainScreenPageObject.kt

@@ -1,5 +1,6 @@
 package com.tangem.screens
 
+import androidx.compose.ui.semantics.SemanticsProperties
 import androidx.compose.ui.test.ExperimentalTestApi
 import androidx.compose.ui.test.SemanticsMatcher
 import androidx.compose.ui.test.SemanticsNodeInteractionsProvider
@@ -186,7 +187,8 @@ class MainScreenPageObject(semanticsProvider: SemanticsNodeInteractionsProvider)
     }
 
     val totalBalanceText: KNode = child {
-        hasParent(withTestTag(MainScreenTestTags.WALLET_BALANCE))
+        hasAnyAncestor(withTestTag(MainScreenTestTags.WALLET_BALANCE))
+        addSemanticsMatcher(SemanticsMatcher.keyIsDefined(SemanticsProperties.Text))
     }
 
     val notificationYesButton: KNode = child {
@@ -235,6 +237,11 @@ class MainScreenPageObject(semanticsProvider: SemanticsNodeInteractionsProvider)
         useUnmergedTree = true
     }
 
+    val searchThroughMarketPlaceholder: KNode = child {
+        hasText(getResourceString(R.string.markets_search_header_title))
+        useUnmergedTree = true
+    }
+
     fun tokenNetworkGroupTitle(tokenNetwork: String): KNode {
         return lazyList.child {
             hasTestTag(MainScreenTestTags.TOKEN_LIST_ITEM)

app/src/androidTest/kotlin/com/tangem/screens/MarketsPageObject.kt

@@ -1,57 +1,44 @@
 package com.tangem.screens
 
-import androidx.compose.ui.test.SemanticsMatcher
 import androidx.compose.ui.test.SemanticsNodeInteractionsProvider
 import com.tangem.common.BaseTestCase
 import com.tangem.common.constants.TestConstants.MARKETS_MAIN_NETWORK_SUFFIX
-import com.tangem.common.utils.LazyListItemNode
 import com.tangem.core.ui.test.BaseButtonTestTags
 import com.tangem.core.ui.test.MarketsTestTags
 import com.tangem.core.ui.test.TopAppBarTestTags
-import com.tangem.core.ui.utils.LazyListItemPositionSemantics
 import com.tangem.features.onramp.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.compose.node.element.lazylist.KLazyListNode
 import io.github.kakaocup.kakao.common.utilities.getResourceString
-import androidx.compose.ui.test.hasText as withText
 
 class MarketsPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
     ComposeScreen<MarketsPageObject>(semanticsProvider = semanticsProvider) {
 
-    private val lazyList = KLazyListNode(
-        semanticsProvider = semanticsProvider,
-        viewBuilderAction = { hasTestTag(MarketsTestTags.TOKENS_LIST) },
-        itemTypeBuilder = { itemType(::LazyListItemNode) },
-        positionMatcher = { position ->
-            SemanticsMatcher.expectValue(
-                LazyListItemPositionSemantics,
-                position
-            )
-        }
-    )
-
     val addToPortfolioButton: KNode = child {
         hasTestTag(BaseButtonTestTags.TEXT)
         hasText(getResourceString(R.string.common_add_to_portfolio))
         useUnmergedTree = true
     }
 
-    val mainNetworkSwitch: KNode = child<KNode> {
-        hasAnyDescendant(withText(MARKETS_MAIN_NETWORK_SUFFIX))
-        useUnmergedTree = true
-    }.child { hasTestTag(MarketsTestTags.ADD_TO_PORTFOLIO_SWITCH) }
+    val mainNetworkSuffix: KNode = child {
+        hasText(MARKETS_MAIN_NETWORK_SUFFIX)
+    }
 
     val topBarBackButton: KNode = child {
         hasTestTag(TopAppBarTestTags.CLOSE_BUTTON)
         useUnmergedTree = true
     }
 
+    val searchThroughMarketPlaceholder: KNode = child {
+        hasText(getResourceString(R.string.markets_search_header_title))
+        useUnmergedTree = true
+    }
+
     fun tokenWithTitle(title: String): KNode {
-        return lazyList.child<KNode> {
+        return child {
+            hasTestTag(MarketsTestTags.TOKENS_LIST_ITEM)
             hasText(title)
-            useUnmergedTree = true
         }
     }
 }

app/src/androidTest/kotlin/com/tangem/screens/MarketsTokenDetailsPageObject.kt

@@ -0,0 +1,33 @@
+package com.tangem.screens
+
+import androidx.compose.ui.test.SemanticsNodeInteractionsProvider
+import com.tangem.common.BaseTestCase
+import com.tangem.core.ui.test.MarketTokenDetailsBottomSheetTestTags
+import com.tangem.core.ui.test.TokenElementsTestTags
+import com.tangem.features.onramp.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
+import androidx.compose.ui.test.hasTestTag as withTestTag
+import androidx.compose.ui.test.hasText as withText
+
+class MarketsTokenDetailsPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
+    ComposeScreen<MarketsTokenDetailsPageObject>(semanticsProvider = semanticsProvider) {
+
+    val swapPortfolioQuickActionButton: KNode = child {
+        hasTestTag(MarketTokenDetailsBottomSheetTestTags.PORTFOLIO_QUICK_ACTION_BUTTON)
+        hasText(getResourceString(R.string.common_swap), substring = true)
+    }
+
+    fun tokenWithTitle(title: String): KNode = child {
+        hasAnyAncestor(withTestTag(MarketTokenDetailsBottomSheetTestTags.PORTFOLIO_TOKEN_ITEM))
+        hasTestTag(TokenElementsTestTags.TOKEN_TITLE)
+        hasAnySibling(withTestTag(TokenElementsTestTags.TOKEN_ICON))
+        hasAnyChild(withText(title))
+        useUnmergedTree = true
+    }
+}
+
+internal fun BaseTestCase.onMarketsTokenDetailsScreen(function: MarketsTokenDetailsPageObject.() -> Unit) =
+    onComposeScreen(composeTestRule, function)

app/src/androidTest/kotlin/com/tangem/screens/MarketsTooltipPageObject.kt

@@ -13,6 +13,10 @@ class MarketsTooltipPageObject(semanticsProvider: SemanticsNodeInteractionsProvi
     val contentContainer: KNode = child {
         hasTestTag(MarketTooltipTestTags.CONTAINER)
     }
+
+    val closeButton: KNode = child {
+        hasTestTag(MarketTooltipTestTags.CLOSE_BUTTON)
+    }
 }
 
 internal fun BaseTestCase.onMarketsTooltipScreen(function: MarketsTooltipPageObject.() -> Unit) =

app/src/androidTest/kotlin/com/tangem/screens/SwapChooseTokenPageObject.kt

@@ -0,0 +1,32 @@
+package com.tangem.screens
+
+import androidx.compose.ui.test.SemanticsNodeInteractionsProvider
+import com.tangem.common.BaseTestCase
+import com.tangem.core.ui.R
+import com.tangem.core.ui.test.TokenElementsTestTags
+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 androidx.compose.ui.test.hasText as withText
+
+class SwapChooseTokenPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
+    ComposeScreen<SwapChooseTokenPageObject>(semanticsProvider = semanticsProvider) {
+
+    val title: KNode = child {
+        hasText(getResourceString(R.string.common_choose_token))
+    }
+
+    val myTokensTitle: KNode = child {
+        hasText(getResourceString(R.string.exchange_tokens_available_tokens_header))
+    }
+
+    fun tokenWithTitle(tokenTitle: String): KNode = child {
+            hasTestTag(TokenElementsTestTags.TOKEN_TITLE)
+            hasAnyDescendant(withText(tokenTitle))
+            useUnmergedTree = true
+        }
+}
+
+internal fun BaseTestCase.onSwapChooseTokenScreen(function: SwapChooseTokenPageObject.() -> Unit) =
+    onComposeScreen(composeTestRule, function)

app/src/androidTest/kotlin/com/tangem/screens/SwapSelectTokenPageObject.kt

@@ -0,0 +1,70 @@
+package com.tangem.screens
+
+import androidx.compose.ui.test.SemanticsNodeInteractionsProvider
+import com.tangem.common.BaseTestCase
+import com.tangem.core.ui.R
+import com.tangem.core.ui.test.SearchBarTestTags
+import com.tangem.core.ui.test.SwapSelectTokenScreenTestTags
+import com.tangem.core.ui.test.TokenElementsTestTags
+import com.tangem.core.ui.test.TopAppBarTestTags
+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 androidx.compose.ui.test.hasText as withText
+
+class SwapSelectTokenPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
+    ComposeScreen<SwapSelectTokenPageObject>(semanticsProvider = semanticsProvider) {
+
+    val title: KNode = child {
+        hasTestTag(TopAppBarTestTags.TITLE)
+        hasText(getResourceString(R.string.common_swap))
+        useUnmergedTree = true
+    }
+
+    val closeButton: KNode = child {
+        hasTestTag(TopAppBarTestTags.CLOSE_BUTTON)
+    }
+
+    val youSwapTitle: KNode = child {
+        hasText(getResourceString(R.string.swapping_from_title))
+        useUnmergedTree = true
+    }
+
+    val youSwapBlock: KNode = child {
+        hasTestTag(SwapSelectTokenScreenTestTags.YOU_SWAP_BLOCK)
+        hasAnyDescendant(withText(getResourceString(R.string.action_buttons_you_want_to_swap)))
+        useUnmergedTree = true
+    }
+
+    val youReceiveTitle: KNode = child {
+        hasText(getResourceString(R.string.swapping_to_title))
+        useUnmergedTree = true
+    }
+
+    val youReceiveBlock: KNode = child {
+        hasTestTag(SwapSelectTokenScreenTestTags.YOU_SWAP_BLOCK)
+        hasAnyDescendant(withText(getResourceString(R.string.action_buttons_you_want_to_receive)))
+        useUnmergedTree = true
+    }
+
+    val searchBarIcon: KNode = child {
+        hasTestTag(SearchBarTestTags.ICON)
+        useUnmergedTree = true
+    }
+
+    val searchBarPlaceholderText: KNode = child {
+        hasTestTag(SearchBarTestTags.PLACEHOLDER_TEXT)
+        useUnmergedTree = true
+    }
+
+    fun tokenWithName(tokenName: String): KNode = child {
+        hasTestTag(TokenElementsTestTags.TOKEN_TITLE)
+        hasAnyChild(withText(tokenName))
+        useUnmergedTree = true
+    }
+
+}
+
+internal fun BaseTestCase.onSwapSelectTokenScreen(function: SwapSelectTokenPageObject.() -> Unit) =
+    onComposeScreen(composeTestRule, function)

app/src/androidTest/kotlin/com/tangem/screens/SwapStoriesPageObject.kt

@@ -10,10 +10,31 @@ import io.github.kakaocup.compose.node.element.KNode
 class SwapStoriesPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
     ComposeScreen<SwapStoriesPageObject>(semanticsProvider = semanticsProvider) {
 
+    val container: KNode = child {
+        hasTestTag(SwapStoriesScreenTestTags.SCREEN_CONTAINER)
+        useUnmergedTree = true
+    }
+
     val closeButton: KNode = child {
         hasTestTag(SwapStoriesScreenTestTags.CLOSE_BUTTON)
         useUnmergedTree = true
     }
+
+    fun progressBarItem(index: Int): KNode = child {
+        hasTestTag(SwapStoriesScreenTestTags.PROGRESS_BAR_ITEM)
+        hasPosition(index)
+        useUnmergedTree = true
+    }
+
+    val title: KNode = child {
+        hasTestTag(SwapStoriesScreenTestTags.TITLE)
+        useUnmergedTree = true
+    }
+
+    val subtitle: KNode = child {
+        hasTestTag(SwapStoriesScreenTestTags.SUBTITLE)
+        useUnmergedTree = true
+    }
 }
 
 internal fun BaseTestCase.onSwapStoriesScreen(function: SwapStoriesPageObject.() -> Unit) =

app/src/androidTest/kotlin/com/tangem/screens/SwapTokenPageObject.kt

@@ -9,10 +9,15 @@ 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 androidx.compose.ui.test.hasTestTag as withTestTag
+import androidx.compose.ui.test.hasText as withText
 
 class SwapTokenPageObject(semanticsProvider: SemanticsNodeInteractionsProvider) :
     ComposeScreen<SwapTokenPageObject>(semanticsProvider = semanticsProvider) {
 
+    val container: KNode = child {
+        hasTestTag(SwapTokenScreenTestTags.CONTAINER)
+    }
+
     val title: KNode = child {
         hasTestTag(TopAppBarTestTags.TITLE)
         hasText(getResourceString(R.string.common_swap))
@@ -76,10 +81,45 @@ class SwapTokenPageObject(semanticsProvider: SemanticsNodeInteractionsProvider)
         hasText(getResourceString(R.string.common_swap))
     }
 
-    fun tokenSymbol(symbol: String): KNode = child {
-        hasTestTag(SwapTokenScreenTestTags.TOKEN_SYMBOL)
+    val youSwapBlock: KNode = child {
+        hasTestTag(SwapTokenScreenTestTags.SWAP_BLOCK_HEADER)
+        hasAnyDescendant(withText(getResourceString(R.string.swapping_from_title)))
+        hasAnyDescendant(withTestTag(SwapTokenScreenTestTags.BALANCE))
+        useUnmergedTree = true
     }
 
+    val youReceiveBlock: KNode = child {
+        hasTestTag(SwapTokenScreenTestTags.SWAP_BLOCK_HEADER)
+        hasAnyDescendant(withText(getResourceString(R.string.swapping_to_title)))
+        hasAnyDescendant(withTestTag(SwapTokenScreenTestTags.BALANCE))
+        useUnmergedTree = true
+    }
+
+    val receiveFiatAmount: KNode = child {
+        hasTestTag(SwapTokenScreenTestTags.RECEIVE_FIAT_AMOUNT)
+    }
+
+    val swapFiatAmount: KNode = child {
+        hasTestTag(SwapTokenScreenTestTags.SWAP_FIAT_AMOUNT)
+    }
+
+    val changeTokenIcon: KNode = child {
+        hasTestTag(SwapTokenScreenTestTags.SELECT_TOKEN_ICON)
+    }
+
+    fun swapTokenSymbol(symbol: String): KNode = child {
+        hasAnyAncestor(withTestTag(SwapTokenScreenTestTags.SWAP_CARD))
+        hasTestTag(SwapTokenScreenTestTags.TOKEN_SYMBOL)
+        hasText(symbol)
+        useUnmergedTree = true
+    }
+
+    fun receiveTokenSymbol(symbol: String): KNode = child {
+        hasAnyAncestor(withTestTag(SwapTokenScreenTestTags.RECEIVE_CARD))
+        hasTestTag(SwapTokenScreenTestTags.TOKEN_SYMBOL)
+        hasText(symbol)
+        useUnmergedTree = true
+    }
 }
 
 internal fun BaseTestCase.onSwapTokenScreen(function: SwapTokenPageObject.() -> Unit) =

app/src/androidTest/kotlin/com/tangem/tests/BuyTokenTest.kt

@@ -1,6 +1,7 @@
 package com.tangem.tests
 
 import com.tangem.common.BaseTestCase
+import com.tangem.common.extensions.assertTextContainsSafe
 import com.tangem.common.extensions.clickWithAssertion
 import com.tangem.common.utils.resetWireMockScenarioState
 import com.tangem.common.utils.setWireMockScenarioState
@@ -374,7 +375,9 @@ class BuyTokenTest : BaseTestCase() {
                 onSelectProviderBottomSheet { paymentMethodIcon.assertIsDisplayed() }
             }
             step("Assert provider name: '$providerNameMercuryo'") {
-                onSelectProviderBottomSheet { providerName.assertTextContains(providerNameMercuryo) }
+                onSelectProviderBottomSheet {
+                    providerName.assertTextContainsSafe(text = providerNameMercuryo, substring = true)
+                }
             }
         }
     }

app/src/androidTest/kotlin/com/tangem/tests/actionButtons/MainScreenActionButtonsTest.kt

@@ -208,7 +208,7 @@ class MainScreenActionButtonsTest : BaseTestCase() {
                 onSwapTokenScreen { title.assertIsDisplayed() }
             }
             step("Assert token symbol: '$tokenSymbol' is displayed") {
-                onSwapTokenScreen { tokenSymbol(tokenSymbol).assertIsDisplayed() }
+                onSwapTokenScreen { swapTokenSymbol(tokenSymbol).assertIsDisplayed() }
             }
         }
     }

app/src/androidTest/kotlin/com/tangem/tests/actionButtons/TokenDetailsScreenActionButtonsTest.kt

@@ -3,6 +3,7 @@ package com.tangem.tests.actionButtons
 import com.tangem.common.BaseTestCase
 import com.tangem.common.constants.TestConstants.WAIT_UNTIL_TIMEOUT
 import com.tangem.common.extensions.SwipeDirection
+import com.tangem.common.extensions.assertIsDimmed
 import com.tangem.common.extensions.clickWithAssertion
 import com.tangem.common.extensions.swipeVertical
 import com.tangem.common.utils.resetWireMockScenarioState
@@ -60,8 +61,6 @@ class TokenDetailsScreenActionButtonsTest : BaseTestCase() {
     @Test
     fun checkActionButtonsStateTest() {
         val tokenTitle = "Bitcoin"
-        val actionButtonIsNotDimmed = "Action button is not dimmed"
-        val actionButtonIsDimmed = "Action button is dimmed"
 
         setupHooks().run {
             step("Open 'Main Screen'") {
@@ -75,19 +74,19 @@ class TokenDetailsScreenActionButtonsTest : BaseTestCase() {
                 onMainScreen { tokenWithTitleAndAddress(tokenTitle).performClick() }
             }
             step("Assert 'Receive' button is not dimmed") {
-                onTokenDetailsScreen { receiveButton().assertContentDescriptionEquals(actionButtonIsNotDimmed) }
+                onTokenDetailsScreen { receiveButton().assertIsDimmed(false) }
             }
             step("Assert 'Buy' button is not dimmed") {
-                onTokenDetailsScreen { buyButton().assertContentDescriptionEquals(actionButtonIsNotDimmed) }
+                onTokenDetailsScreen { buyButton().assertIsDimmed(false) }
             }
             step("Assert 'Send' button is not dimmed") {
-                onTokenDetailsScreen { sendButton().assertContentDescriptionEquals(actionButtonIsNotDimmed) }
+                onTokenDetailsScreen { sendButton().assertIsDimmed(false) }
             }
             step("Assert 'Swap' button is dimmed") {
-                onTokenDetailsScreen { swapButton().assertContentDescriptionEquals(actionButtonIsDimmed) }
+                onTokenDetailsScreen { swapButton().assertIsDimmed() }
             }
             step("Assert 'Sell' button is dimmed") {
-                onTokenDetailsScreen { sellButton().assertContentDescriptionEquals(actionButtonIsDimmed) }
+                onTokenDetailsScreen { sellButton().assertIsDimmed() }
             }
         }
     }
@@ -120,7 +119,7 @@ class TokenDetailsScreenActionButtonsTest : BaseTestCase() {
                 onSwapTokenScreen { title.assertIsDisplayed() }
             }
             step("Assert token symbol: '$tokenSymbol' is displayed") {
-                onSwapTokenScreen { tokenSymbol(tokenSymbol).assertIsDisplayed() }
+                onSwapTokenScreen { swapTokenSymbol(tokenSymbol).assertIsDisplayed() }
             }
         }
     }
@@ -130,7 +129,6 @@ class TokenDetailsScreenActionButtonsTest : BaseTestCase() {
     @Test
     fun checkSwapButtonProviderErrorTest() {
         val tokenTitle = "POL (ex-MATIC)"
-        val actionButtonIsDimmed = "Action button is dimmed"
 
         setupHooks().run {
             step("Open 'Main Screen'") {
@@ -147,7 +145,7 @@ class TokenDetailsScreenActionButtonsTest : BaseTestCase() {
                 onMainScreen { tokenWithTitleAndAddress(tokenTitle).performClick() }
             }
             step("Assert 'Swap' button is dimmed") {
-                onTokenDetailsScreen { swapButton().assertContentDescriptionEquals(actionButtonIsDimmed) }
+                onTokenDetailsScreen { swapButton().assertIsDimmed() }
             }
             step("Click on 'Swap' button") {
                 onTokenDetailsScreen { swapButton().performClick() }
@@ -162,7 +160,7 @@ class TokenDetailsScreenActionButtonsTest : BaseTestCase() {
                 onSwapIsNotSupportedDialog { okButton.performClick() }
             }
             step("Assert 'Swap' button is dimmed") {
-                onTokenDetailsScreen { swapButton().assertContentDescriptionEquals(actionButtonIsDimmed) }
+                onTokenDetailsScreen { swapButton().assertIsDimmed() }
             }
         }
     }
@@ -172,7 +170,6 @@ class TokenDetailsScreenActionButtonsTest : BaseTestCase() {
     @Test
     fun checkSwapButtonExpressErrorTest() {
         val tokenTitle = "Polygon"
-        val actionButtonIsDimmed = "Action button is dimmed"
         val scenarioName = "express_api_assets"
         val scenarioState = "Error"
 
@@ -198,7 +195,7 @@ class TokenDetailsScreenActionButtonsTest : BaseTestCase() {
                 onMainScreen { tokenWithTitleAndAddress(tokenTitle).performClick() }
             }
             step("Assert 'Swap' button is dimmed") {
-                onTokenDetailsScreen { swapButton().assertContentDescriptionEquals(actionButtonIsDimmed) }
+                onTokenDetailsScreen { swapButton().assertIsDimmed() }
             }
             step("Click on 'Swap' button") {
                 onTokenDetailsScreen { swapButton().performClick() }
@@ -213,7 +210,7 @@ class TokenDetailsScreenActionButtonsTest : BaseTestCase() {
                 onOperationIsUnavailableDialog { okButton.performClick() }
             }
             step("Assert 'Swap' button is dimmed") {
-                onTokenDetailsScreen { swapButton().assertContentDescriptionEquals(actionButtonIsDimmed) }
+                onTokenDetailsScreen { swapButton().assertIsDimmed() }
             }
         }
     }

app/src/androidTest/kotlin/com/tangem/tests/balance/TotalBalanceLongTapTest.kt

@@ -31,8 +31,8 @@ class TotalBalanceLongTapTest : BaseTestCase() {
                     }
                 }
             }
-            step("Assert 'Rename' button is not displayed") {
-                onMainScreen { totalBalanceMenuRenameWallet.assertIsNotDisplayed() }
+            step("Assert 'Rename' button is displayed") {
+                onMainScreen { totalBalanceMenuRenameWallet.assertIsDisplayed() }
             }
             step("Assert 'Delete' button is not displayed") {
                 onMainScreen { totalBalanceMenuDeleteWallet.assertIsNotDisplayed() }

app/src/androidTest/kotlin/com/tangem/tests/balance/TotalBalanceUpdateTest.kt

@@ -57,7 +57,7 @@ class TotalBalanceUpdateTest : BaseTestCase() {
         val tokenTitle = "XRP"
         val scenarioName = "quotes_api"
         val scenarioState = "Ripple"
-        val updatedBalance = "$3,307.18"
+        val updatedBalance = "$3,320.47"
         setupHooks(
             additionalAfterSection = {
                 resetWireMockScenarioState(scenarioName)
@@ -85,14 +85,17 @@ class TotalBalanceUpdateTest : BaseTestCase() {
             step("Click on 'Add to portfolio' button") {
                 onMarketsScreen { addToPortfolioButton.clickWithAssertion() }
             }
-            step("Toggle the main network switch") {
-                onMarketsScreen { mainNetworkSwitch.performClick() }
+            step("Click on main network") {
+                onMarketsScreen { mainNetworkSuffix.performClick() }
             }
-            step("Click on 'Continue' button") {
-                onDialog { continueButton.clickWithAssertion() }
+            step("Click on 'Add' button") {
+                onDialog { addButton.clickWithAssertion() }
             }
             step("Assert 'Continue' is not displayed") {
-                onDialog { continueButton.assertIsNotDisplayed() }
+                onDialog { addButton.assertIsNotDisplayed() }
+            }
+            step("Click on 'Later' button") {
+                onDialog { laterButton.clickWithAssertion() }
             }
             step("Go back to 'Markets: tokens list'") {
                 waitForIdle()

app/src/androidTest/kotlin/com/tangem/tests/swap/SwapSelectTokenScreenTest.kt

@@ -0,0 +1,72 @@
+package com.tangem.tests.swap
+
+import com.tangem.common.BaseTestCase
+import com.tangem.common.extensions.clickWithAssertion
+import com.tangem.scenarios.openMainScreen
+import com.tangem.scenarios.synchronizeAddresses
+import com.tangem.screens.onMainScreen
+import com.tangem.screens.onSwapSelectTokenScreen
+import com.tangem.screens.onSwapStoriesScreen
+import com.tangem.screens.onSwapTokenScreen
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.qameta.allure.kotlin.AllureId
+import io.qameta.allure.kotlin.junit4.DisplayName
+import org.junit.Test
+
+@HiltAndroidTest
+class SwapSelectTokenScreenTest : BaseTestCase() {
+
+    @AllureId("2829")
+    @DisplayName("Open 'Swap select token' screen from 'Main' screen")
+    @Test
+    fun openSwapSelectTokenScreenFromMainScreenTest() {
+        val swapTokenName = "Ethereum"
+        val receiveTokenName = "Polygon"
+
+        setupHooks().run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Click on 'Swap' button") {
+                onMainScreen { swapButton.performClick() }
+            }
+            step("Close 'Stories' screen") {
+                onSwapStoriesScreen { closeButton.clickWithAssertion() }
+            }
+            step("Assert 'Swap select token' screen title is displayed") {
+                onSwapSelectTokenScreen { title.assertIsDisplayed() }
+            }
+            step("Assert 'You swap' title is displayed") {
+                onSwapSelectTokenScreen { youSwapTitle.assertIsDisplayed() }
+            }
+            step("Assert 'You swap' block is displayed") {
+                onSwapSelectTokenScreen { youSwapBlock.assertIsDisplayed() }
+            }
+            step("Assert search icon is displayed") {
+                onSwapSelectTokenScreen { searchBarIcon.assertIsDisplayed() }
+            }
+            step("Assert search placeholder is displayed") {
+                onSwapSelectTokenScreen { searchBarPlaceholderText.assertIsDisplayed() }
+            }
+            step("Click on token with name '$swapTokenName'") {
+                onSwapSelectTokenScreen { tokenWithName(swapTokenName).performClick() }
+            }
+            step("Assert 'You receive' title is displayed") {
+                onSwapSelectTokenScreen { youReceiveTitle.assertIsDisplayed() }
+            }
+            step("Assert 'You receive' block is displayed") {
+                onSwapSelectTokenScreen { youReceiveBlock.assertIsDisplayed() }
+            }
+            step("Click on token with name '$receiveTokenName'") {
+                onSwapSelectTokenScreen { tokenWithName(receiveTokenName).performClick() }
+            }
+            step("Assert 'Swap token' screen is opened") {
+                onSwapTokenScreen { container.assertIsDisplayed() }
+            }
+        }
+    }
+}

app/src/androidTest/kotlin/com/tangem/tests/swap/SwapStoriesTest.kt

@@ -0,0 +1,437 @@
+package com.tangem.tests.swap
+
+import androidx.compose.ui.test.longClick
+import androidx.test.InstrumentationRegistry.getTargetContext
+import com.tangem.common.BaseTestCase
+import com.tangem.common.extensions.assertHasBadge
+import com.tangem.common.extensions.restartApp
+import com.tangem.common.utils.resetWireMockScenarioState
+import com.tangem.common.utils.setWireMockScenarioState
+import com.tangem.scenarios.*
+import com.tangem.screens.*
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.qameta.allure.kotlin.AllureId
+import io.qameta.allure.kotlin.junit4.DisplayName
+import org.junit.Test
+
+@HiltAndroidTest
+class SwapStoriesTest : BaseTestCase() {
+
+    @AllureId("5453")
+    @DisplayName("Check 'Swap' button badge on 'Main' screen")
+    @Test
+    fun checkMainScreenSwapButtonBadgeTest() {
+
+        setupHooks().run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Assert 'Swap' button has badge") {
+                onMainScreen { swapButton.assertHasBadge() }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.MainScreen)
+            }
+            step("Click on 'Close' button") {
+                onSwapTokenScreen { closeButton.performClick() }
+            }
+            step("Assert 'Swap' button has not badge") {
+                onMainScreen { swapButton.assertHasBadge(false) }
+            }
+        }
+    }
+
+    @AllureId("5454")
+    @DisplayName("Check 'Swap' button badge on token details screen")
+    @Test
+    fun checkTokenDetailsScreenSwapButtonTest() {
+        val tokenName = "Ethereum"
+
+        setupHooks().run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Click on token with name: '$tokenName'") {
+                onMainScreen { tokenWithTitleAndAddress(tokenName).performClick() }
+            }
+            step("Assert 'Swap' button has badge") {
+                onTokenDetailsScreen { swapButton().assertHasBadge() }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.TokenDetails)
+            }
+            step("Click on 'Close' button") {
+                onSwapTokenScreen { closeButton.performClick() }
+            }
+            step("Assert 'Swap' button has not badge") {
+                onTokenDetailsScreen { swapButton().assertHasBadge(false) }
+            }
+        }
+    }
+
+    @AllureId("5455")
+    @DisplayName("Check 'Swap' button badge on token details in 'Market' screen")
+    @Test
+    fun checkMarketTokenDetailsScreenSwapButtonTest() {
+        val tokenName = "Ethereum"
+        val badgeShown = "Badge shown"
+        val badgeHidden = "Badge hidden"
+
+        setupHooks().run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Open 'Markets' token details screen for token '$tokenName'") {
+                openMarketTokenDetailsScreen(blockchainName = tokenName, tokenName = tokenName)
+            }
+            step("Assert 'Swap' button has badge") {
+                onMarketsTokenDetailsScreen { swapPortfolioQuickActionButton.assertIsDisplayed() }
+                onMarketsTokenDetailsScreen { swapPortfolioQuickActionButton.assertContentDescriptionEquals(badgeShown) }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.MarketsTokenDetails)
+            }
+            step("Click on 'Close' button") {
+                onSwapTokenScreen { closeButton.performClick() }
+            }
+            step("Assert 'Swap' button has not badge") {
+                onMarketsTokenDetailsScreen { swapPortfolioQuickActionButton.assertContentDescriptionEquals(badgeHidden) }
+            }
+        }
+    }
+
+    @AllureId("5469")
+    @DisplayName("Check unavailable swap stories on 'Main' screen")
+    @Test
+    fun checkUnavailableSwapStoriesOnMainScreen() {
+        val scenarioName = "stories_first_time_swap"
+        val scenarioErrorState = "Error"
+        val packageName = getTargetContext().packageName
+
+        setupHooks(
+            additionalBeforeAppLaunchSection = {
+                setWireMockScenarioState(scenarioName = scenarioName, state = scenarioErrorState)
+            },
+            additionalAfterSection = {
+                resetWireMockScenarioState(scenarioName)
+            }
+        ).run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Assert 'Swap' button has not badge") {
+                onMainScreen { swapButton.assertHasBadge(false) }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.MainScreen, storiesExist = false)
+            }
+            step("Reset WireMock scenario state") {
+                resetWireMockScenarioState(scenarioName)
+            }
+            step("Click on 'Close' button") {
+                onSwapTokenScreen { closeButton.performClick() }
+            }
+            step("Restart app") {
+                restartApp(packageName)
+            }
+            step("Assert 'Swap' button is displayed") {
+                waitForIdle()
+                onMainScreen { swapButton.assertIsDisplayed() }
+            }
+            step("Assert 'Swap' button has badge") {
+                onMainScreen { swapButton.assertHasBadge() }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.MainScreen, storiesExist = true)
+            }
+        }
+    }
+
+    @AllureId("5471")
+    @DisplayName("Check unavailable swap stories on 'Token details' screen")
+    @Test
+    fun checkUnavailableSwapStoriesOnTokenDetailsScreen() {
+        val scenarioName = "stories_first_time_swap"
+        val scenarioErrorState = "Error"
+        val packageName = getTargetContext().packageName
+        val tokenName = "Ethereum"
+
+
+        setupHooks(
+            additionalBeforeAppLaunchSection = {
+                setWireMockScenarioState(scenarioName = scenarioName, state = scenarioErrorState)
+            },
+            additionalAfterSection = {
+                resetWireMockScenarioState(scenarioName)
+            }
+        ).run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Click on token with name: '$tokenName'") {
+                onMainScreen { tokenWithTitleAndAddress(tokenName).performClick() }
+            }
+            step("Assert 'Swap' button has not badge") {
+                onTokenDetailsScreen { swapButton().assertHasBadge(false) }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.TokenDetails, storiesExist = false)
+            }
+            step("Click on 'Close' button") {
+                onSwapTokenScreen { closeButton.performClick() }
+            }
+            step("Reset WireMock scenario state") {
+                resetWireMockScenarioState(scenarioName)
+            }
+            step("Restart app") {
+                restartApp(packageName)
+            }
+            step("Assert 'Swap' button has badge") {
+                waitForIdle()
+                onMainScreen { swapButton.assertHasBadge() }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.TokenDetails, storiesExist = true)
+            }
+        }
+    }
+
+    @AllureId("5470")
+    @DisplayName("Check unavailable swap stories on 'Markets' token details screen")
+    @Test
+    fun checkUnavailableSwapStoriesOnMarketsTokenDetailsScreen() {
+        val scenarioName = "stories_first_time_swap"
+        val scenarioErrorState = "Error"
+        val packageName = getTargetContext().packageName
+        val tokenName = "Ethereum"
+        val badgeShown = "Badge shown"
+        val badgeHidden = "Badge hidden"
+
+        setupHooks(
+            additionalBeforeAppLaunchSection = {
+                setWireMockScenarioState(scenarioName = scenarioName, state = scenarioErrorState)
+            },
+            additionalAfterSection = {
+                resetWireMockScenarioState(scenarioName)
+            }
+        ).run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Open 'Markets' token details screen for token '$tokenName'") {
+                openMarketTokenDetailsScreen(blockchainName = tokenName, tokenName = tokenName)
+            }
+            step("Assert 'Swap' button has not badge") {
+                waitForIdle()
+                onMarketsTokenDetailsScreen { swapPortfolioQuickActionButton.assertIsDisplayed() }
+                onMarketsTokenDetailsScreen { swapPortfolioQuickActionButton.assertContentDescriptionEquals(badgeHidden) }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.MarketsTokenDetails, storiesExist = false)
+            }
+            step("Click on 'Close' button") {
+                onSwapTokenScreen { closeButton.performClick() }
+            }
+            step("Reset WireMock scenario state") {
+                resetWireMockScenarioState(scenarioName)
+            }
+            step("Restart app") {
+                restartApp(packageName)
+            }
+            step("Open 'Markets' token details screen for token '$tokenName'") {
+                openMarketTokenDetailsScreen(blockchainName = tokenName, tokenName = tokenName)
+            }
+            step("Assert 'Swap' button has badge") {
+                waitForIdle()
+                onMarketsTokenDetailsScreen { swapPortfolioQuickActionButton.assertIsDisplayed() }
+                onMarketsTokenDetailsScreen { swapPortfolioQuickActionButton.assertContentDescriptionEquals(badgeShown) }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.MarketsTokenDetails, storiesExist = true)
+            }
+        }
+    }
+
+    @AllureId("5474")
+    @DisplayName("Check 'Swap' stories on 'Main' screen")
+    @Test
+    fun checkSwapStoriesOnMainScreenTest() {
+
+        setupHooks().run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Click on 'Swap' button on 'Main' screen") {
+                onMainScreen { swapButton.performClick() }
+            }
+            step("Check stories changes") {
+                checkStoriesChanges()
+            }
+            step("Click on 'Close' button") {
+                onSwapStoriesScreen { closeButton.performClick() }
+            }
+            step("Assert 'Swap' screen title is displayed") {
+                onSwapTokenScreen { title.assertIsDisplayed() }
+            }
+            step("Click on 'Close' button") {
+                onSwapTokenScreen { closeButton.performClick() }
+            }
+            step("Open 'Swap' screen without stories") {
+                openSwapScreen(from = SwapEntryPoint.MainScreen, storiesExist = false)
+            }
+        }
+    }
+
+    @AllureId("5475")
+    @DisplayName("Check 'Swap' stories on 'Token details' screen")
+    @Test
+    fun checkSwapStoriesOnTokenDetailsScreenTest() {
+        val tokenName = "Ethereum"
+
+        setupHooks().run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Click on token with name: '$tokenName'") {
+                onMainScreen { tokenWithTitleAndAddress(tokenName).performClick() }
+            }
+            step("Assert 'Swap' button has badge") {
+                onTokenDetailsScreen { swapButton().assertHasBadge() }
+            }
+            step("Click on 'Swap' button on 'Token details' screen") {
+                onTokenDetailsScreen { swapButton().performClick() }
+            }
+            step("Check stories changes") {
+                checkStoriesChanges()
+            }
+            step("Click on 'Close' button") {
+                onSwapStoriesScreen { closeButton.performClick() }
+            }
+            step("Assert 'Swap' screen title is displayed") {
+                onSwapTokenScreen { title.assertIsDisplayed() }
+            }
+            step("Click on 'Close' button") {
+                onSwapTokenScreen { closeButton.performClick() }
+            }
+            step("Open 'Swap' screen without stories") {
+                openSwapScreen(from = SwapEntryPoint.TokenDetails, storiesExist = false)
+            }
+        }
+    }
+
+    @AllureId("5476")
+    @DisplayName("Check 'Swap' stories on 'Markets' screen")
+    @Test
+    fun checkSwapStoriesOnMarketTokenDetailsScreenTest() {
+        val tokenName = "Ethereum"
+
+        setupHooks().run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Open 'Markets' token details screen for token '$tokenName'") {
+                openMarketTokenDetailsScreen(blockchainName = tokenName, tokenName = tokenName)
+            }
+            step("Click on 'Swap' button on 'Markets' token details screen") {
+                onMarketsTokenDetailsScreen { swapPortfolioQuickActionButton.performClick() }
+            }
+            step("Check stories changes") {
+                checkStoriesChanges()
+            }
+            step("Click on 'Close' button") {
+                onSwapStoriesScreen { closeButton.performClick() }
+            }
+            step("Assert 'Swap' screen title is displayed") {
+                onSwapTokenScreen { title.assertIsDisplayed() }
+            }
+            step("Click on 'Close' button") {
+                onSwapTokenScreen { closeButton.performClick() }
+            }
+            step("Open 'Swap' screen without stories") {
+                openSwapScreen(from = SwapEntryPoint.MarketsTokenDetails, storiesExist = false)
+            }
+        }
+    }
+
+    @AllureId("5477")
+    @DisplayName("Check 'Swap' stories on token actions bottom sheet")
+    @Test
+    fun checkSwapStoriesOnTokenActionsBottomSheetTest() {
+        val tokenName = "Ethereum"
+
+        setupHooks().run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Long click on token with name: '$tokenName'") {
+                waitForIdle()
+                onMainScreen {
+                    tokenWithTitleAndAddress(tokenName).performTouchInput {
+                        longClick(
+                            position = center,
+                            durationMillis = 1000L
+                        )
+                    }
+                }
+            }
+            step("Click on 'Swap' button") {
+                onTokenActionsBottomSheet { swapButton.performClick() }
+            }
+            step("Check stories changes") {
+                checkStoriesChanges()
+            }
+            step("Click on 'Close' button") {
+                onSwapStoriesScreen { closeButton.performClick() }
+            }
+            step("Assert 'Swap' screen title is displayed") {
+                onSwapTokenScreen { title.assertIsDisplayed() }
+            }
+            step("Click on 'Close' button") {
+                onSwapTokenScreen { closeButton.performClick() }
+            }
+            step("Open 'Swap' screen without stories") {
+                openSwapScreen(from = SwapEntryPoint.TokenActionsBottomSheet, storiesExist = false)
+            }
+        }
+    }
+}

app/src/androidTest/kotlin/com/tangem/tests/swap/SwapTokenScreenTest.kt

@@ -1,4 +1,4 @@
-package com.tangem.tests
+package com.tangem.tests.swap
 
 import androidx.compose.ui.test.hasText
 import com.tangem.common.BaseTestCase
@@ -10,7 +10,9 @@ import com.tangem.common.extensions.*
 import com.tangem.common.utils.resetWireMockScenarios
 import com.tangem.datasource.api.common.config.ApiConfig
 import com.tangem.datasource.api.common.config.ApiEnvironment
+import com.tangem.scenarios.SwapEntryPoint
 import com.tangem.scenarios.openMainScreen
+import com.tangem.scenarios.openSwapScreen
 import com.tangem.scenarios.synchronizeAddresses
 import com.tangem.screens.*
 import dagger.hilt.android.testing.HiltAndroidTest
@@ -19,7 +21,7 @@ import io.qameta.allure.kotlin.junit4.DisplayName
 import org.junit.Test
 
 @HiltAndroidTest
-class SwapTokenTest : BaseTestCase() {
+class SwapTokenScreenTest : BaseTestCase() {
 
     @ApiEnv(
         ApiEnvConfig(ApiConfig.ID.Express, ApiEnvironment.PROD)
@@ -28,7 +30,7 @@ class SwapTokenTest : BaseTestCase() {
     @DisplayName("Swap: network fee")
     @Test
     fun networkFeeTest() {
-        val inputAmount = "100"
+        val inputAmount = "400"
         val tokenTitle = "Polygon"
 
         setupHooks().run {
@@ -43,7 +45,7 @@ class SwapTokenTest : BaseTestCase() {
             step("Click on token with name: '$tokenTitle'") {
                 onMainScreen { tokenWithTitleAndAddress(tokenTitle).clickWithAssertion() }
             }
-            step("Click on token with name: '$tokenTitle'") {
+            step("Assert title: '$tokenTitle' is displayed") {
                 onTokenDetailsScreen { title.assertIsDisplayed() }
             }
             step("Click on 'Swap' button") {
@@ -97,22 +99,31 @@ class SwapTokenTest : BaseTestCase() {
                 }
             }
             step("Assert receive amount is not equal to '0'") {
-                onSwapTokenScreen { receiveAmount.assert(!hasText("0")) }
+                onSwapTokenScreen {
+                    flakySafely(WAIT_UNTIL_TIMEOUT_LONG) {
+                        waitForIdle()
+                        receiveAmount.assert(!hasText("0"))
+                    }
+                }
             }
         }
     }
 
+    @ApiEnv(
+        ApiEnvConfig(ApiConfig.ID.Express, ApiEnvironment.PROD)
+    )
     @AllureId("3549")
     @DisplayName("Swap: network error test")
     @Test
     fun networkErrorSwapTest() {
+        val tokenTitle = "Polygon"
+
         setupHooks(
             additionalAfterSection = {
                 enableWiFi()
                 enableMobileData()
             }
         ).run {
-            val tokenTitle = "Polygon"
 
             step("Open 'Main Screen'") {
                 openMainScreen()
@@ -123,7 +134,7 @@ class SwapTokenTest : BaseTestCase() {
             step("Click on token with name: '$tokenTitle'") {
                 onMainScreen { tokenWithTitleAndAddress(tokenTitle).clickWithAssertion() }
             }
-            step("Click on token with name: '$tokenTitle'") {
+            step("Assert title: '$tokenTitle' is displayed") {
                 onTokenDetailsScreen { title.assertIsDisplayed() }
             }
             step("Turn off Wi-Fi and Mobile Data") {
@@ -140,7 +151,12 @@ class SwapTokenTest : BaseTestCase() {
                 onSwapTokenScreen { title.assertIsDisplayed() }
             }
             step("Assert error notification title is displayed") {
-                onSwapTokenScreen { errorNotificationTitle.assertIsDisplayed() }
+                onSwapTokenScreen {
+                    waitForIdle()
+                    flakySafely(WAIT_UNTIL_TIMEOUT_LONG) {
+                        errorNotificationTitle.assertIsDisplayed()
+                    }
+                }
             }
             step("Assert error notification text is displayed") {
                 onSwapTokenScreen { errorNotificationText.assertIsDisplayed() }
@@ -158,7 +174,8 @@ class SwapTokenTest : BaseTestCase() {
     @DisplayName("Swap: change network fee")
     @Test
     fun changeNetworkFeeTest() {
-        val inputAmount = "100"
+        val inputAmount = "400"
+
         setupHooks().run {
             val tokenTitle = "Polygon"
 
@@ -171,7 +188,7 @@ class SwapTokenTest : BaseTestCase() {
             step("Click on token with name: '$tokenTitle'") {
                 onMainScreen { tokenWithTitleAndAddress(tokenTitle).clickWithAssertion() }
             }
-            step("Click on token with name: '$tokenTitle'") {
+            step("Assert title: '$tokenTitle' is displayed") {
                 onTokenDetailsScreen { title.assertIsDisplayed() }
             }
             step("Click on 'Swap' button") {
@@ -207,10 +224,20 @@ class SwapTokenTest : BaseTestCase() {
             step("Assert input amount = '$inputAmount'") {
                 onSwapTokenScreen { textInput.assertTextEquals(inputAmount) }
             }
+            step("Assert 'Network fee' block is displayed") {
+                onSwapTokenScreen {
+                    flakySafely(WAIT_UNTIL_TIMEOUT_LONG) {
+                        networkFeeBlock.assertIsDisplayed()
+                    }
+                }
+            }
+            step("Assert 'Swap' button is enabled") {
+                onSwapTokenScreen { swapButton.assertIsEnabled() }
+            }
             step("Click on 'Network fee' block") {
                 onSwapTokenScreen {
                     flakySafely(WAIT_UNTIL_TIMEOUT_LONG) {
-                        selectFeeIcon.clickWithAssertion()
+                        selectFeeIcon.performClick()
                     }
                 }
             }
@@ -218,7 +245,6 @@ class SwapTokenTest : BaseTestCase() {
                 onSwapSelectNetworkFeeBottomSheet { title.assertIsDisplayed() }
             }
             step("Assert 'Market' item is displayed") {
-                printSemanticTree(rootIndex = 1, useUnmergedTree = true)
                 onSwapSelectNetworkFeeBottomSheet { marketSelectorItem.assertIsDisplayed() }
             }
             step("Assert 'Fast' item is displayed") {
@@ -239,4 +265,183 @@ class SwapTokenTest : BaseTestCase() {
             }
         }
     }
+
+    @AllureId("2828")
+    @DisplayName("Swap: network fee")
+    @Test
+    fun goToTokenSwapTest() {
+        val swapTokenSymbol = "POL"
+        val receiveTokenSymbol = "ETH"
+        val tokenTitle = "Polygon"
+
+        setupHooks().run {
+
+            resetWireMockScenarios()
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Click on token with name: '$tokenTitle'") {
+                onMainScreen { tokenWithTitleAndAddress(tokenTitle).clickWithAssertion() }
+            }
+            step("Assert title: '$tokenTitle' is displayed") {
+                onTokenDetailsScreen { title.assertIsDisplayed() }
+            }
+            step("Click on 'Swap' button") {
+                onTokenDetailsScreen { swapButton().performClick() }
+            }
+            step("Close 'Stories' screen") {
+                onSwapStoriesScreen { closeButton.clickWithAssertion() }
+            }
+            step("Assert 'Swap' screen title is displayed") {
+                onSwapTokenScreen { title.assertIsDisplayed() }
+            }
+            step("Assert 'Close' button is displayed") {
+                onSwapTokenScreen { closeButton.assertIsDisplayed() }
+            }
+            step("Assert 'Swap tokens on screen' button is displayed") {
+                onSwapTokenScreen {
+                    flakySafely(WAIT_UNTIL_TIMEOUT) {
+                        swapTokensOnscreenButton.assertIsDisplayed()
+                    }
+                }
+            }
+            step("Assert token symbol: '$swapTokenSymbol' is displayed") {
+                onSwapTokenScreen { swapTokenSymbol(swapTokenSymbol).assertIsDisplayed() }
+            }
+            step("Assert token symbol: '$receiveTokenSymbol' is displayed") {
+                onSwapTokenScreen { receiveTokenSymbol(receiveTokenSymbol).assertIsDisplayed() }
+            }
+        }
+    }
+
+    @AllureId("575")
+    @DisplayName("Swap: check UI")
+    @Test
+    fun checkSwapUiTest() {
+        val swapTokenSymbol = "POL"
+        val receiveTokenSymbol = "ETH"
+        val newReceiveToken = "POL (ex-MATIC)"
+        val tokenTitle = "Polygon"
+        val inputAmount = "1"
+
+        setupHooks().run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Click on token with name: '$tokenTitle'") {
+                onMainScreen { tokenWithTitleAndAddress(tokenTitle).clickWithAssertion() }
+            }
+            step("Assert title: '$tokenTitle' is displayed") {
+                onTokenDetailsScreen { title.assertIsDisplayed() }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.TokenDetails)
+            }
+            step("Assert 'Close' button is displayed") {
+                onSwapTokenScreen { closeButton.assertIsDisplayed() }
+            }
+            step("Assert swap token symbol: '$swapTokenSymbol' is displayed") {
+                onSwapTokenScreen { swapTokenSymbol(swapTokenSymbol).assertIsDisplayed() }
+            }
+            step("Assert receive token symbol: '$receiveTokenSymbol' is displayed") {
+                onSwapTokenScreen { receiveTokenSymbol(receiveTokenSymbol).assertIsDisplayed() }
+            }
+            step("Click on 'Select token' icon") {
+                onSwapTokenScreen { changeTokenIcon.performClick() }
+            }
+            step("Select new receive token: $newReceiveToken") {
+                onSwapChooseTokenScreen { tokenWithTitle(newReceiveToken).performClick() }
+            }
+            step("Assert new receive token symbol: '$swapTokenSymbol' is displayed") {
+                onSwapTokenScreen { receiveTokenSymbol(swapTokenSymbol).assertIsDisplayed() }
+            }
+            step("Input swap amount = '$inputAmount'") {
+                waitForIdle()
+                onSwapTokenScreen {
+                    textInput.clickWithAssertion()
+                    textInput.performTextReplacement(inputAmount)
+                }
+            }
+            step("Assert input amount = '$inputAmount'") {
+                onSwapTokenScreen { textInput.assertTextEquals(inputAmount) }
+            }
+            step("Press 'Delete' button on keyboard") {
+                device.uiDevice.pressDelete()
+                waitForIdle()
+            }
+            step("Assert 'You swap' block is displayed") {
+                onSwapTokenScreen { youSwapBlock.assertIsDisplayed() }
+            }
+            step("Assert 'You receive' block is displayed") {
+                onSwapTokenScreen { youReceiveBlock }
+            }
+            step("Assert send token fiat amount is displayed") {
+                onSwapTokenScreen { swapFiatAmount.assertIsDisplayed() }
+            }
+            step("Assert receive token fiat amount is displayed") {
+                onSwapTokenScreen { receiveFiatAmount.assertIsDisplayed() }
+            }
+            step("Assert 'Swap tokens on screen' button is displayed") {
+                onSwapTokenScreen {
+                    flakySafely(WAIT_UNTIL_TIMEOUT) {
+                        swapTokensOnscreenButton.assertIsDisplayed()
+                    }
+                }
+            }
+            step("Assert 'Swap' button is disabled") {
+                onSwapTokenScreen { swapButton.assertIsNotEnabled() }
+            }
+        }
+    }
+
+    @AllureId("5162")
+    @DisplayName("Swap: check swap tokens switch")
+    @Test
+    fun checkSwapTokensSwitchTest() {
+        val swapTokenSymbol = "POL"
+        val receiveTokenSymbol = "ETH"
+        val tokenTitle = "Polygon"
+
+        setupHooks().run {
+
+            step("Open 'Main Screen'") {
+                openMainScreen()
+            }
+            step("Synchronize addresses") {
+                synchronizeAddresses()
+            }
+            step("Click on token with name: '$tokenTitle'") {
+                onMainScreen { tokenWithTitleAndAddress(tokenTitle).clickWithAssertion() }
+            }
+            step("Assert title: '$tokenTitle' is displayed") {
+                onTokenDetailsScreen { title.assertIsDisplayed() }
+            }
+            step("Open 'Swap' screen") {
+                openSwapScreen(from = SwapEntryPoint.TokenDetails)
+            }
+            step("Assert swap token symbol: '$swapTokenSymbol' is displayed") {
+                onSwapTokenScreen { swapTokenSymbol(swapTokenSymbol).assertIsDisplayed() }
+            }
+            step("Assert receive token symbol: '$receiveTokenSymbol' is displayed") {
+                onSwapTokenScreen { receiveTokenSymbol(receiveTokenSymbol).assertIsDisplayed() }
+            }
+            step("Click on 'Swap tokens on screen' button") {
+                onSwapTokenScreen { swapTokensOnscreenButton.performClick() }
+                waitForIdle()
+            }
+            step("Assert new swap token symbol: '$receiveTokenSymbol' is displayed") {
+                onSwapTokenScreen { swapTokenSymbol(receiveTokenSymbol).assertIsDisplayed() }
+            }
+            step("Assert new receive token symbol: '$swapTokenSymbol' is displayed") {
+                onSwapTokenScreen { receiveTokenSymbol(swapTokenSymbol).assertIsDisplayed() }
+            }
+        }
+    }
 }

app/src/google/java/com/tangem/tap/GoogleReviewManager.kt

@@ -0,0 +1,50 @@
+package com.tangem.tap
+
+import android.app.Activity
+import com.google.android.gms.tasks.Task
+import com.google.android.play.core.review.ReviewInfo
+import com.google.android.play.core.review.ReviewManagerFactory
+import com.tangem.core.navigation.review.ReviewManager
+import timber.log.Timber
+import com.google.android.play.core.review.ReviewManager as GReviewManager
+
+/**
+ * Implementation of [ReviewManager] for Google Play Store.
+ */
+internal class GoogleReviewManager : ReviewManager {
+
+    override fun request(onDismissClick: () -> Unit) {
+        foregroundActivityObserver.withForegroundActivity { activity ->
+            val reviewManager = ReviewManagerFactory.create(activity)
+            val requestTask = reviewManager.requestReviewFlow()
+            requestTask
+                .addOnCompleteListener { task ->
+                    handleOnCompleteRequestTask(
+                        reviewManager = reviewManager,
+                        activity = activity,
+                        task = task,
+                        onDismissClick = onDismissClick,
+                    )
+                }
+                .addOnFailureListener(Timber::e)
+        }
+    }
+
+    private fun handleOnCompleteRequestTask(
+        reviewManager: GReviewManager,
+        activity: Activity,
+        task: Task<ReviewInfo>,
+        onDismissClick: () -> Unit,
+    ) {
+        if (task.isSuccessful) {
+            val reviewFlow = reviewManager.launchReviewFlow(activity, task.result)
+            reviewFlow
+                .addOnCompleteListener { resultReviewTask ->
+                    if (!resultReviewTask.isSuccessful) onDismissClick()
+                }
+                .addOnFailureListener(Timber::e)
+        } else {
+            Timber.e(task.exception)
+        }
+    }
+}

app/src/google/java/com/tangem/tap/di/GoogleReviewManagerModule.kt

@@ -0,0 +1,20 @@
+package com.tangem.tap.di
+
+import com.tangem.core.navigation.review.ReviewManager
+import com.tangem.tap.GoogleReviewManager
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal class GoogleReviewManagerModule {
+
+    @Singleton
+    @Provides
+    fun provideGoogleReviewManager(): ReviewManager {
+        return GoogleReviewManager()
+    }
+}

app/src/huawei/java/com/tangem/tap/di/HuaweiReviewManagerModule.kt

@@ -0,0 +1,20 @@
+package com.tangem.tap.di
+
+import com.tangem.core.navigation.review.DummyReviewManager
+import com.tangem.core.navigation.review.ReviewManager
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal class HuaweiReviewManagerModule {
+
+    @Provides
+    @Singleton
+    fun provideHuaweiReviewManager(): ReviewManager {
+        return DummyReviewManager()
+    }
+}

app/src/main/AndroidManifest.xml

@@ -313,6 +313,16 @@
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.BROWSABLE" />
 
+                <data
+                    android:host="join.tangem.com"
+                    android:scheme="https" />
+            </intent-filter>
+            <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
                 <data
                     android:scheme="https"
                     android:host="tangem.com"

app/src/main/assets/tangem-app-config

@@ -1 +1 @@
-Subproject commit a5d1a89425a95bc9c90c7a6fed3c578b0d324994
+Subproject commit b693d601d9dc3de27f0536574bce59a6aa5e2e89

app/src/main/java/com/tangem/tap/ApplicationEntryPoint.kt

@@ -40,9 +40,7 @@ import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.walletconnect.usecase.initialize.WcInitializeUseCase
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.builder.ColdUserWalletBuilder
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.repository.WalletsRepository
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
 import com.tangem.hot.sdk.TangemHotSdk
 import com.tangem.tap.common.analytics.handlers.BlockchainExceptionHandler
@@ -92,8 +90,6 @@ interface ApplicationEntryPoint {
 
     fun getOneTimeEventFilter(): OneTimeEventFilter
 
-    fun getGeneralUserWalletsListManager(): UserWalletsListManager
-
     fun getWasTwinsOnboardingShownUseCase(): WasTwinsOnboardingShownUseCase
 
     fun getSaveTwinsOnboardingShownUseCase(): SaveTwinsOnboardingShownUseCase
@@ -151,8 +147,6 @@ interface ApplicationEntryPoint {
 
     fun getTangemHotSdk(): TangemHotSdk
 
-    fun getHotWalletFeatureToggles(): HotWalletFeatureToggles
-
     fun getWcInitializeUseCase(): WcInitializeUseCase
 
     fun getTrackingContextProxy(): TrackingContextProxy

app/src/main/java/com/tangem/tap/LockTimerWorker.kt

@@ -6,9 +6,6 @@ import androidx.work.CoroutineWorker
 import androidx.work.WorkerParameters
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.settings.repositories.SettingsRepository
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
-import com.tangem.domain.wallets.legacy.asLockable
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import timber.log.Timber
@@ -18,21 +15,12 @@ class LockTimerWorker @AssistedInject constructor(
     @Assisted context: Context,
     @Assisted params: WorkerParameters,
     private val settingsRepository: SettingsRepository,
-    private val userWalletsListManager: UserWalletsListManager,
     private val userWalletsListRepository: UserWalletsListRepository,
-    private val hotWalletFeatureToggles: HotWalletFeatureToggles,
 ) : CoroutineWorker(context, params) {
 
     override suspend fun doWork(): Result {
         Timber.i("onStart job")
-        if (hotWalletFeatureToggles.isHotWalletEnabled) {
-            userWalletsListRepository.lockAllWallets()
-                .onRight {
-                    settingsRepository.setShouldOpenWelcomeScreenOnResume(value = true)
-                }
-        } else {
-            val userWalletsListManagerLockable = userWalletsListManager.asLockable() ?: return Result.failure()
-            userWalletsListManagerLockable.lock()
+        userWalletsListRepository.lockAllWallets().onRight {
             settingsRepository.setShouldOpenWelcomeScreenOnResume(value = true)
         }
         Timber.i("onStart job complete")

app/src/main/java/com/tangem/tap/LockUserWalletsTimer.kt

@@ -9,10 +9,7 @@ import androidx.work.WorkManager
 import com.tangem.common.routing.AppRoute
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.settings.repositories.SettingsRepository
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
-import com.tangem.domain.wallets.legacy.asLockable
 import com.tangem.domain.wallets.usecase.ClearAllHotWalletContextualUnlockUseCase
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.tap.LockTimerWorker.Companion.TAG
 import com.tangem.tap.common.extensions.dispatchNavigationAction
 import kotlinx.coroutines.CoroutineScope
@@ -22,16 +19,13 @@ import kotlinx.coroutines.launch
 import timber.log.Timber
 import java.util.concurrent.TimeUnit
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.minutes
 
 @Suppress("LongParameterList")
 internal class LockUserWalletsTimer(
     private val context: Context,
     private val settingsRepository: SettingsRepository,
     private val duration: Duration = with(Duration) { 5.minutes },
-    private val userWalletsListManager: UserWalletsListManager,
     private val userWalletsListRepository: UserWalletsListRepository,
-    private val hotWalletFeatureToggles: HotWalletFeatureToggles,
     private val coroutineScope: CoroutineScope,
     private val clearAllHotWalletContextualUnlockUseCase: ClearAllHotWalletContextualUnlockUseCase,
 ) : LifecycleOwner by context as LifecycleOwner,
@@ -59,9 +53,7 @@ internal class LockUserWalletsTimer(
             )
 
             if (shouldOpenWelcomeScreenOnResume) {
-                if (hotWalletFeatureToggles.isHotWalletEnabled) {
-                    clearAllHotWalletContextualUnlockUseCase.invoke()
-                }
+                clearAllHotWalletContextualUnlockUseCase.invoke()
                 store.dispatchNavigationAction { replaceAll(AppRoute.Welcome()) }
                 settingsRepository.setShouldOpenWelcomeScreenOnResume(value = false)
             }
@@ -115,38 +107,18 @@ internal class LockUserWalletsTimer(
      * This job used only when app is foreground when background use [JobScheduler]
      */
     private fun createDelayJob(): Job = coroutineScope.launch {
-        val startTime = System.currentTimeMillis()
-
         delay(duration)
 
-        if (hotWalletFeatureToggles.isHotWalletEnabled) {
-            val userWallets = userWalletsListRepository.userWalletsSync()
-            if (userWallets.isNotEmpty()) {
-                userWalletsListRepository.lockAllWallets()
-                    .onLeft {
-                        start()
-                    }
-                    .onRight {
-                        clearAllHotWalletContextualUnlockUseCase.invoke()
-                        store.dispatchNavigationAction { replaceAll(AppRoute.Welcome()) }
-                    }
-            }
-        } else {
-            val userWalletsListManager = userWalletsListManager.asLockable() ?: return@launch
-
-            if (userWalletsListManager.hasUserWallets) {
-                val currentTime = System.currentTimeMillis()
-
-                Timber.i(
-                    """
-                        Finished
-                        |- Millis passed: ${currentTime - startTime}
-                    """.trimIndent(),
-                )
-
-                userWalletsListManager.lock()
-                store.dispatchNavigationAction { replaceAll(AppRoute.Welcome()) }
-            }
+        val userWallets = userWalletsListRepository.userWalletsSync()
+        if (userWallets.isNotEmpty()) {
+            userWalletsListRepository.lockAllWallets()
+                .onLeft {
+                    start()
+                }
+                .onRight {
+                    clearAllHotWalletContextualUnlockUseCase.invoke()
+                    store.dispatchNavigationAction { replaceAll(AppRoute.Welcome()) }
+                }
         }
     }
 }

app/src/main/java/com/tangem/tap/MainActivity.kt

@@ -43,9 +43,7 @@ import com.tangem.domain.settings.SetGoogleServicesAvailabilityUseCase
 import com.tangem.domain.settings.ShouldInitiallyAskPermissionUseCase
 import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.staking.SendUnsubmittedHashesUseCase
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.usecase.ClearAllHotWalletContextualUnlockUseCase
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.features.tangempay.TangemPayFeatureToggles
 import com.tangem.features.tester.api.TesterMenuLauncher
 import com.tangem.google.GoogleServicesHelper
@@ -114,9 +112,6 @@ class MainActivity : AppCompatActivity(), ActivityResultCallbackHolder {
     @Inject
     lateinit var analyticsEventsHandler: AnalyticsEventHandler
 
-    @Inject
-    lateinit var userWalletsListManager: UserWalletsListManager
-
     @Inject
     @RootAppComponentContext
     internal lateinit var rootComponentContext: AppComponentContext
@@ -163,9 +158,6 @@ class MainActivity : AppCompatActivity(), ActivityResultCallbackHolder {
     @Inject
     internal lateinit var userWalletsListRepository: UserWalletsListRepository
 
-    @Inject
-    internal lateinit var hotWalletFeatureToggles: HotWalletFeatureToggles
-
     @Inject
     internal lateinit var clearAllHotWalletContextualUnlockUseCase: ClearAllHotWalletContextualUnlockUseCase
 
@@ -258,10 +250,8 @@ class MainActivity : AppCompatActivity(), ActivityResultCallbackHolder {
         lockUserWalletsTimer = LockUserWalletsTimer(
             context = this,
             settingsRepository = settingsRepository,
-            userWalletsListManager = userWalletsListManager,
             coroutineScope = mainScope,
             userWalletsListRepository = userWalletsListRepository,
-            hotWalletFeatureToggles = hotWalletFeatureToggles,
             clearAllHotWalletContextualUnlockUseCase = clearAllHotWalletContextualUnlockUseCase,
         )
 

app/src/main/java/com/tangem/tap/TangemApplication.kt

@@ -58,7 +58,6 @@ import com.tangem.domain.onboarding.repository.OnboardingRepository
 import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.builder.ColdUserWalletBuilder
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.repository.WalletsRepository
 import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
 import com.tangem.operations.attestation.api.TangemApiServiceSettings
@@ -146,9 +145,6 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
     private val oneTimeEventFilter: OneTimeEventFilter
         get() = entryPoint.getOneTimeEventFilter()
 
-    private val generalUserWalletsListManager: UserWalletsListManager
-        get() = entryPoint.getGeneralUserWalletsListManager()
-
     private val wasTwinsOnboardingShownUseCase: WasTwinsOnboardingShownUseCase
         get() = entryPoint.getWasTwinsOnboardingShownUseCase()
 
@@ -238,9 +234,6 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
     private val tangemHotSdk
         get() = entryPoint.getTangemHotSdk()
 
-    private val hotWalletFeatureToggles
-        get() = entryPoint.getHotWalletFeatureToggles()
-
     private val wcInitializeUseCase
         get() = entryPoint.getWcInitializeUseCase()
 
@@ -382,7 +375,6 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
                     appThemeModeRepository = appThemeModeRepository,
                     balanceHidingRepository = balanceHidingRepository,
                     walletsRepository = walletsRepository,
-                    generalUserWalletsListManager = generalUserWalletsListManager,
                     wasTwinsOnboardingShownUseCase = wasTwinsOnboardingShownUseCase,
                     saveTwinsOnboardingShownUseCase = saveTwinsOnboardingShownUseCase,
                     cardRepository = cardRepository,
@@ -407,7 +399,6 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
                     userTokensResponseStore = userTokensResponseStore,
                     userWalletsListRepository = userWalletsListRepository,
                     tangemHotSdk = tangemHotSdk,
-                    hotWalletFeatureToggles = hotWalletFeatureToggles,
                     trackingContextProxy = trackingContextProxy,
                 ),
             ),

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

@@ -2,7 +2,6 @@ package com.tangem.tap.common.redux
 
 import com.tangem.tap.common.redux.global.globalReducer
 import com.tangem.tap.features.details.redux.DetailsReducer
-import com.tangem.tap.features.welcome.redux.WelcomeReducer
 import com.tangem.tap.proxy.redux.DaggerGraphReducer
 import org.rekotlin.Action
 
@@ -12,7 +11,6 @@ fun appReducer(action: Action, state: AppState): AppState {
     return AppState(
         globalState = globalReducer(action, state),
         detailsState = DetailsReducer.reduce(action, state),
-        welcomeState = WelcomeReducer.reduce(action, state),
         daggerGraphState = DaggerGraphReducer.reduce(action, state),
     )
 }

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

@@ -7,8 +7,6 @@ import com.tangem.tap.features.details.redux.DetailsMiddleware
 import com.tangem.tap.features.details.redux.DetailsState
 import com.tangem.tap.features.onboarding.products.wallet.redux.BackupMiddleware
 import com.tangem.tap.features.wallet.redux.middlewares.TradeCryptoMiddleware
-import com.tangem.tap.features.welcome.redux.WelcomeMiddleware
-import com.tangem.tap.features.welcome.redux.WelcomeState
 import com.tangem.tap.proxy.redux.DaggerGraphMiddleware
 import com.tangem.tap.proxy.redux.DaggerGraphState
 import org.rekotlin.Middleware
@@ -17,7 +15,6 @@ import org.rekotlin.StateType
 data class AppState(
     val globalState: GlobalState = GlobalState(),
     val detailsState: DetailsState = DetailsState(),
-    val welcomeState: WelcomeState = WelcomeState(),
     val daggerGraphState: DaggerGraphState = DaggerGraphState(),
 ) : StateType {
 
@@ -28,7 +25,6 @@ data class AppState(
                 GlobalMiddleware.handler,
                 DetailsMiddleware().detailsMiddleware,
                 BackupMiddleware().backupMiddleware,
-                WelcomeMiddleware().middleware,
                 LockUserWalletsTimerMiddleware().middleware,
                 AccessCodeRequestPolicyMiddleware().middleware,
                 DaggerGraphMiddleware.daggerGraphMiddleware,

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

@@ -27,8 +27,6 @@ internal object LegacyMiddleware {
             { action ->
                 when (action) {
                     is LegacyAction.PrepareDetailsScreen -> {
-                        val walletsRepository = store.inject(DaggerGraphState::walletsRepository)
-
                         selectedUserWallet()
                             .distinctUntilChanged { old, new ->
                                 if (old is UserWallet.Cold && new is UserWallet.Cold) {
@@ -39,9 +37,7 @@ internal object LegacyMiddleware {
                                 }
                             }
                             .onEach { selectedUserWallet ->
-                                val initializedAppSettingsStateContent = initializeAppSettingsState(
-                                    shouldSaveUserWallets = walletsRepository.shouldSaveUserWalletsSync(),
-                                )
+                                val initializedAppSettingsStateContent = initializeAppSettingsState()
                                 store.dispatchWithMain(
                                     DetailsAction.PrepareScreen(
                                         scanResponse = (selectedUserWallet as? UserWallet.Cold)?.scanResponse,
@@ -60,24 +56,15 @@ internal object LegacyMiddleware {
     }
 
     private fun selectedUserWallet(): Flow<UserWallet> {
-        val hotWalletFeatureToggles = store.inject(DaggerGraphState::hotWalletFeatureToggles)
-        return if (hotWalletFeatureToggles.isHotWalletEnabled) {
-            store.inject(DaggerGraphState::userWalletsListRepository).selectedUserWallet.filterNotNull()
-        } else {
-            val userWalletsListManager = store.inject(DaggerGraphState::generalUserWalletsListManager)
-            userWalletsListManager.selectedUserWallet
-        }
+        return store.inject(DaggerGraphState::userWalletsListRepository).selectedUserWallet.filterNotNull()
     }
 
     /**
      * LEGACY: We need to initialize [AppSettingsState] async to avoid drawing blocking
      * previously it was initialized in runBlocking and blocked details screen
      */
-    private suspend fun initializeAppSettingsState(shouldSaveUserWallets: Boolean): AppSettingsState {
+    private suspend fun initializeAppSettingsState(): AppSettingsState {
         return AppSettingsState(
-            isBiometricsAvailable = tangemSdkManager.checkCanUseBiometry(),
-            saveWallets = shouldSaveUserWallets,
-            saveAccessCodes = store.inject(DaggerGraphState::settingsRepository).shouldSaveAccessCodes(),
             selectedAppCurrency = store.state.globalState.appCurrency,
             selectedThemeMode = store.inject(DaggerGraphState::appThemeModeRepository).getAppThemeMode().firstOrNull()
                 ?: AppThemeMode.DEFAULT,

app/src/main/java/com/tangem/tap/data/DefaultTangemPayStorage.kt

@@ -1,7 +1,12 @@
 package com.tangem.tap.data
 
 import android.content.Context
+import com.squareup.moshi.JsonAdapter
 import com.squareup.moshi.Moshi
+import com.squareup.moshi.Types
+import com.tangem.data.pay.entity.WithdrawStoreData
+import com.tangem.data.pay.util.WithdrawStateConverter
+import com.tangem.data.pay.util.WithdrawStoreDataConverter
 import com.tangem.datasource.di.NetworkMoshi
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.datasource.local.preferences.PreferencesKeys
@@ -11,10 +16,12 @@ import com.tangem.datasource.local.preferences.utils.getSyncOrNull
 import com.tangem.datasource.local.preferences.utils.store
 import com.tangem.datasource.local.visa.TangemPayStorage
 import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.pay.TangemPayWithdrawState
 import com.tangem.domain.visa.model.TangemPayAuthTokens
 import com.tangem.sdk.storage.AndroidSecureStorageV2
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.withContext
 import java.util.UUID
 import javax.inject.Inject
@@ -41,6 +48,18 @@ internal class DefaultTangemPayStorage @Inject constructor(
     }
 
     private val tokensAdapter by lazy { moshi.adapter(TangemPayAuthTokens::class.java) }
+    private val withdrawStoreDataConverter by lazy { WithdrawStoreDataConverter() }
+    private val withdrawStateConverter by lazy { WithdrawStateConverter() }
+
+    private val listType by lazy {
+        Types.newParameterizedType(List::class.java, WithdrawStoreData::class.java)
+    }
+    private val mapType by lazy {
+        Types.newParameterizedType(Map::class.java, String::class.java, listType)
+    }
+    private val adapter: JsonAdapter<Map<String, List<WithdrawStoreData>>> by lazy {
+        appPreferencesStore.moshi.adapter(mapType)
+    }
 
     override suspend fun storeCustomerWalletAddress(userWalletId: UserWalletId, customerWalletAddress: String) {
         withContext(dispatcherProvider.io) {
@@ -131,33 +150,76 @@ internal class DefaultTangemPayStorage @Inject constructor(
         return appPreferencesStore.getSyncOrNull(PreferencesKeys.getTangemPayCheckCustomerByWalletId(userWalletId))
     }
 
-    override suspend fun storeWithdrawOrder(userWalletId: UserWalletId, orderId: String) {
+    override suspend fun storeActiveWithdrawOrderId(userWalletId: UserWalletId, orderId: String) {
         appPreferencesStore.editData { mutablePreferences ->
-            val orders = mutablePreferences.getObjectMap<String>(PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY)
+            val orders = mutablePreferences.getObjectMap<String>(PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY)
                 .plus(createWithdrawOrderIdKey(userWalletId) to orderId)
             mutablePreferences.setObjectMap(
-                key = PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY,
+                key = PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY,
                 value = orders,
             )
         }
     }
 
-    override suspend fun getWithdrawOrderId(userWalletId: UserWalletId): String? {
-        val orders = appPreferencesStore.getObjectMapSync<String>(PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY)
+    override suspend fun storeWithdrawOrder(userWalletId: UserWalletId, data: TangemPayWithdrawState) {
+        appPreferencesStore.editData { prefs ->
+            val walletKey = createWithdrawOrderIdKey(userWalletId)
+            val currentMap = prefs[PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY]
+                ?.let(adapter::fromJson)
+                .orEmpty()
+            val newItem = withdrawStoreDataConverter.convert(data)
+            val currentList = currentMap[walletKey].orEmpty()
+            val updatedList = buildList(currentList.size + 1) {
+                for (item in currentList) { if (item.orderId != newItem.orderId) add(item) }
+                add(newItem)
+            }
+            prefs[PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY] =
+                adapter.toJson(currentMap + (walletKey to updatedList))
+        }
+    }
+
+    override suspend fun getActiveWithdrawOrderId(userWalletId: UserWalletId): String? {
+        val orders = appPreferencesStore.getObjectMapSync<String>(PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY)
         return orders[createWithdrawOrderIdKey(userWalletId)]
     }
 
-    override suspend fun deleteWithdrawOrder(userWalletId: UserWalletId) {
+    override suspend fun getWithdrawOrders(userWalletId: UserWalletId): List<TangemPayWithdrawState> {
+        val map = appPreferencesStore.data.firstOrNull()
+            ?.get(PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY)?.let(adapter::fromJson).orEmpty()
+        return map[createWithdrawOrderIdKey(userWalletId)].orEmpty().map(withdrawStateConverter::convert)
+    }
+
+    override suspend fun deleteActiveWithdrawOrder(userWalletId: UserWalletId) {
         appPreferencesStore.editData { mutablePreferences ->
-            val orders = mutablePreferences.getObjectMap<String>(PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY)
+            val orders = mutablePreferences.getObjectMap<String>(PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY)
                 .minus(createWithdrawOrderIdKey(userWalletId))
             mutablePreferences.setObjectMap(
-                key = PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY,
+                key = PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY,
                 value = orders,
             )
         }
     }
 
+    override suspend fun deleteWithdrawOrder(userWalletId: UserWalletId, orderId: String) {
+        appPreferencesStore.editData { prefs ->
+            val walletKey = createWithdrawOrderIdKey(userWalletId)
+            val currentMap = prefs[PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY]?.let(adapter::fromJson)
+                .orEmpty()
+            val currentList = currentMap[walletKey].orEmpty()
+            val updatedList = buildList(currentList.size) {
+                for (item in currentList) {
+                    if (item.orderId != orderId) add(item)
+                }
+            }
+            val updatedMap = if (updatedList.isEmpty()) {
+                currentMap - walletKey
+            } else {
+                currentMap + (walletKey to updatedList)
+            }
+            prefs[PreferencesKeys.TANGEM_PAY_WITHDRAW_ORDERS_KEY] = adapter.toJson(updatedMap)
+        }
+    }
+
     override suspend fun storeHideOnboardingBanner(userWalletId: UserWalletId, hide: Boolean) {
         withContext(dispatcherProvider.io) {
             appPreferencesStore.store(PreferencesKeys.getTangemPayHideOnboardingKey(userWalletId), hide)

app/src/main/java/com/tangem/tap/data/RuntimeUserWalletsStore.kt

@@ -1,39 +0,0 @@
-package com.tangem.tap.data
-
-import com.tangem.common.CompletionResult
-import com.tangem.datasource.local.userwallet.UserWalletsStore
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
-import kotlinx.coroutines.flow.Flow
-
-// FIXME: Workaround, remove it once the normal UserWalletsStore has been implemented
-// [REDACTED_JIRA]
-internal class RuntimeUserWalletsStore(
-    private val userWalletsListManager: UserWalletsListManager,
-) : UserWalletsStore {
-
-    override val selectedUserWalletOrNull: UserWallet?
-        get() = userWalletsListManager.selectedUserWalletSync
-
-    override val userWallets: Flow<List<UserWallet>>
-        get() = userWalletsListManager.userWallets
-
-    override val userWalletsSync: List<UserWallet>
-        get() = userWalletsListManager.userWalletsSync
-
-    override fun getSyncOrNull(key: UserWalletId): UserWallet? {
-        return userWalletsListManager.userWalletsSync.firstOrNull { it.walletId == key }
-    }
-
-    override fun getSyncStrict(key: UserWalletId): UserWallet {
-        return requireNotNull(getSyncOrNull(key)) { "Unable to find user wallet with provided ID: $key" }
-    }
-
-    override suspend fun update(
-        userWalletId: UserWalletId,
-        update: suspend (UserWallet) -> UserWallet,
-    ): CompletionResult<UserWallet> {
-        return userWalletsListManager.update(userWalletId, update)
-    }
-}

app/src/main/java/com/tangem/tap/data/UserWalletsStoreRepositoryProxy.kt

@@ -1,53 +0,0 @@
-package com.tangem.tap.data
-
-import com.tangem.common.CompletionResult
-import com.tangem.common.catching
-import com.tangem.datasource.local.userwallet.UserWalletsStore
-import com.tangem.domain.common.wallets.UserWalletsListRepository
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.models.wallet.UserWalletId
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
-
-class UserWalletsStoreRepositoryProxy(
-    private val userWalletsListRepository: UserWalletsListRepository,
-) : UserWalletsStore {
-
-    override val selectedUserWalletOrNull: UserWallet?
-        get() = userWalletsListRepository.selectedUserWallet.value
-
-    override val userWallets: Flow<List<UserWallet>>
-        get() = flow {
-            userWalletsListRepository.load()
-            userWalletsListRepository.userWallets.collect {
-                emit(requireNotNull(it))
-            }
-        }
-
-    override val userWalletsSync: List<UserWallet>
-        get() = userWalletsListRepository.userWallets.value.orEmpty()
-
-    override fun getSyncOrNull(key: UserWalletId): UserWallet? {
-        return userWalletsListRepository.userWallets.value?.find { it.walletId == key }
-    }
-
-    override fun getSyncStrict(key: UserWalletId): UserWallet {
-        return requireNotNull(getSyncOrNull(key)) { "Unable to find user wallet with provided ID: $key" }
-    }
-
-    override suspend fun update(
-        userWalletId: UserWalletId,
-        update: suspend (UserWallet) -> UserWallet,
-    ): CompletionResult<UserWallet> {
-        return catching {
-            val userWallet = userWalletsListRepository.userWallets.value?.find { it.walletId == userWalletId }
-            requireNotNull(userWallet) { "Unable to find user wallet with provided ID: $userWalletId" }
-            val updatedUserWallet = update(userWallet)
-            userWalletsListRepository.saveWithoutLock(
-                userWallet = updatedUserWallet,
-                canOverride = true,
-            )
-            updatedUserWallet
-        }
-    }
-}

app/src/main/java/com/tangem/tap/di/data/UserWalletsStoreModule.kt

@@ -1,32 +0,0 @@
-package com.tangem.tap.di.data
-
-import com.tangem.datasource.local.userwallet.UserWalletsStore
-import com.tangem.domain.common.wallets.UserWalletsListRepository
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
-import com.tangem.tap.data.RuntimeUserWalletsStore
-import com.tangem.tap.data.UserWalletsStoreRepositoryProxy
-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 UserWalletsStoreModule {
-
-    @Provides
-    @Singleton
-    fun provideUserWalletsStore(
-        userWalletsListManager: UserWalletsListManager,
-        userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
-    ): UserWalletsStore {
-        return if (hotWalletFeatureToggles.isHotWalletEnabled) {
-            UserWalletsStoreRepositoryProxy(userWalletsListRepository)
-        } else {
-            RuntimeUserWalletsStore(userWalletsListManager = userWalletsListManager)
-        }
-    }
-}

app/src/main/java/com/tangem/tap/di/domain/AccountDomainModule.kt

@@ -9,6 +9,7 @@ import com.tangem.domain.account.status.usecase.RecoverCryptoPortfolioUseCase
 import com.tangem.domain.account.status.utils.CryptoCurrencyBalanceFetcher
 import com.tangem.domain.account.tokens.MainAccountTokensMigration
 import com.tangem.domain.account.usecase.*
+import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.feature.referral.data.ExternalReferralRepository
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.Module
@@ -94,10 +95,12 @@ internal object AccountDomainModule {
     @Provides
     @Singleton
     fun provideIsAccountsModeEnabledUseCase(
+        userWalletsListRepository: UserWalletsListRepository,
         accountsCRUDRepository: AccountsCRUDRepository,
         accountsFeatureToggles: AccountsFeatureToggles,
     ): IsAccountsModeEnabledUseCase {
         return IsAccountsModeEnabledUseCase(
+            userWalletsListRepository = userWalletsListRepository,
             crudRepository = accountsCRUDRepository,
             accountsFeatureToggles = accountsFeatureToggles,
         )

app/src/main/java/com/tangem/tap/di/domain/CardDomainModule.kt

@@ -9,9 +9,7 @@ import com.tangem.domain.demo.IsDemoCardUseCase
 import com.tangem.domain.demo.models.DemoConfig
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.derivations.DerivationsRepository
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.usecase.*
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.tap.domain.card.DefaultDeleteSavedAccessCodesUseCase
 import com.tangem.tap.domain.card.DefaultResetCardUseCase
@@ -42,16 +40,8 @@ internal object CardDomainModule {
     }
 
     @Provides
-    fun provideIsNeedToBackupUseCase(
-        userWalletsListManager: UserWalletsListManager,
-        userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
-    ): IsNeedToBackupUseCase {
-        return IsNeedToBackupUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
+    fun provideIsNeedToBackupUseCase(userWalletsListRepository: UserWalletsListRepository): IsNeedToBackupUseCase {
+        return IsNeedToBackupUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides

app/src/main/java/com/tangem/tap/di/domain/CardLegacyDomainModule.kt

@@ -3,9 +3,7 @@ package com.tangem.tap.di.domain
 import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 import com.tangem.domain.card.ScanCardProcessor
 import com.tangem.domain.common.wallets.UserWalletsListRepository
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.usecase.GenerateWalletNameUseCase
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.tap.domain.scanCard.CardScanningFeatureToggles
 import com.tangem.tap.domain.scanCard.DefaultScanCardProcessor
 import com.tangem.tap.domain.scanCard.LegacyScanProcessor
@@ -34,14 +32,8 @@ internal object CardLegacyDomainModule {
     @Provides
     @Singleton
     fun providesWalletNameGenerateUseCase(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
     ): GenerateWalletNameUseCase {
-        return GenerateWalletNameUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
+        return GenerateWalletNameUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 }

app/src/main/java/com/tangem/tap/di/domain/EarnDomainModule.kt

@@ -0,0 +1,58 @@
+package com.tangem.tap.di.domain
+
+import com.tangem.domain.common.wallets.UserWalletsListRepository
+import com.tangem.domain.earn.repository.EarnRepository
+import com.tangem.domain.earn.usecase.*
+import com.tangem.domain.networks.multi.MultiNetworkStatusSupplier
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@Module
+@InstallIn(SingletonComponent::class)
+object EarnDomainModule {
+
+    @Provides
+    fun provideFetchEarnNetworksUseCase(repository: EarnRepository): FetchEarnNetworksUseCase {
+        return FetchEarnNetworksUseCase(repository)
+    }
+
+    @Provides
+    fun provideManageEarnNetworksUseCase(
+        earnRepository: EarnRepository,
+        userWalletsListRepository: UserWalletsListRepository,
+        multiNetworkStatusSupplier: MultiNetworkStatusSupplier,
+    ): GetEarnNetworksUseCase {
+        return GetEarnNetworksUseCase(
+            earnRepository = earnRepository,
+            userWalletsListRepository = userWalletsListRepository,
+            multiNetworkStatusSupplier = multiNetworkStatusSupplier,
+        )
+    }
+
+    @Provides
+    fun provideFetchTopEarnTokensUseCase(repository: EarnRepository): FetchTopEarnTokensUseCase {
+        return FetchTopEarnTokensUseCase(repository)
+    }
+
+    @Provides
+    fun provideManageTopEarnTokensUseCase(repository: EarnRepository): GetTopEarnTokensUseCase {
+        return GetTopEarnTokensUseCase(repository)
+    }
+
+    @Provides
+    fun provideGetEarnTokensBatchFlowUseCase(repository: EarnRepository): GetEarnTokensBatchFlowUseCase {
+        return GetEarnTokensBatchFlowUseCase(repository)
+    }
+
+    @Provides
+    fun provideGetEarnFilterUseCase(repository: EarnRepository): GetEarnFilterUseCase {
+        return GetEarnFilterUseCase(repository)
+    }
+
+    @Provides
+    fun provideSetEarnFilterUseCase(repository: EarnRepository): SetEarnFilterUseCase {
+        return SetEarnFilterUseCase(repository)
+    }
+}

app/src/main/java/com/tangem/tap/di/domain/HotWalletDomainModule.kt

@@ -1,9 +1,13 @@
 package com.tangem.tap.di.domain
 
+import com.tangem.domain.hotwallet.CheckHotWalletUpgradeBannerUseCase
+import com.tangem.domain.hotwallet.CloseHotWalletUpgradeBannerUseCase
 import com.tangem.domain.hotwallet.GetAccessCodeSkippedUseCase
+import com.tangem.domain.hotwallet.GetUpgradeBannerClosureTimestampUseCase
 import com.tangem.domain.hotwallet.IsHotWalletCreationSupported
 import com.tangem.domain.hotwallet.IsAccessCodeSimpleUseCase
 import com.tangem.domain.hotwallet.SetAccessCodeSkippedUseCase
+import com.tangem.domain.hotwallet.ShouldShowUpgradeHotWalletBannerUseCase
 import com.tangem.domain.hotwallet.repository.HotWalletRepository
 import dagger.Module
 import dagger.Provides
@@ -40,4 +44,36 @@ internal object HotWalletDomainModule {
     ): IsHotWalletCreationSupported {
         return IsHotWalletCreationSupported(hotWalletRepository)
     }
+
+    @Provides
+    @Singleton
+    fun provideCheckHotWalletUpgradeBannerUseCase(
+        hotWalletRepository: HotWalletRepository,
+    ): CheckHotWalletUpgradeBannerUseCase {
+        return CheckHotWalletUpgradeBannerUseCase(hotWalletRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideCloseHotWalletUpgradeBannerUseCase(
+        hotWalletRepository: HotWalletRepository,
+    ): CloseHotWalletUpgradeBannerUseCase {
+        return CloseHotWalletUpgradeBannerUseCase(hotWalletRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideShouldShowUpgradeHotWalletBannerUseCase(
+        hotWalletRepository: HotWalletRepository,
+    ): ShouldShowUpgradeHotWalletBannerUseCase {
+        return ShouldShowUpgradeHotWalletBannerUseCase(hotWalletRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetUpgradeBannerClosureTimestampUseCase(
+        hotWalletRepository: HotWalletRepository,
+    ): GetUpgradeBannerClosureTimestampUseCase {
+        return GetUpgradeBannerClosureTimestampUseCase(hotWalletRepository)
+    }
 }

app/src/main/java/com/tangem/tap/di/domain/MarketsDomainModule.kt

@@ -13,8 +13,6 @@ 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
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.Module
 import dagger.Provides
@@ -107,15 +105,11 @@ object MarketsDomainModule {
     @Provides
     @Singleton
     fun provideFilterNetworksUseCase(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
         excludedBlockchains: ExcludedBlockchains,
     ): FilterAvailableNetworksForWalletUseCase {
         return FilterAvailableNetworksForWalletUseCase(
-            userWalletsListManager = userWalletsListManager,
             userWalletsListRepository = userWalletsListRepository,
-            shouldUseNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
             excludedBlockchains = excludedBlockchains,
         )
     }

app/src/main/java/com/tangem/tap/di/domain/TransactionDomainModule.kt

@@ -5,6 +5,7 @@ import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.demo.models.DemoConfig
 import com.tangem.domain.networks.single.SingleNetworkStatusFetcher
 import com.tangem.domain.networks.single.SingleNetworkStatusSupplier
+import com.tangem.domain.notifications.repository.PushNotificationsRepository
 import com.tangem.domain.tokens.GetMultiCryptoCurrencyStatusUseCase
 import com.tangem.domain.tokens.GetSingleCryptoCurrencyStatusUseCase
 import com.tangem.domain.tokens.GetViewedTokenReceiveWarningUseCase
@@ -56,6 +57,7 @@ internal object TransactionDomainModule {
         singleNetworkStatusFetcher: SingleNetworkStatusFetcher,
         tangemHotWalletSignerFactory: TangemHotWalletSigner.Factory,
         dispatchers: CoroutineDispatcherProvider,
+        pushNotificationsRepository: PushNotificationsRepository,
     ): SendTransactionUseCase {
         return SendTransactionUseCase(
             demoConfig = DemoConfig,
@@ -65,6 +67,7 @@ internal object TransactionDomainModule {
             singleNetworkStatusFetcher = singleNetworkStatusFetcher,
             parallelUpdatingScope = CoroutineScope(SupervisorJob() + dispatchers.io),
             getHotWalletSigner = tangemHotWalletSignerFactory::create,
+            pushNotificationsRepository = pushNotificationsRepository,
         )
     }
 

app/src/main/java/com/tangem/tap/di/domain/WalletsDomainModule.kt

@@ -1,9 +1,9 @@
 package com.tangem.tap.di.domain
 
 import com.tangem.core.analytics.api.AnalyticsEventHandler
+import com.tangem.domain.account.repository.AccountsCRUDRepository
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.redux.ReduxStateHolder
-import com.tangem.domain.tokens.repository.CurrenciesRepository
 import com.tangem.domain.transaction.WalletAddressServiceRepository
 import com.tangem.domain.transaction.usecase.ParseSharedAddressUseCase
 import com.tangem.domain.transaction.usecase.ValidateWalletAddressUseCase
@@ -13,7 +13,6 @@ import com.tangem.domain.wallets.delegate.DefaultUserWalletsSyncDelegate
 import com.tangem.domain.wallets.delegate.UserWalletsSyncDelegate
 import com.tangem.domain.wallets.derivations.DerivationsRepository
 import com.tangem.domain.wallets.hot.HotWalletAccessor
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.repository.WalletNamesMigrationRepository
 import com.tangem.domain.wallets.repository.WalletsPromoRepository
 import com.tangem.domain.wallets.repository.WalletsRepository
@@ -23,7 +22,6 @@ import com.tangem.domain.yield.supply.usecase.YieldSupplyApyFlowUseCase
 import com.tangem.domain.yield.supply.usecase.YieldSupplyApyUpdateUseCase
 import com.tangem.feature.wallet.presentation.wallet.domain.IsWalletNFTEnabledSyncUseCase
 import com.tangem.feature.wallet.presentation.wallet.domain.WalletNameMigrationUseCase
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.operations.attestation.CardArtworksProvider
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.Module
@@ -39,105 +37,61 @@ internal object WalletsDomainModule {
 
     @Provides
     fun providesUserWalletsSyncDelegate(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
-        dispatchers: CoroutineDispatcherProvider,
     ): UserWalletsSyncDelegate {
-        return DefaultUserWalletsSyncDelegate(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-            dispatchers = dispatchers,
-        )
+        return DefaultUserWalletsSyncDelegate(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides
     @Singleton
-    fun providesGetWalletsUseCase(
-        userWalletsListManager: UserWalletsListManager,
-        userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
-    ): GetWalletsUseCase {
-        return GetWalletsUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewListRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
+    fun providesGetWalletsUseCase(userWalletsListRepository: UserWalletsListRepository): GetWalletsUseCase {
+        return GetWalletsUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides
     @Singleton
     fun providesWalletNameMigrationUseCase(
-        userWalletsListManager: UserWalletsListManager,
         walletNamesMigrationRepository: WalletNamesMigrationRepository,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
     ): WalletNameMigrationUseCase {
         return WalletNameMigrationUseCase(
-            userWalletsListManager = userWalletsListManager,
             walletNamesMigrationRepository = walletNamesMigrationRepository,
             userWalletsListRepository = userWalletsListRepository,
-            useNewListRepository = hotWalletFeatureToggles.isHotWalletEnabled,
         )
     }
 
     @Provides
     @Singleton
-    fun providesGetUserWalletUseCase(
-        userWalletsListManager: UserWalletsListManager,
-        userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
-    ): GetUserWalletUseCase {
-        return GetUserWalletUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewListRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
+    fun providesGetUserWalletUseCase(userWalletsListRepository: UserWalletsListRepository): GetUserWalletUseCase {
+        return GetUserWalletUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides
     @Singleton
     fun providesGetSelectedWalletSyncUseCase(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
     ): GetSelectedWalletSyncUseCase {
-        return GetSelectedWalletSyncUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
+        return GetSelectedWalletSyncUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides
     @Singleton
     fun providesGetSelectedWalletUseCase(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
     ): GetSelectedWalletUseCase {
-        return GetSelectedWalletUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
+        return GetSelectedWalletUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides
     @Singleton
     fun providesSaveWalletUseCase(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
         walletsRepository: WalletsRepository,
         analyticsEventHandler: AnalyticsEventHandler,
     ): SaveWalletUseCase {
         return SaveWalletUseCase(
-            userWalletsListManager = userWalletsListManager,
             userWalletsListRepository = userWalletsListRepository,
             walletsRepository = walletsRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
             analyticsEventHandler = analyticsEventHandler,
         )
     }
@@ -145,15 +99,9 @@ internal object WalletsDomainModule {
     @Provides
     @Singleton
     fun providesIsWalletAlreadySavedUseCase(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
     ): IsWalletAlreadySavedUseCase {
-        return IsWalletAlreadySavedUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
+        return IsWalletAlreadySavedUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides
@@ -170,12 +118,6 @@ internal object WalletsDomainModule {
         return GetExploreUrlUseCase(walletsManagersFacade = walletsManagersFacade)
     }
 
-    @Provides
-    @Singleton
-    fun providesUnlockWalletsUseCase(userWalletsListManager: UserWalletsListManager): UnlockWalletsUseCase {
-        return UnlockWalletsUseCase(userWalletsListManager = userWalletsListManager)
-    }
-
     @Provides
     @Singleton
     fun providesUnlockWalletUseCase(
@@ -203,31 +145,19 @@ internal object WalletsDomainModule {
     @Provides
     @Singleton
     fun providesSelectWalletUseCase(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
         reduxStateHolder: ReduxStateHolder,
     ): SelectWalletUseCase {
         return SelectWalletUseCase(
-            userWalletsListManager = userWalletsListManager,
             userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
             reduxStateHolder = reduxStateHolder,
         )
     }
 
     @Provides
     @Singleton
-    fun providesUpdateWalletUseCase(
-        userWalletsListManager: UserWalletsListManager,
-        userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
-    ): UpdateWalletUseCase {
-        return UpdateWalletUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
+    fun providesUpdateWalletUseCase(userWalletsListRepository: UserWalletsListRepository): UpdateWalletUseCase {
+        return UpdateWalletUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides
@@ -244,44 +174,14 @@ internal object WalletsDomainModule {
 
     @Provides
     @Singleton
-    fun providesGetWalletsSyncUseCase(
-        userWalletsListManager: UserWalletsListManager,
-        userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
-    ): GetWalletNamesUseCase {
-        return GetWalletNamesUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
+    fun providesGetWalletsSyncUseCase(userWalletsListRepository: UserWalletsListRepository): GetWalletNamesUseCase {
+        return GetWalletNamesUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides
     @Singleton
-    fun providesDeleteWalletUseCase(
-        userWalletsListManager: UserWalletsListManager,
-        userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
-    ): DeleteWalletUseCase {
-        return DeleteWalletUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
-    }
-
-    @Provides
-    @Singleton
-    fun providesShouldSaveUserWalletsSyncUseCase(
-        walletsRepository: WalletsRepository,
-    ): ShouldSaveUserWalletsSyncUseCase {
-        return ShouldSaveUserWalletsSyncUseCase(walletsRepository = walletsRepository)
-    }
-
-    @Provides
-    @Singleton
-    fun providesShouldSaveUserWalletsUseCase(walletsRepository: WalletsRepository): ShouldSaveUserWalletsUseCase {
-        return ShouldSaveUserWalletsUseCase(walletsRepository = walletsRepository)
+    fun providesDeleteWalletUseCase(userWalletsListRepository: UserWalletsListRepository): DeleteWalletUseCase {
+        return DeleteWalletUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides
@@ -353,15 +253,9 @@ internal object WalletsDomainModule {
     @Provides
     @Singleton
     fun providesGetSavedWalletChangesIdUseCase(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
     ): GetSavedWalletsCountUseCase {
-        return GetSavedWalletsCountUseCase(
-            userWalletsListManager = userWalletsListManager,
-            userWalletsListRepository = userWalletsListRepository,
-            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
-        )
+        return GetSavedWalletsCountUseCase(userWalletsListRepository = userWalletsListRepository)
     }
 
     @Provides
@@ -378,11 +272,11 @@ internal object WalletsDomainModule {
     @Singleton
     fun providesSetNotificationsEnabledUseCase(
         walletsRepository: WalletsRepository,
-        currenciesRepository: CurrenciesRepository,
+        accountsCRUDRepository: AccountsCRUDRepository,
     ): SetNotificationsEnabledUseCase {
         return SetNotificationsEnabledUseCase(
             walletsRepository = walletsRepository,
-            currenciesRepository = currenciesRepository,
+            accountsCRUDRepository = accountsCRUDRepository,
         )
     }
 
@@ -485,15 +379,11 @@ internal object WalletsDomainModule {
     @Provides
     @Singleton
     fun provideGetWalletsForAutomaticallyPushEnablingUseCase(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
         dispatcherProvider: CoroutineDispatcherProvider,
     ): GetWalletsForAutomaticallyPushEnablingUseCase {
         return GetWalletsForAutomaticallyPushEnablingUseCase(
-            userWalletsListManager = userWalletsListManager,
             userWalletsListRepository = userWalletsListRepository,
-            shouldUseNewListRepository = hotWalletFeatureToggles.isHotWalletEnabled,
             dispatchers = dispatcherProvider,
         )
     }
@@ -511,4 +401,12 @@ internal object WalletsDomainModule {
     fun provideSyncWalletWithRemoteUseCase(walletsRepository: WalletsRepository): SyncWalletWithRemoteUseCase {
         return SyncWalletWithRemoteUseCase(walletsRepository = walletsRepository)
     }
+
+    @Provides
+    @Singleton
+    fun provideApplyUserWalletListSortingUseCase(
+        userWalletsListRepository: UserWalletsListRepository,
+    ): ApplyUserWalletListSortingUseCase {
+        return ApplyUserWalletListSortingUseCase(userWalletsListRepository = userWalletsListRepository)
+    }
 }

app/src/main/java/com/tangem/tap/domain/scanCard/DefaultScanCardProcessor.kt

@@ -20,6 +20,7 @@ internal class DefaultScanCardProcessor(
         cardId: String?,
         allowsRequestAccessCodeFromRepository: Boolean,
         analyticsSource: AnalyticsParam.ScreensSources,
+        shouldCheckIsAlreadyActivated: Boolean,
     ): CompletionResult<ScanResponse> {
         return if (isNewCardScanningEnabled) {
             UseCaseScanProcessor.scan(cardId, allowsRequestAccessCodeFromRepository)
@@ -28,6 +29,7 @@ internal class DefaultScanCardProcessor(
                 analyticsSource = analyticsSource,
                 cardId = cardId,
                 allowsRequestAccessCodeFromRepository = allowsRequestAccessCodeFromRepository,
+                shouldCheckIsAlreadyActivated = shouldCheckIsAlreadyActivated,
             )
         }
     }
@@ -35,6 +37,7 @@ internal class DefaultScanCardProcessor(
     @Suppress("LongParameterList")
     override suspend fun scan(
         analyticsSource: AnalyticsParam.ScreensSources,
+        shouldCheckIsAlreadyActivated: Boolean,
         cardId: String?,
         onProgressStateChange: suspend (showProgress: Boolean) -> Unit,
         onWalletNotCreated: suspend () -> Unit,
@@ -56,6 +59,7 @@ internal class DefaultScanCardProcessor(
         } else {
             legacyScanProcessor.scan(
                 analyticsSource = analyticsSource,
+                shouldCheckIsAlreadyActivated = shouldCheckIsAlreadyActivated,
                 cardId = cardId,
                 onProgressStateChange = onProgressStateChange,
                 onWalletNotCreated = onWalletNotCreated,

app/src/main/java/com/tangem/tap/domain/scanCard/LegacyScanProcessor.kt

@@ -19,15 +19,15 @@ import com.tangem.core.ui.R
 import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.core.ui.extensions.toWrappedList
 import com.tangem.core.ui.message.dialog.Dialogs
-import com.tangem.domain.common.extensions.withMainContext
 import com.tangem.domain.card.common.util.twinsIsTwinned
+import com.tangem.domain.common.extensions.withMainContext
 import com.tangem.domain.feedback.models.FeedbackEmailType
 import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.domain.wallets.builder.UserWalletIdBuilder
 import com.tangem.sdk.extensions.localizedDescriptionRes
 import com.tangem.tap.common.analytics.paramsInterceptor.CardContextInterceptor
-import com.tangem.tap.common.extensions.*
-import com.tangem.tap.common.redux.AppDialog
+import com.tangem.tap.common.extensions.dispatchNavigationAction
+import com.tangem.tap.common.extensions.dispatchOnMain
+import com.tangem.tap.common.extensions.inject
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.features.disclaimer.createDisclaimer
 import com.tangem.tap.features.onboarding.OnboardingHelper
@@ -55,10 +55,12 @@ internal class LegacyScanProcessor @Inject constructor(
         cardId: String? = null,
         allowsRequestAccessCodeFromRepository: Boolean = false,
         analyticsSource: AnalyticsParam.ScreensSources,
+        shouldCheckIsAlreadyActivated: Boolean,
     ): CompletionResult<ScanResponse> {
         return tangemSdkManager.scanProduct(
             cardId = cardId,
             allowsRequestAccessCodeFromRepository = allowsRequestAccessCodeFromRepository,
+            shouldCheckIsAlreadyActivated = shouldCheckIsAlreadyActivated,
         )
             .doOnFailure { error ->
                 onScanFailure(analyticsSource = analyticsSource, error = error, onFailure = {}, onCancel = {})
@@ -68,6 +70,7 @@ internal class LegacyScanProcessor @Inject constructor(
     @Suppress("LongParameterList")
     suspend fun scan(
         analyticsSource: AnalyticsParam.ScreensSources,
+        shouldCheckIsAlreadyActivated: Boolean,
         cardId: String?,
         onProgressStateChange: suspend (showProgress: Boolean) -> Unit,
         onWalletNotCreated: suspend () -> Unit,
@@ -80,7 +83,10 @@ internal class LegacyScanProcessor @Inject constructor(
 
         tangemSdkManager.changeDisplayedCardIdNumbersCount(null)
 
-        val result = tangemSdkManager.scanProduct(cardId)
+        val result = tangemSdkManager.scanProduct(
+            cardId = cardId,
+            shouldCheckIsAlreadyActivated = shouldCheckIsAlreadyActivated,
+        )
 
         val analyticsEvent = Basic.CardWasScanned(analyticsSource)
         store.dispatchOnMain(GlobalAction.ScanFailsCounter.ChooseBehavior(result, analyticsSource))
@@ -113,7 +119,6 @@ internal class LegacyScanProcessor @Inject constructor(
                             onProgressStateChange = onProgressStateChange,
                             onSuccess = onSuccess,
                             onWalletNotCreated = onWalletNotCreated,
-                            onCancel = onCancel,
                         )
                     },
                 )
@@ -198,90 +203,38 @@ internal class LegacyScanProcessor @Inject constructor(
         scanResponse: ScanResponse,
         crossinline onProgressStateChange: suspend (showProgress: Boolean) -> Unit,
         crossinline onWalletNotCreated: suspend () -> Unit,
-        crossinline onCancel: suspend () -> Unit,
         crossinline onSuccess: suspend (ScanResponse) -> Unit,
     ) {
-        checkCardWasUsedInApp(
-            scanResponse = scanResponse,
-            onCancel = {
-                mainScope.launch {
-                    onProgressStateChange.invoke(false)
-                    onCancel()
-                }
-            },
-        ) {
-            if (OnboardingHelper.isOnboardingCase(scanResponse)) {
-                trackingContextProxy.addContext(scanResponse)
+        if (OnboardingHelper.isOnboardingCase(scanResponse)) {
+            trackingContextProxy.addContext(scanResponse)
+            onWalletNotCreated()
+            navigateTo(
+                AppRoute.Onboarding(
+                    scanResponse = scanResponse,
+                    mode = AppRoute.Onboarding.Mode.Onboarding,
+                ),
+            ) { onProgressStateChange(it) }
+        } else {
+            trackingContextProxy.setContext(scanResponse)
+
+            val wasTwinsOnboardingShown =
+                store.inject(DaggerGraphState::wasTwinsOnboardingShownUseCase).invokeSync()
+
+            if (scanResponse.twinsIsTwinned() && !wasTwinsOnboardingShown) {
                 onWalletNotCreated()
                 navigateTo(
                     AppRoute.Onboarding(
                         scanResponse = scanResponse,
-                        mode = AppRoute.Onboarding.Mode.Onboarding,
+                        mode = AppRoute.Onboarding.Mode.WelcomeOnlyTwin,
                     ),
                 ) { onProgressStateChange(it) }
             } else {
-                trackingContextProxy.setContext(scanResponse)
-
-                val wasTwinsOnboardingShown =
-                    store.inject(DaggerGraphState::wasTwinsOnboardingShownUseCase).invokeSync()
-
-                if (scanResponse.twinsIsTwinned() && !wasTwinsOnboardingShown) {
-                    onWalletNotCreated()
-                    navigateTo(
-                        AppRoute.Onboarding(
-                            scanResponse = scanResponse,
-                            mode = AppRoute.Onboarding.Mode.WelcomeOnlyTwin,
-                        ),
-                    ) { onProgressStateChange(it) }
-                } else {
-                    delay(DELAY_SDK_DIALOG_CLOSE)
-                    onSuccess(scanResponse)
-                }
+                delay(DELAY_SDK_DIALOG_CLOSE)
+                onSuccess(scanResponse)
             }
         }
     }
 
-    /**
-     * Checks if card has password and never login at this app
-     * Show alert in this case
-     */
-    private suspend fun checkCardWasUsedInApp(
-        scanResponse: ScanResponse,
-        onCancel: () -> Unit,
-        onSuccess: suspend () -> Unit,
-    ) {
-        val userWalletId = runCatching { UserWalletIdBuilder.card(scanResponse.card).build() }.getOrNull()
-        if (userWalletId == null) {
-            onSuccess()
-            return
-        }
-
-        val userTokensResponseStore = store.inject(DaggerGraphState::userTokensResponseStore)
-        val tokens = userTokensResponseStore.getSyncOrNull(userWalletId = userWalletId)
-
-        if (scanResponse.card.isAccessCodeSet && tokens == null) {
-            store.dispatchDialogShow(
-                AppDialog.WalletAlreadyWasUsedDialog(
-                    onOk = { mainScope.launch { onSuccess() } },
-                    onSupportClick = {
-                        val cardInfo =
-                            store.inject(DaggerGraphState::getWalletMetaInfoUseCase).invoke(scanResponse).getOrNull()
-                                ?: error("CardInfo must be not null")
-
-                        scope.launch {
-                            store.inject(DaggerGraphState::sendFeedbackEmailUseCase)
-                                .invoke(type = FeedbackEmailType.PreActivatedWallet(cardInfo))
-                        }
-                        onCancel()
-                    },
-                    onCancel = { onCancel() },
-                ),
-            )
-        } else {
-            onSuccess()
-        }
-    }
-
     private suspend inline fun navigateTo(route: AppRoute, onProgressStateChange: (showProgress: Boolean) -> Unit) {
         delay(DELAY_SDK_DIALOG_CLOSE)
         store.dispatchNavigationAction { push(route) }

app/src/main/java/com/tangem/tap/domain/scanCard/repository/DefaultScanCardRepository.kt

@@ -13,11 +13,16 @@ internal class DefaultScanCardRepository(
 
     private val exceptionConverter = ScanCardExceptionConverter()
 
-    override suspend fun scanCard(cardId: String?, allowRequestAccessCodeFromStorage: Boolean): ScanResponse {
+    override suspend fun scanCard(
+        cardId: String?,
+        allowRequestAccessCodeFromStorage: Boolean,
+        shouldCheckIsAlreadyActivated: Boolean,
+    ): ScanResponse {
         return when (
             val result = tangemSdkManager.scanProduct(
                 cardId = cardId,
                 allowsRequestAccessCodeFromRepository = allowRequestAccessCodeFromStorage,
+                shouldCheckIsAlreadyActivated = shouldCheckIsAlreadyActivated,
             )
         ) {
             is CompletionResult.Success -> result.data

app/src/main/java/com/tangem/tap/domain/sdk/impl/DefaultTangemSdkManager.kt

@@ -126,7 +126,13 @@ internal class DefaultTangemSdkManager(
             }
 
             if (awaitInitialization) {
-                awaitAuthenticationManagerInitialization().needEnrollBiometrics
+                val manager = awaitAuthenticationManagerInitialization()
+
+                if (manager.isInitialized) {
+                    manager.needEnrollBiometrics
+                } else {
+                    false
+                }
             } else {
                 throw e
             }
@@ -145,7 +151,11 @@ internal class DefaultTangemSdkManager(
             if (awaitInitialization) {
                 val manager = awaitAuthenticationManagerInitialization()
 
-                manager.canAuthenticate || manager.needEnrollBiometrics
+                if (manager.isInitialized) {
+                    manager.canAuthenticate || manager.needEnrollBiometrics
+                } else {
+                    false
+                }
             } else {
                 throw e
             }
@@ -156,6 +166,7 @@ internal class DefaultTangemSdkManager(
         cardId: String?,
         messageRes: Int?,
         allowsRequestAccessCodeFromRepository: Boolean,
+        shouldCheckIsAlreadyActivated: Boolean,
     ): CompletionResult<ScanResponse> {
         val message = Message(resources.getStringSafe(messageRes ?: R.string.initial_message_scan_header))
         return coroutineScope {
@@ -166,6 +177,7 @@ internal class DefaultTangemSdkManager(
                     allowsRequestAccessCodeFromRepository = allowsRequestAccessCodeFromRepository,
                     visaCardScanHandler = visaCardScanHandler,
                     visaCoroutineScope = this,
+                    shouldCheckIsAlreadyActivated = shouldCheckIsAlreadyActivated,
                     onboardingV2FeatureToggles = onboardingV2FeatureToggles,
                 ),
                 cardId = cardId,

app/src/main/java/com/tangem/tap/domain/sdk/impl/MockTangemSdkManager.kt

@@ -59,6 +59,7 @@ class MockTangemSdkManager(
         cardId: String?,
         messageRes: Int?,
         allowsRequestAccessCodeFromRepository: Boolean,
+        shouldCheckIsAlreadyActivated: Boolean,
     ): CompletionResult<ScanResponse> {
         return MockProvider.getScanResponse()
     }

app/src/main/java/com/tangem/tap/domain/tasks/product/ResetBackupCardTask.kt

@@ -27,6 +27,7 @@ internal class ResetBackupCardTask(
         PreflightReadTask(
             readMode = PreflightReadMode.FullCardRead,
             filter = UserWalletIdPreflightReadFilter(expectedUserWalletId = userWalletId),
+            secureStorage = session.environment.secureStorage,
         ).run(session) { result ->
             when (result) {
                 is CompletionResult.Success -> resetCard(session, callback)

app/src/main/java/com/tangem/tap/domain/tasks/product/ScanProductTask.kt

@@ -29,6 +29,7 @@ import com.tangem.domain.models.scan.CardDTO.Companion.RING_BATCH_PREFIX
 import com.tangem.domain.models.scan.ProductType
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
+import com.tangem.operations.PreflightReadMode
 import com.tangem.operations.ScanTask
 import com.tangem.operations.backup.PrimaryCard
 import com.tangem.operations.backup.StartPrimaryCardLinkingTask
@@ -52,6 +53,7 @@ internal class ScanProductTask(
     private val visaCardScanHandler: VisaCardScanHandler?,
     private val visaCoroutineScope: CoroutineScope?,
     private val onboardingV2FeatureToggles: OnboardingV2FeatureToggles?,
+    private val shouldCheckIsAlreadyActivated: Boolean,
     override val allowsRequestAccessCodeFromRepository: Boolean = false,
 ) : CardSessionRunnable<ScanResponse> {
 
@@ -109,6 +111,14 @@ internal class ScanProductTask(
         }
     }
 
+    override fun preflightReadMode(): PreflightReadMode {
+        return if (shouldCheckIsAlreadyActivated) {
+            PreflightReadMode.FullCardReadWithAccessCodeCheck
+        } else {
+            return super.preflightReadMode()
+        }
+    }
+
     private fun getErrorIfExcludedCard(cardDto: CardDTO, card: Card): TangemError? {
         if (cardDto.isExcluded) return TapSdkError.CardForDifferentApp()
         if (cardDto.isNotSupportedInThatRelease) return TapSdkError.CardNotSupportedByRelease()

app/src/main/java/com/tangem/tap/domain/twins/FinalizeTwinTask.kt

@@ -20,7 +20,10 @@ class FinalizeTwinTask(
         WriteProtectedIssuerDataTask(twinPublicKey, issuerKeys).run(session) { result ->
             when (result) {
                 is CompletionResult.Success ->
-                    PreflightReadTask(PreflightReadMode.FullCardRead).run(session) { readResult ->
+                    PreflightReadTask(
+                        readMode = PreflightReadMode.FullCardRead,
+                        secureStorage = session.environment.secureStorage,
+                    ).run(session) { readResult ->
                         when (readResult) {
                             is CompletionResult.Success ->
                                 ScanProductTask(
@@ -28,6 +31,7 @@ class FinalizeTwinTask(
                                     derivationsFinder = null,
                                     visaCardScanHandler = null,
                                     visaCoroutineScope = null,
+                                    shouldCheckIsAlreadyActivated = false,
                                     onboardingV2FeatureToggles = null,
                                 ).run(session, callback)
                             is CompletionResult.Failure ->

app/src/main/java/com/tangem/tap/domain/userWalletList/di/UserWalletsListManagerModule.kt

@@ -16,20 +16,15 @@ import com.tangem.domain.visa.model.VisaActivationRemoteState
 import com.tangem.domain.visa.model.VisaCardActivationStatus
 import com.tangem.domain.wallets.hot.HotWalletAccessCodeAttemptsRepository
 import com.tangem.domain.wallets.hot.HotWalletPasswordRequester
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.feature.referral.domain.MobileWalletPromoRepository
 import com.tangem.hot.sdk.TangemHotSdk
 import com.tangem.sdk.storage.AndroidSecureStorage
 import com.tangem.sdk.storage.AndroidSecureStorageV2
 import com.tangem.sdk.storage.createEncryptedSharedPreferences
-import com.tangem.tap.domain.userWalletList.implementation.BiometricUserWalletsListManager
-import com.tangem.tap.domain.userWalletList.implementation.GeneralUserWalletsListManager
-import com.tangem.tap.domain.userWalletList.implementation.RuntimeUserWalletsListManager
 import com.tangem.tap.domain.userWalletList.repository.DefaultUserWalletsListRepository
 import com.tangem.tap.domain.userWalletList.repository.DelegatedKeystoreManager
 import com.tangem.tap.domain.userWalletList.repository.UserWalletEncryptionKeysRepository
 import com.tangem.tap.domain.userWalletList.repository.UserWalletsKeysStoreDecorator
-import com.tangem.tap.domain.userWalletList.repository.implementation.BiometricUserWalletsKeysRepository
 import com.tangem.tap.domain.userWalletList.repository.implementation.DefaultSelectedUserWalletRepository
 import com.tangem.tap.domain.userWalletList.repository.implementation.DefaultUserWalletsPublicInformationRepository
 import com.tangem.tap.domain.userWalletList.repository.implementation.DefaultUserWalletsSensitiveInformationRepository
@@ -48,77 +43,6 @@ import javax.inject.Singleton
 @InstallIn(SingletonComponent::class)
 internal object UserWalletsListManagerModule {
 
-    @Provides
-    @Singleton
-    @Deprecated("Use UserWalletsListRepository instead")
-    fun provideGeneralUserWalletsListManager(
-        @ApplicationContext applicationContext: Context,
-        appPreferencesStore: AppPreferencesStore,
-        dispatchers: CoroutineDispatcherProvider,
-        analyticsEventHandler: AnalyticsEventHandler,
-    ): UserWalletsListManager {
-        return GeneralUserWalletsListManager(
-            runtimeUserWalletsListManager = RuntimeUserWalletsListManager(),
-            biometricUserWalletsListManager = createBiometricUserWalletsListManager(
-                applicationContext = applicationContext,
-                analyticsEventHandler = analyticsEventHandler,
-                dispatchers = dispatchers,
-            ),
-            appPreferencesStore = appPreferencesStore,
-            dispatchers = dispatchers,
-        )
-    }
-
-    @Deprecated("Use UserWalletsListRepository instead")
-    private fun createBiometricUserWalletsListManager(
-        applicationContext: Context,
-        analyticsEventHandler: AnalyticsEventHandler,
-        dispatchers: CoroutineDispatcherProvider,
-    ): UserWalletsListManager {
-        val moshi = buildMoshi()
-        val secureStorage = buildSecureStorage(applicationContext = applicationContext)
-
-        val authenticatedStorage = AuthenticatedStorage(
-            secureStorage = UserWalletsKeysStoreDecorator(
-                featureStorage = secureStorage,
-                cardSdkStorageProvider = Provider { tangemSdkManager.secureStorage },
-            ),
-            keystoreManager = DelegatedKeystoreManager(
-                keystoreManagerProvider = Provider { tangemSdkManager.keystoreManager },
-            ),
-        )
-
-        val keysRepository = BiometricUserWalletsKeysRepository(
-            moshi = moshi,
-            secureStorage = secureStorage,
-            authenticatedStorage = authenticatedStorage,
-            analyticsEventHandler = analyticsEventHandler,
-        )
-
-        val publicInformationRepository = DefaultUserWalletsPublicInformationRepository(
-            moshi = moshi,
-            secureStorage = secureStorage,
-        )
-
-        val sensitiveInformationRepository = DefaultUserWalletsSensitiveInformationRepository(
-            moshi = moshi,
-            secureStorage = secureStorage,
-        )
-
-        val selectedUserWalletRepository = DefaultSelectedUserWalletRepository(
-            secureStorage = secureStorage,
-            dispatchers = dispatchers,
-        )
-
-        return BiometricUserWalletsListManager(
-            keysRepository = keysRepository,
-            publicInformationRepository = publicInformationRepository,
-            sensitiveInformationRepository = sensitiveInformationRepository,
-            selectedUserWalletRepository = selectedUserWalletRepository,
-            dispatcherProvider = dispatchers,
-        )
-    }
-
     @Provides
     @Singleton
     fun provideUserWalletsListRepository(
@@ -186,7 +110,7 @@ internal object UserWalletsListManagerModule {
         )
     }
 
-    fun buildMoshi(): Moshi {
+    private fun buildMoshi(): Moshi {
         return Moshi.Builder()
             .add(WalletDerivedKeysMapAdapter())
             .add(ScanResponseDerivedKeysMapAdapter())
@@ -203,7 +127,7 @@ internal object UserWalletsListManagerModule {
             .build()
     }
 
-    fun buildSecureStorage(@ApplicationContext applicationContext: Context): SecureStorage {
+    private fun buildSecureStorage(@ApplicationContext applicationContext: Context): SecureStorage {
         return AndroidSecureStorage(
             preferences = SecureStorage.createEncryptedSharedPreferences(
                 context = applicationContext,

app/src/main/java/com/tangem/tap/domain/userWalletList/implementation/BiometricUserWalletsListManager.kt

@@ -1,434 +0,0 @@
-package com.tangem.tap.domain.userWalletList.implementation
-
-import com.tangem.common.*
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.models.wallet.isLocked
-import com.tangem.domain.wallets.legacy.UserWalletsListError
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
-import com.tangem.domain.wallets.legacy.UserWalletsListManager.Lockable.UnlockType
-import com.tangem.tap.domain.userWalletList.model.UserWalletEncryptionKey
-import com.tangem.tap.domain.userWalletList.repository.SelectedUserWalletRepository
-import com.tangem.tap.domain.userWalletList.repository.UserWalletsKeysRepository
-import com.tangem.tap.domain.userWalletList.repository.UserWalletsPublicInformationRepository
-import com.tangem.tap.domain.userWalletList.repository.UserWalletsSensitiveInformationRepository
-import com.tangem.tap.domain.userWalletList.utils.encryptionKey
-import com.tangem.tap.domain.userWalletList.utils.lockAll
-import com.tangem.tap.domain.userWalletList.utils.toUserWallets
-import com.tangem.tap.domain.userWalletList.utils.updateWith
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
-import timber.log.Timber
-
-@Suppress("LargeClass")
-@OptIn(ExperimentalCoroutinesApi::class)
-internal class BiometricUserWalletsListManager(
-    private val keysRepository: UserWalletsKeysRepository,
-    private val publicInformationRepository: UserWalletsPublicInformationRepository,
-    private val sensitiveInformationRepository: UserWalletsSensitiveInformationRepository,
-    private val selectedUserWalletRepository: SelectedUserWalletRepository,
-    private val dispatcherProvider: CoroutineDispatcherProvider,
-) : UserWalletsListManager.Lockable {
-    private val state = MutableStateFlow(State())
-
-    private var hasSavedWallets: Boolean? = null
-    private val savedWalletMutex = Mutex()
-
-    override val isLockable: Boolean = true
-
-    override val userWallets: Flow<List<UserWallet>>
-        get() = state
-            .mapLatest { it.userWallets }
-            .distinctUntilChanged()
-
-    override val userWalletsSync: List<UserWallet>
-        get() = state.value.userWallets
-
-    @Deprecated("You should provide the selected wallet via routing parameters due to the scalability of the features")
-    override val selectedUserWallet: Flow<UserWallet>
-        get() = state
-            .mapLatest { state ->
-                findSelectedUserWallet(state.userWallets)
-            }
-            .filterNotNull()
-            .distinctUntilChanged()
-
-    @Deprecated("You should provide the selected wallet via routing parameters due to the scalability of the features")
-    override val selectedUserWalletSync: UserWallet?
-        get() = findSelectedUserWallet()
-
-    override val lockedState: Flow<Boolean>
-        get() = state
-            .mapLatest { it.isLocked }
-            .distinctUntilChanged()
-
-    override val isLocked: Boolean
-        get() = state.value.isLocked
-
-    override val hasUserWallets: Boolean
-        get() {
-            return runBlocking {
-                // workaround to avoid calling hasSavedEncryptionKeys many times because of performance
-                savedWalletMutex.withLock {
-                    Timber.i("Checking if user has saved wallets")
-                    val hasSavedWalletsLocal = hasSavedWallets
-                    if (hasSavedWalletsLocal == null || !hasSavedWalletsLocal) {
-                        val hasKeys = keysRepository.hasSavedEncryptionKeys()
-                        hasSavedWallets = hasKeys
-                        hasKeys
-                    } else {
-                        Timber.i("User has saved wallets (from cache)")
-                        true
-                    }
-                }
-            }
-        }
-
-    override val walletsCount: Int
-        get() = state.value.userWallets.size
-
-    override val savedWalletsCount: Flow<Int>
-        get() = state
-            .mapLatest { walletsCount }
-            .distinctUntilChanged()
-
-    override suspend fun unlock(type: UnlockType): CompletionResult<UserWallet> {
-        return withContext(dispatcherProvider.io) {
-            unlockAndSetSelectedUserWallet(type)
-                .mapFailure { error ->
-                    Timber.e(error, "Unable to unlock user wallets")
-                    if (error is UserWalletsListError) {
-                        error
-                    } else {
-                        UserWalletsListError.UnableToUnlockUserWallets(error)
-                    }
-                }
-                .map { selectedUserWallet ->
-                    if (selectedUserWallet == null || selectedUserWallet.isLocked) {
-                        Timber.e("Unable to find selected user wallet")
-                        throw UserWalletsListError.NoUserWalletSelected
-                    } else {
-                        selectedUserWallet
-                    }
-                }
-        }
-    }
-
-    override fun lock() {
-        state.update { prevState ->
-            prevState.copy(
-                encryptionKeys = emptyList(),
-                userWallets = prevState.userWallets.lockAll(),
-                isLocked = true,
-            )
-        }
-    }
-
-    override suspend fun select(userWalletId: UserWalletId): CompletionResult<UserWallet> = catching {
-        if (state.value.selectedUserWalletId == userWalletId) {
-            return@catching requireNotNull(findSelectedUserWallet()) {
-                "Wallet is not found"
-            }
-        }
-
-        selectedUserWalletRepository.set(userWalletId)
-
-        val newState = state.updateAndGet { prevState ->
-            prevState.copy(
-                selectedUserWalletId = userWalletId,
-            )
-        }
-
-        newState.userWallets.first { it.walletId == userWalletId }
-    }
-
-    override suspend fun save(userWallet: UserWallet, canOverride: Boolean): CompletionResult<Unit> {
-        return withContext(dispatcherProvider.io) {
-            if (canOverride) {
-                saveInternal(userWallet, changeSelectedUserWallet = true, canOverridePublicInfo = false)
-            } else {
-                val isWalletSaved = state.value.userWallets
-                    .any {
-                        it.walletId == userWallet.walletId
-                    }
-
-                if (isWalletSaved) {
-                    CompletionResult.Failure(UserWalletsListError.WalletAlreadySaved)
-                } else {
-                    saveInternal(userWallet, changeSelectedUserWallet = true, canOverridePublicInfo = false)
-                }
-            }
-        }
-    }
-
-    override suspend fun update(
-        userWalletId: UserWalletId,
-        update: suspend (UserWallet) -> UserWallet,
-    ): CompletionResult<UserWallet> {
-        return withContext(dispatcherProvider.io) {
-            get(userWalletId)
-                .map { storedUserWallet ->
-                    update(storedUserWallet)
-                }
-                .flatMap { updatedUserWallet ->
-                    saveInternal(updatedUserWallet, changeSelectedUserWallet = false, canOverridePublicInfo = true)
-                }
-                .flatMap {
-                    get(userWalletId)
-                }
-        }
-    }
-
-    override suspend fun delete(userWalletIds: List<UserWalletId>): CompletionResult<Unit> {
-        val idsToRemove = state.value.userWallets
-            .takeIf { it.isNotEmpty() }
-            ?.filter { it.walletId in userWalletIds }
-            ?.map { it.walletId }
-
-        if (idsToRemove.isNullOrEmpty()) {
-            return CompletionResult.Success(Unit)
-        }
-
-        if (idsToRemove.size == state.value.userWallets.size) {
-            return clear()
-        }
-
-        return withContext(dispatcherProvider.io) {
-            sensitiveInformationRepository.delete(idsToRemove)
-                .flatMap { publicInformationRepository.delete(idsToRemove) }
-                .map { keysRepository.delete(idsToRemove) }
-                .map {
-                    state.update { prevState ->
-                        val remainingWallets = prevState.userWallets.filter { it.walletId !in idsToRemove }
-
-                        val isSelectedWalletDeleted = prevState.selectedUserWalletId in idsToRemove
-                        val newSelectedUserWallet = findOrSetSelectedWallet(
-                            prevSelectedWalletId = prevState.selectedUserWalletId,
-                            prevSelectedWalletIndex = prevState.userWallets.indexOfFirst {
-                                it.walletId == prevState.selectedUserWalletId
-                            },
-                            userWallets = remainingWallets,
-                            ignorePrevSelectedWallet = isSelectedWalletDeleted,
-                        )
-
-                        prevState.copy(
-                            encryptionKeys = prevState.encryptionKeys.filter { it.walletId !in idsToRemove },
-                            userWallets = remainingWallets,
-                            isLocked = remainingWallets.any { it.isLocked },
-                            selectedUserWalletId = newSelectedUserWallet?.walletId,
-                        )
-                    }
-                }
-        }
-    }
-
-    override suspend fun clear(): CompletionResult<Unit> {
-        savedWalletMutex.withLock {
-            hasSavedWallets = null
-        }
-        return withContext(dispatcherProvider.io) {
-            sensitiveInformationRepository.clear()
-                .flatMap { publicInformationRepository.clear() }
-                .map {
-                    keysRepository.clear()
-                    selectedUserWalletRepository.set(null)
-                    state.value = State()
-                }
-        }
-    }
-
-    override suspend fun get(userWalletId: UserWalletId): CompletionResult<UserWallet> {
-        return catching {
-            state.value.userWallets.first { it.walletId == userWalletId }
-        }
-    }
-
-    private suspend fun saveInternal(
-        userWallet: UserWallet,
-        changeSelectedUserWallet: Boolean,
-        canOverridePublicInfo: Boolean,
-    ): CompletionResult<Unit> {
-        val encryptionKey = userWallet.encryptionKey
-            ?.let { UserWalletEncryptionKey(userWallet.walletId, it) }
-            ?: return CompletionResult.Success(Unit) // No encryption key, no need to save
-
-        return keysRepository.save(encryptionKey)
-            .flatMap { sensitiveInformationRepository.save(userWallet, encryptionKey = encryptionKey.encryptionKey) }
-            .flatMap { publicInformationRepository.save(userWallet, canOverridePublicInfo) }
-            .flatMap {
-                loadUserWallets(
-                    encryptionKeys = state.value.encryptionKeys
-                        .plus(encryptionKey)
-                        .distinctBy(UserWalletEncryptionKey::walletId),
-                )
-            }
-            .doOnSuccess { loadedState ->
-                if (changeSelectedUserWallet) {
-                    selectedUserWalletRepository.set(userWallet.walletId)
-
-                    state.value = loadedState.copy(
-                        selectedUserWalletId = userWallet.walletId,
-                    )
-                } else {
-                    state.value = loadedState
-                }
-            }
-            .map { /* Type erasing */ }
-    }
-
-    private suspend fun unlockAndSetSelectedUserWallet(type: UnlockType): CompletionResult<UserWallet?> {
-        return keysRepository.getAll()
-            .flatMap { encryptionKeys ->
-                loadUserWallets(
-                    encryptionKeys = state.value.encryptionKeys
-                        .plus(encryptionKeys)
-                        .distinctBy(UserWalletEncryptionKey::walletId),
-                )
-            }
-            .map { loadedState ->
-                when (type) {
-                    UnlockType.ALL -> {
-                        if (loadedState.isLocked) {
-                            Timber.e("Some user wallets remain locked")
-
-                            state.value = loadedState
-
-                            throw UserWalletsListError.NotAllUserWalletsUnlocked
-                        } else {
-                            val prevState = state.value
-
-                            val selectedWallet = findOrSetSelectedWallet(
-                                prevSelectedWalletId = prevState.selectedUserWalletId,
-                                userWallets = loadedState.userWallets,
-                                prevSelectedWalletIndex = prevState.userWallets.indexOfFirst {
-                                    it.walletId == prevState.selectedUserWalletId
-                                },
-                            )
-
-                            state.value = loadedState.copy(selectedUserWalletId = selectedWallet?.walletId)
-
-                            selectedWallet
-                        }
-                    }
-                    UnlockType.ANY -> {
-                        val prevState = state.value
-
-                        val selectedWallet = findOrSetSelectedWallet(
-                            prevSelectedWalletId = state.value.selectedUserWalletId,
-                            prevSelectedWalletIndex = prevState.userWallets.indexOfFirst {
-                                it.walletId == prevState.selectedUserWalletId
-                            },
-                            userWallets = loadedState.userWallets,
-                        )
-
-                        state.value = loadedState.copy(selectedUserWalletId = selectedWallet?.walletId)
-
-                        selectedWallet
-                    }
-                    UnlockType.ALL_WITHOUT_SELECT -> {
-                        state.value = loadedState
-
-                        findSelectedUserWallet()
-                    }
-                }
-            }
-    }
-
-    private suspend fun loadUserWallets(encryptionKeys: List<UserWalletEncryptionKey>): CompletionResult<State> {
-        return publicInformationRepository.getAll()
-            .map { it.toUserWallets() }
-            .flatMap { userWallets ->
-                sensitiveInformationRepository.getAll(encryptionKeys)
-                    .map { walletIdToSensitiveInformation ->
-                        userWallets.updateWith(walletIdToSensitiveInformation)
-                    }
-            }
-            .map { userWallets ->
-                val prevState = state.value
-
-                if (userWallets.isNotEmpty()) {
-                    val newUserWallets = (userWallets + prevState.userWallets)
-                        .distinctBy(UserWallet::walletId)
-
-                    prevState.copy(
-                        userWallets = newUserWallets,
-                        encryptionKeys = encryptionKeys,
-                        isLocked = newUserWallets.any(UserWallet::isLocked),
-                    )
-                } else {
-                    prevState
-                }
-            }
-    }
-
-    private suspend fun findOrSetSelectedWallet(
-        prevSelectedWalletId: UserWalletId?,
-        prevSelectedWalletIndex: Int,
-        userWallets: List<UserWallet>,
-        ignorePrevSelectedWallet: Boolean = false,
-    ): UserWallet? {
-        var possibleSelectedUserWallet: UserWallet? = null
-
-        if (!ignorePrevSelectedWallet) {
-            val selectedWalletId = prevSelectedWalletId ?: selectedUserWalletRepository.get()
-            possibleSelectedUserWallet = findSelectedUserWallet(userWallets, selectedWalletId)
-        }
-
-        if (possibleSelectedUserWallet == null || possibleSelectedUserWallet.isLocked) {
-            possibleSelectedUserWallet =
-                userWallets.findAvailableUserWallet(prevSelectedIndex = prevSelectedWalletIndex)
-        }
-
-        selectedUserWalletRepository.set(possibleSelectedUserWallet?.walletId)
-
-        return possibleSelectedUserWallet
-    }
-
-    /**
-     * Find the nearest available wallet that can be selected
-     *
-     * Example:
-     * Number with *n* is previous selected wallet with index [prevSelectedIndex].
-     *
-     * 1. [*1*, 2, 3, 4] => delete 1 => [2, 3, 4] => find and select => [*2*, 3, 4]
-     * 2. [1, *2*, 3, 4] => delete 2 => [1, 3, 4] => find and select => [1, *3*, 4]
-     * 3. [1, 2, *3*, 4] => delete 3 => [1, 2, 4] => find and select => [1, 2, *4*]
-     * 4. [1, 2, 3, *4*] => delete 4 => [1, 2, 3] => find and select => [1, 2, *3*]
-     *
-     * @receiver list of user wallets without deleted wallet
-     */
-    private fun List<UserWallet>.findAvailableUserWallet(prevSelectedIndex: Int): UserWallet? {
-        if (prevSelectedIndex == 0) return firstOrNull { !it.isLocked } ?: firstOrNull()
-
-        if (prevSelectedIndex in indices && !this[prevSelectedIndex].isLocked) return this[prevSelectedIndex]
-
-        for (offset in 1..size) {
-            val rightIndex = prevSelectedIndex + offset
-            if (rightIndex in indices && !this[rightIndex].isLocked) return this[rightIndex]
-
-            val leftIndex = prevSelectedIndex - offset
-            if (leftIndex in indices && !this[leftIndex].isLocked) return this[leftIndex]
-        }
-
-        return lastOrNull()
-    }
-
-    private fun findSelectedUserWallet(
-        userWallets: List<UserWallet> = state.value.userWallets,
-        selectedUserWalletId: UserWalletId? = state.value.selectedUserWalletId,
-    ): UserWallet? {
-        return userWallets.firstOrNull { it.walletId == selectedUserWalletId }
-    }
-
-    private data class State(
-        val encryptionKeys: List<UserWalletEncryptionKey> = emptyList(),
-        val userWallets: List<UserWallet> = emptyList(),
-        val selectedUserWalletId: UserWalletId? = null,
-        val isLocked: Boolean = true,
-    )
-}

app/src/main/java/com/tangem/tap/domain/userWalletList/implementation/GeneralUserWalletsListManager.kt

@@ -1,203 +0,0 @@
-package com.tangem.tap.domain.userWalletList.implementation
-
-import com.tangem.common.CompletionResult
-import com.tangem.datasource.local.preferences.AppPreferencesStore
-import com.tangem.datasource.local.preferences.PreferencesKeys
-import com.tangem.datasource.local.preferences.utils.get
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.*
-import timber.log.Timber
-
-/**
- * General implementation of [UserWalletsListManager] that helps to switch between Runtime and Biometric
- * implementations.
- *
- * @property runtimeUserWalletsListManager   runtime user wallets list manager
- * @property biometricUserWalletsListManager biometric user wallets list manager
- * @property appPreferencesStore             app preferences store
- * @property dispatchers                     coroutine dispatcher provider
- *
-[REDACTED_AUTHOR]
- */
-@OptIn(ExperimentalCoroutinesApi::class)
-internal class GeneralUserWalletsListManager(
-    private val runtimeUserWalletsListManager: UserWalletsListManager,
-    private val biometricUserWalletsListManager: UserWalletsListManager,
-    private val appPreferencesStore: AppPreferencesStore,
-    private val dispatchers: CoroutineDispatcherProvider,
-) : UserWalletsListManager.Lockable {
-
-    private val applicationScope = CoroutineScope(dispatchers.io)
-    private val implementation: MutableStateFlow<UserWalletsListManager?> = MutableStateFlow(value = null)
-
-    private val requireImplementation: UserWalletsListManager
-        get() = requireNotNull(implementation.value) {
-            "UserWalletsListManager is not initialized"
-        }
-
-    init {
-        subscribeOnCurrentManager()
-    }
-
-    override val isLockable: Boolean
-        get() = requireImplementation.isLockable
-
-    override val userWallets: Flow<List<UserWallet>>
-        get() = implementation
-            .transformLatest { impl ->
-                if (impl != null) {
-                    emitAll(impl.userWallets)
-                }
-            }
-            // To avoid returning empty flow to subscriber while implementation and userWallets are null
-            // Flow is called first time when implementation is null and then when its assigned with implementation
-            // that may have not user wallets (null or empty).
-            // As a result subscription occurs on empty flow, than will not change if user wallets are available
-            .filter { requireImplementation.hasUserWallets }
-
-    override val savedWalletsCount: Flow<Int>
-        get() = implementation
-            .transformLatest { impl ->
-                if (impl != null) {
-                    emitAll(impl.savedWalletsCount)
-                }
-            }
-
-    override val userWalletsSync: List<UserWallet>
-        get() = requireImplementation.userWalletsSync
-
-    override val selectedUserWallet: Flow<UserWallet>
-        get() = implementation
-            .transformLatest { impl ->
-                if (impl != null) {
-                    emitAll(impl.selectedUserWallet)
-                }
-            }
-            // To avoid returning empty flow to subscriber while implementation and userWallets are null
-            // Flow is called first time when implementation is null and then when its assigned with implementation
-            // that may have not user wallets (null or empty).
-            // As a result subscription occurs on empty flow, than will not change if user wallets are available
-            .filter { requireImplementation.hasUserWallets }
-
-    override val selectedUserWalletSync: UserWallet?
-        get() = requireImplementation.selectedUserWalletSync
-
-    override val hasUserWallets: Boolean
-        get() = requireImplementation.hasUserWallets
-
-    override val walletsCount: Int
-        get() = requireImplementation.walletsCount
-
-    override val lockedState: Flow<Boolean>
-        get() = implementation.transformLatest { impl ->
-            if (impl == null) return@transformLatest
-
-            if (impl is UserWalletsListManager.Lockable) {
-                emitAll(impl.lockedState)
-            } else {
-                error("RuntimeUserWalletsListManager is not lockable")
-            }
-        }
-
-    override val isLocked: Boolean
-        get() {
-            val impl = requireImplementation
-
-            return if (impl is UserWalletsListManager.Lockable) {
-                impl.isLocked
-            } else {
-                error("RuntimeUserWalletsListManager is not lockable")
-            }
-        }
-
-    override suspend fun select(userWalletId: UserWalletId): CompletionResult<UserWallet> {
-        return requireImplementation.select(userWalletId)
-    }
-
-    override suspend fun save(userWallet: UserWallet, canOverride: Boolean): CompletionResult<Unit> {
-        return requireImplementation.save(userWallet, canOverride)
-    }
-
-    override suspend fun update(
-        userWalletId: UserWalletId,
-        update: suspend (UserWallet) -> UserWallet,
-    ): CompletionResult<UserWallet> {
-        return requireImplementation.update(userWalletId, update)
-    }
-
-    override suspend fun delete(userWalletIds: List<UserWalletId>): CompletionResult<Unit> {
-        return requireImplementation.delete(userWalletIds)
-    }
-
-    override suspend fun clear(): CompletionResult<Unit> {
-        return requireImplementation.clear()
-    }
-
-    override suspend fun get(userWalletId: UserWalletId): CompletionResult<UserWallet> {
-        return requireImplementation.get(userWalletId)
-    }
-
-    override suspend fun unlock(type: UserWalletsListManager.Lockable.UnlockType): CompletionResult<UserWallet> {
-        val implementation = requireImplementation
-
-        return if (implementation is UserWalletsListManager.Lockable) {
-            implementation.unlock(type)
-        } else {
-            error("RuntimeUserWalletsListManager is not lockable")
-        }
-    }
-
-    override fun lock() {
-        val implementation = requireImplementation
-
-        return if (implementation is UserWalletsListManager.Lockable) {
-            implementation.lock()
-        } else {
-            error("RuntimeUserWalletsListManager is not lockable")
-        }
-    }
-
-    private fun subscribeOnCurrentManager() {
-        appPreferencesStore.get(key = PreferencesKeys.SAVE_USER_WALLETS_KEY, default = false)
-            .distinctUntilChanged()
-            .onEach { shouldSaveUserWallets ->
-                val possibleManager = if (shouldSaveUserWallets) {
-                    biometricUserWalletsListManager
-                } else {
-                    runtimeUserWalletsListManager
-                }
-
-                if (possibleManager == implementation.value) {
-                    Timber.e("Switch to the same manager ${possibleManager::class.simpleName.orEmpty()}")
-                }
-
-                Timber.i("Switch to ${possibleManager::class.simpleName.orEmpty()}")
-
-                val previousManager = implementation.value
-                implementation.value = copySelectedUserWallet(
-                    sourceManager = previousManager,
-                    destinationManager = possibleManager,
-                )
-
-                previousManager?.clear()
-            }
-            .flowOn(dispatchers.io)
-            .launchIn(applicationScope)
-    }
-
-    private suspend fun copySelectedUserWallet(
-        sourceManager: UserWalletsListManager?,
-        destinationManager: UserWalletsListManager,
-    ): UserWalletsListManager {
-        sourceManager?.selectedUserWalletSync?.let { selectedWallet ->
-            destinationManager.save(selectedWallet, canOverride = true)
-        }
-
-        return destinationManager
-    }
-}

app/src/main/java/com/tangem/tap/domain/userWalletList/implementation/RuntimeUserWalletsListManager.kt

@@ -1,115 +0,0 @@
-package com.tangem.tap.domain.userWalletList.implementation
-
-import com.tangem.common.CompletionResult
-import com.tangem.common.catching
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.wallets.legacy.UserWalletsListError
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.*
-
-@OptIn(ExperimentalCoroutinesApi::class)
-internal class RuntimeUserWalletsListManager : UserWalletsListManager {
-    private val state = MutableStateFlow(State())
-
-    override val isLockable: Boolean = false
-
-    override val userWallets: Flow<List<UserWallet>>
-        get() = state
-            .mapLatest { listOfNotNull(it.userWallet) }
-            .distinctUntilChanged()
-
-    override val selectedUserWallet: Flow<UserWallet>
-        get() = state
-            .mapLatest { it.userWallet }
-            .filterNotNull()
-            .distinctUntilChanged()
-
-    override val userWalletsSync: List<UserWallet>
-        get() = listOfNotNull(state.value.userWallet)
-
-    override val selectedUserWalletSync: UserWallet?
-        get() = state.value.userWallet
-
-    override val hasUserWallets: Boolean
-        get() = state.value.userWallet != null
-
-    /**
-     * only 1 wallet stored in runtime implementation
-     */
-    override val walletsCount: Int
-        get() = if (hasUserWallets) 1 else 0
-
-    override val savedWalletsCount: Flow<Int>
-        get() = state
-            .mapLatest { walletsCount }
-            .distinctUntilChanged()
-
-    override suspend fun select(userWalletId: UserWalletId): CompletionResult<UserWallet> = catching {
-        state.value.userWallet
-            ?.takeIf { it.walletId == userWalletId }
-            ?: walletNotFound()
-    }
-
-    override suspend fun save(userWallet: UserWallet, canOverride: Boolean): CompletionResult<Unit> {
-        return if (canOverride) {
-            saveInternal(userWallet)
-        } else {
-            val isWalletSaved = state.value.userWallet?.walletId == userWallet.walletId
-
-            if (isWalletSaved) {
-                CompletionResult.Failure(UserWalletsListError.WalletAlreadySaved)
-            } else {
-                saveInternal(userWallet)
-            }
-        }
-    }
-
-    override suspend fun update(
-        userWalletId: UserWalletId,
-        update: suspend (UserWallet) -> UserWallet,
-    ): CompletionResult<UserWallet> = catching {
-        val wallet = state.value.userWallet
-            ?.takeIf { it.walletId == userWalletId }
-            ?: walletNotFound()
-
-        requireNotNull(
-            state.updateAndGet { prevState ->
-                prevState.copy(
-                    userWallet = update(wallet),
-                )
-            }.userWallet,
-        ) { "User wallet is null after update" }
-    }
-
-    override suspend fun delete(userWalletIds: List<UserWalletId>): CompletionResult<Unit> = clear()
-
-    override suspend fun clear(): CompletionResult<Unit> = catching {
-        state.update { prevState ->
-            prevState.copy(
-                userWallet = null,
-            )
-        }
-    }
-
-    override suspend fun get(userWalletId: UserWalletId): CompletionResult<UserWallet> = catching {
-        state.value.userWallet ?: walletNotFound()
-    }
-
-    private fun saveInternal(userWallet: UserWallet): CompletionResult<Unit> = catching {
-        state.update { prevState ->
-            prevState.copy(
-                userWallet = userWallet,
-            )
-        }
-    }
-
-    private fun walletNotFound(): Nothing {
-        throw NoSuchElementException("User wallet not found")
-    }
-
-    private data class State(
-        val userWallet: UserWallet? = null,
-    )
-}

app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt

@@ -13,6 +13,7 @@ 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.UserWalletTransformAction
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.common.wallets.UserWalletsListRepository.LockMethod
 import com.tangem.domain.common.wallets.error.*
@@ -30,19 +31,18 @@ import com.tangem.hot.sdk.TangemHotSdk
 import com.tangem.hot.sdk.model.HotWalletId
 import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.tap.domain.userWalletList.model.UserWalletEncryptionKey
-import com.tangem.tap.domain.userWalletList.utils.encryptionKey
-import com.tangem.tap.domain.userWalletList.utils.lock
-import com.tangem.tap.domain.userWalletList.utils.toUserWallets
-import com.tangem.tap.domain.userWalletList.utils.updateWith
+import com.tangem.tap.domain.userWalletList.utils.*
 import com.tangem.utils.Provider
 import com.tangem.utils.ProviderSuspend
 import com.tangem.utils.coroutines.runSuspendCatching
 import com.tangem.utils.extensions.addOrReplace
 import com.tangem.utils.extensions.indexOfFirstOrNull
+import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
 
 @Suppress("LongParameterList", "LargeClass")
 internal class DefaultUserWalletsListRepository(
@@ -64,6 +64,7 @@ internal class DefaultUserWalletsListRepository(
 
     override val userWallets = MutableStateFlow<List<UserWallet>?>(null)
     override val selectedUserWallet = MutableStateFlow<UserWallet?>(null)
+
     private val mutex = Mutex()
 
     override suspend fun load() {
@@ -295,8 +296,9 @@ internal class DefaultUserWalletsListRepository(
                 }
 
                 val scanResponse = unlockMethod.scanResponse ?: run {
-                    val res = tangemSdkManagerProvider().scanProduct()
-                    when (res) {
+                    when (val res = tangemSdkManagerProvider().scanProduct(
+                        shouldCheckIsAlreadyActivated = false,
+                    )) {
                         is CompletionResult.Failure -> raise(UnlockWalletError.UserCancelled)
                         is CompletionResult.Success -> res.data
                     }
@@ -395,6 +397,44 @@ internal class DefaultUserWalletsListRepository(
         return userWallets.any { it.walletId !in unsecuredWalletIds }
     }
 
+    override suspend fun transform(action: UserWalletTransformAction) {
+        val wallets = userWalletsSync()
+        val walletsMap = wallets.associateBy { it.walletId }
+        val transformedWallets = action.transform(wallets)
+        val transformedWalletsMap = transformedWallets.associateBy { it.walletId }
+
+        require(walletsMap.keys == transformedWalletsMap.keys) {
+            "The transformation action must not change the set of wallet IDs." +
+                "Original IDs: ${walletsMap.keys}, Transformed IDs: ${transformedWalletsMap.keys}"
+        }
+
+        updateWallets { transformedWallets }
+
+        withContext(NonCancellable) {
+            if (savePersistentInformation()) {
+                publicInformationRepository.transform {
+                    transformedWallets.map { wallet -> wallet.publicInformation }
+                }
+
+                val changedSensitiveInfoWallets = wallets.filter { wallet ->
+                    val transformedWallet = transformedWalletsMap[wallet.walletId]
+                    transformedWallet != null && transformedWallet.sensitiveInformation != wallet.sensitiveInformation
+                }
+
+                changedSensitiveInfoWallets.forEach { wallet ->
+                    if (wallet.isLocked.not()) {
+                        sensitiveInformationRepository.save(wallet, wallet.encryptionKey)
+                    }
+
+                    checkForUpgradeAndDeleteHotWalletIfNeeded(
+                        newUserWallet = wallet,
+                        oldUserWallet = walletsMap[wallet.walletId] ?: error("This should never happen"),
+                    )
+                }
+            }
+        }
+    }
+
     private suspend fun checkForUpgradeAndDeleteHotWalletIfNeeded(
         newUserWallet: UserWallet,
         oldUserWallet: UserWallet,
@@ -435,9 +475,7 @@ internal class DefaultUserWalletsListRepository(
             authMode = true, // In auth mode user wallet can be deleted after 30 failed attempts
             hasBiometry = hasBiometry(),
         )
-        val result = passwordRequester.requestPassword(attemptRequest)
-
-        return when (result) {
+        return when (val result = passwordRequester.requestPassword(attemptRequest)) {
             HotWalletPasswordRequester.Result.Dismiss -> {
                 passwordRequester.dismiss()
                 UnlockWalletError.UserCancelled.left()

app/src/main/java/com/tangem/tap/domain/userWalletList/repository/UserWalletsKeysRepository.kt

@@ -1,39 +0,0 @@
-package com.tangem.tap.domain.userWalletList.repository
-
-import com.tangem.common.CompletionResult
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.tap.domain.userWalletList.model.UserWalletEncryptionKey
-
-internal interface UserWalletsKeysRepository {
-    /**
-     * Obtaining the encryption keys of all user wallets from the biometric vault. Biometric authentication required
-     * If that operation runs more than biometric cipher key expiration time then the user will not receive all
-     * encryption keys
-     * @return [CompletionResult] of operation with stored [UserWalletEncryptionKey] list
-     * */
-    suspend fun getAll(): CompletionResult<List<UserWalletEncryptionKey>>
-
-    /**
-     * Save the encryption key for user wallet. Biometric authentication not required
-     * @param encryptionKey [UserWalletEncryptionKey] to save
-     * @return [CompletionResult] of operation
-     * */
-    suspend fun save(encryptionKey: UserWalletEncryptionKey): CompletionResult<Unit>
-
-    /**
-     * Delete encryption keys for user wallets. Biometric authentication not required
-     * @param userWalletsIds List of [UserWalletId] whose encryption keys will be deleted
-     * */
-    suspend fun delete(userWalletsIds: List<UserWalletId>)
-
-    /**
-     * Clear all encryption keys for user wallets. Biometric authentication not required
-     * */
-    suspend fun clear()
-
-    /**
-     * Determine if the user has saved user wallets
-     * @return [Boolean] true if user has saved wallets
-     * */
-    fun hasSavedEncryptionKeys(): Boolean
-}

app/src/main/java/com/tangem/tap/domain/userWalletList/repository/UserWalletsPublicInformationRepository.kt

@@ -12,4 +12,8 @@ internal interface UserWalletsPublicInformationRepository {
 
     suspend fun delete(walletIds: List<UserWalletId>): CompletionResult<Unit>
     suspend fun clear(): CompletionResult<Unit>
+
+    suspend fun transform(
+        block: (List<UserWalletPublicInformation>?) -> List<UserWalletPublicInformation>?,
+    ): CompletionResult<Unit>
 }

app/src/main/java/com/tangem/tap/domain/userWalletList/repository/implementation/BiometricFailReasonConverter.kt

@@ -1,39 +0,0 @@
-package com.tangem.tap.domain.userWalletList.repository.implementation
-
-import com.tangem.common.core.TangemError
-import com.tangem.common.core.TangemSdkError
-import com.tangem.core.analytics.models.Basic
-import com.tangem.domain.wallets.legacy.UserWalletsListError
-import com.tangem.utils.converter.Converter
-
-object BiometricFailReasonConverter : Converter<TangemError, Basic.BiometryFailed.BiometricFailReason> {
-
-    override fun convert(value: TangemError): Basic.BiometryFailed.BiometricFailReason {
-        // 1. Try handle TangemSdkError cases first if error has not been mapped
-        when (value) {
-            is TangemSdkError.AuthenticationCanceled ->
-                return Basic.BiometryFailed.BiometricFailReason.AuthenticationCancelled
-            is TangemSdkError.AuthenticationAlreadyInProgress ->
-                return Basic.BiometryFailed.BiometricFailReason.AuthenticationAlreadyInProgress
-        }
-
-        // 2. For other errors, check if they are of type UserWalletsListError
-        if (value !is UserWalletsListError) {
-            return Basic.BiometryFailed.BiometricFailReason.Other(value.customMessage)
-        }
-        // 3. Map UserWalletsListError to BiometricFailReason
-        return when (value) {
-            UserWalletsListError.AllKeysInvalidated ->
-                Basic.BiometryFailed.BiometricFailReason.AllKeysInvalidated
-            UserWalletsListError.BiometricsAuthenticationDisabled ->
-                Basic.BiometryFailed.BiometricFailReason.BiometricsAuthenticationDisabled
-            is UserWalletsListError.BiometricsAuthenticationLockout ->
-                if (value.isPermanent) {
-                    Basic.BiometryFailed.BiometricFailReason.AuthenticationLockoutPermanent
-                } else {
-                    Basic.BiometryFailed.BiometricFailReason.AuthenticationLockout
-                }
-            else -> Basic.BiometryFailed.BiometricFailReason.Other(value.customMessage)
-        }
-    }
-}

app/src/main/java/com/tangem/tap/domain/userWalletList/repository/implementation/BiometricUserWalletsKeysRepository.kt

@@ -1,207 +0,0 @@
-package com.tangem.tap.domain.userWalletList.repository.implementation
-
-import com.squareup.moshi.JsonAdapter
-import com.squareup.moshi.Moshi
-import com.squareup.moshi.Types
-import com.tangem.common.*
-import com.tangem.common.authentication.storage.AuthenticatedStorage
-import com.tangem.common.core.TangemSdkError
-import com.tangem.common.services.secure.SecureStorage
-import com.tangem.core.analytics.api.AnalyticsEventHandler
-import com.tangem.core.analytics.models.AnalyticsParam
-import com.tangem.core.analytics.models.Basic
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.wallets.legacy.UserWalletsListError
-import com.tangem.tap.domain.userWalletList.model.UserWalletEncryptionKey
-import com.tangem.tap.domain.userWalletList.repository.UserWalletsKeysRepository
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.withContext
-
-internal class BiometricUserWalletsKeysRepository(
-    moshi: Moshi,
-    private val authenticatedStorage: AuthenticatedStorage,
-    private val secureStorage: SecureStorage,
-    private val analyticsEventHandler: AnalyticsEventHandler,
-) : UserWalletsKeysRepository {
-
-    private val encryptionKeyAdapter: JsonAdapter<UserWalletEncryptionKey> = moshi.adapter(
-        UserWalletEncryptionKey::class.java,
-    )
-    private val userWalletsIdsListAdapter: JsonAdapter<List<UserWalletId>> = moshi.adapter(
-        Types.newParameterizedType(List::class.java, UserWalletId::class.java),
-    )
-
-    override suspend fun getAll(): CompletionResult<List<UserWalletEncryptionKey>> {
-        return withContext(Dispatchers.IO) {
-            getAllInternal()
-                .mapFailure { error ->
-                    val mappedError = when (error) {
-                        is TangemSdkError.AuthenticationLockout ->
-                            UserWalletsListError.BiometricsAuthenticationLockout(isPermanent = false)
-                        is TangemSdkError.AuthenticationPermanentLockout ->
-                            UserWalletsListError.BiometricsAuthenticationLockout(isPermanent = true)
-                        is TangemSdkError.KeystoreInvalidated ->
-                            UserWalletsListError.AllKeysInvalidated
-                        is TangemSdkError.AuthenticationUnavailable ->
-                            UserWalletsListError.BiometricsAuthenticationDisabled
-                        else -> error
-                    }
-                    analyticsEventHandler.send(
-                        Basic.BiometryFailed(
-                            source = AnalyticsParam.ScreensSources.SignIn,
-                            reason = BiometricFailReasonConverter.convert(mappedError),
-                        ),
-                    )
-                    mappedError
-                }
-        }
-    }
-
-    override suspend fun save(encryptionKey: UserWalletEncryptionKey): CompletionResult<Unit> {
-        return withContext(Dispatchers.IO) {
-            storeEncryptionKey(encryptionKey)
-        }
-    }
-
-    override suspend fun delete(userWalletsIds: List<UserWalletId>) {
-        return withContext(Dispatchers.IO) {
-            userWalletsIds.forEach { userWalletId ->
-                deleteEncryptionKey(userWalletId)
-            }
-
-            deleteUserWalletsIds(userWalletsIds)
-        }
-    }
-
-    override suspend fun clear() {
-        return withContext(Dispatchers.IO) {
-            getUserWalletsIds()
-                .forEach { userWalletId ->
-                    deleteEncryptionKey(userWalletId)
-                }
-
-            clearUserWalletsIds()
-        }
-    }
-
-    override fun hasSavedEncryptionKeys(): Boolean {
-        return runBlocking {
-            getUserWalletsIds().isNotEmpty()
-        }
-    }
-
-    private suspend fun getAllInternal(): CompletionResult<List<UserWalletEncryptionKey>> {
-        return catching {
-            val userWalletIds = getUserWalletsIds()
-
-            getEncryptionKeys(userWalletIds)
-        }
-            .doOnFailure { error ->
-                when (error) {
-                    is TangemSdkError.KeystoreInvalidated -> {
-                        getUserWalletsIds().forEach { userWalletId ->
-                            deleteEncryptionKey(userWalletId)
-                        }
-                    }
-                    else -> Unit
-                }
-            }
-    }
-
-    private suspend fun getEncryptionKeys(userWalletsIds: List<UserWalletId>): List<UserWalletEncryptionKey> {
-        val keys = userWalletsIds.map { userWalletId ->
-            StorageKey.UserWalletEncryptionKey(userWalletId).name
-        }
-
-        return authenticatedStorage.get(keys).mapNotNull { (_, encodedData) ->
-            encodedData.decodeToKey()
-        }
-    }
-
-    private suspend fun storeEncryptionKey(encryptionKey: UserWalletEncryptionKey): CompletionResult<Unit> {
-        return catching {
-            authenticatedStorage.store(
-                keyAlias = StorageKey.UserWalletEncryptionKey(encryptionKey.walletId).name,
-                data = encryptionKey.encode(),
-            )
-        }
-            .map { storeUserWalletId(encryptionKey.walletId) }
-    }
-
-    private fun deleteEncryptionKey(userWalletId: UserWalletId) {
-        authenticatedStorage.delete(StorageKey.UserWalletEncryptionKey(userWalletId).name)
-    }
-
-    private suspend fun getUserWalletsIds(): List<UserWalletId> {
-        return withContext(Dispatchers.IO) {
-            secureStorage.get(StorageKey.UserWalletIds.name)
-                .decodeToUserWalletsIds()
-        }
-    }
-
-    private suspend fun storeUserWalletId(userWalletId: UserWalletId) {
-        val userWalletIds = (getUserWalletsIds() + userWalletId).distinct()
-
-        withContext(Dispatchers.IO) {
-            secureStorage.store(userWalletIds.encode(), StorageKey.UserWalletIds.name)
-        }
-    }
-
-    private suspend fun deleteUserWalletsIds(userWalletsIds: List<UserWalletId>) {
-        val remainingIds = getUserWalletsIds() - userWalletsIds.toSet()
-
-        withContext(Dispatchers.IO) {
-            secureStorage.store(remainingIds.encode(), StorageKey.UserWalletIds.name)
-        }
-    }
-
-    private suspend fun clearUserWalletsIds() {
-        withContext(Dispatchers.IO) {
-            secureStorage.delete(StorageKey.UserWalletIds.name)
-        }
-    }
-
-    private suspend fun UserWalletEncryptionKey.encode(): ByteArray {
-        return withContext(Dispatchers.Default) {
-            encryptionKeyAdapter.toJson(this@encode)
-                .encodeToByteArray(throwOnInvalidSequence = true)
-        }
-    }
-
-    private suspend fun ByteArray?.decodeToKey(): UserWalletEncryptionKey? {
-        return withContext(Dispatchers.Default) {
-            this@decodeToKey
-                ?.decodeToString(throwOnInvalidSequence = true)
-                ?.let(encryptionKeyAdapter::fromJson)
-        }
-    }
-
-    private suspend fun List<UserWalletId>.encode(): ByteArray {
-        return withContext(Dispatchers.Default) {
-            userWalletsIdsListAdapter.toJson(this@encode)
-                .encodeToByteArray(throwOnInvalidSequence = true)
-        }
-    }
-
-    private suspend fun ByteArray?.decodeToUserWalletsIds(): List<UserWalletId> {
-        return withContext(Dispatchers.Default) {
-            this@decodeToUserWalletsIds
-                ?.decodeToString(throwOnInvalidSequence = true)
-                ?.let(userWalletsIdsListAdapter::fromJson)
-                .orEmpty()
-        }
-    }
-
-    private sealed interface StorageKey {
-        val name: String
-
-        class UserWalletEncryptionKey(userWalletId: UserWalletId) : StorageKey {
-            override val name: String = "user_wallet_encryption_key_${userWalletId.stringValue}"
-        }
-
-        object UserWalletIds : StorageKey {
-            override val name: String = "user_wallets_ids_with_saved_keys"
-        }
-    }
-}

app/src/main/java/com/tangem/tap/domain/userWalletList/repository/implementation/DefaultUserWalletsPublicInformationRepository.kt

@@ -77,6 +77,21 @@ internal class DefaultUserWalletsPublicInformationRepository(
         }
     }
 
+    override suspend fun transform(
+        block: (List<UserWalletPublicInformation>?) -> List<UserWalletPublicInformation>?,
+    ): CompletionResult<Unit> {
+        return withContext(Dispatchers.IO) {
+            getAll().flatMap { currentInfo ->
+                val transformed = block(currentInfo)
+                if (transformed != null) {
+                    save(transformed)
+                } else {
+                    CompletionResult.Success(Unit)
+                }
+            }
+        }
+    }
+
     @JvmName("saveWithPublicInformation")
     private suspend fun save(publicInformation: List<UserWalletPublicInformation>): CompletionResult<Unit> = catching {
         withContext(Dispatchers.IO) {

app/src/main/java/com/tangem/tap/domain/userWalletList/utils/Mapper.kt

@@ -104,8 +104,6 @@ internal fun List<UserWallet>.updateWith(
     }
 }
 
-internal fun List<UserWallet>.lockAll(): List<UserWallet> = map(UserWallet::lock)
-
 internal fun UserWallet.lock(): UserWallet = when (this) {
     is UserWallet.Cold -> {
         copy(

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

@@ -3,15 +3,12 @@ package com.tangem.tap.features.details.redux
 import com.tangem.common.CompletionResult
 import com.tangem.common.doOnFailure
 import com.tangem.common.doOnSuccess
-import com.tangem.common.routing.AppRoute
 import com.tangem.core.analytics.Analytics
 import com.tangem.domain.apptheme.model.AppThemeMode
 import com.tangem.domain.common.wallets.UserWalletsListRepository.LockMethod
-import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.tap.common.analytics.events.AnalyticsParam
 import com.tangem.tap.common.analytics.events.Settings
-import com.tangem.tap.common.extensions.dispatchNavigationAction
 import com.tangem.tap.common.extensions.dispatchWithMain
 import com.tangem.tap.common.extensions.inject
 import com.tangem.tap.common.redux.AppState
@@ -43,7 +40,7 @@ class DetailsMiddleware {
                 if (!DemoHelper.tryHandle(stateProvider)) {
                     val detailsState = stateProvider()?.detailsState
                     if (detailsState != null) {
-                        handleAction(detailsState, action)
+                        handleAction(action)
                     }
                 }
                 next(action)
@@ -51,9 +48,9 @@ class DetailsMiddleware {
         }
     }
 
-    private fun handleAction(state: DetailsState, action: Action) {
+    private fun handleAction(action: Action) {
         when (action) {
-            is DetailsAction.AppSettings -> appSettingsMiddleware.handle(state, action)
+            is DetailsAction.AppSettings -> appSettingsMiddleware.handle(action)
         }
     }
 
@@ -61,12 +58,10 @@ class DetailsMiddleware {
 
         private val checkBiometricsStatusJobHolder = JobHolder()
 
-        fun handle(state: DetailsState, action: DetailsAction.AppSettings) {
+        fun handle(action: DetailsAction.AppSettings) {
             when (action) {
                 is DetailsAction.AppSettings.SwitchPrivacySetting -> {
                     when (action.setting) {
-                        AppSetting.SaveWallets -> toggleSaveWallets(state, enable = action.enable)
-                        AppSetting.SaveAccessCode -> toggleSaveAccessCodes(state, enable = action.enable)
                         AppSetting.RequireAccessCode -> toggleRequireAccessCode(enable = action.enable)
                         AppSetting.BiometricAuthentication -> toggleBiometricsAuthentication(enable = action.enable)
                     }
@@ -221,118 +216,6 @@ class DetailsMiddleware {
             }
         }
 
-        private fun toggleSaveWallets(state: DetailsState, enable: Boolean) = scope.launch {
-            // Nothing to change
-            val walletsRepository = store.inject(DaggerGraphState::walletsRepository)
-
-            if (walletsRepository.shouldSaveUserWalletsSync() == enable) {
-                store.dispatchWithMain(DetailsAction.AppSettings.SwitchPrivacySetting.Success)
-                return@launch
-            }
-
-            toggleSaveWallets(state.scanResponse, enable)
-                .doOnFailure {
-                    store.dispatchWithMain(
-                        DetailsAction.AppSettings.SwitchPrivacySetting.Failure(
-                            prevState = !enable,
-                            setting = AppSetting.SaveWallets,
-                        ),
-                    )
-                }
-                .doOnSuccess {
-                    store.dispatchWithMain(DetailsAction.AppSettings.SwitchPrivacySetting.Success)
-                }
-        }
-
-        private suspend fun toggleSaveWallets(scanResponse: ScanResponse?, enable: Boolean): CompletionResult<Unit> {
-            return if (enable) {
-                saveCurrentWallet(scanResponse, enableAccessCodesSaving = false)
-            } else {
-                deleteSavedWalletsAndAccessCodes()
-            }
-        }
-
-        private fun toggleSaveAccessCodes(state: DetailsState, enable: Boolean) = scope.launch {
-            val shouldSaveAccessCodes = store.inject(DaggerGraphState::settingsRepository).shouldSaveAccessCodes()
-
-            // Nothing to change
-            if (shouldSaveAccessCodes == enable) {
-                store.dispatchWithMain(DetailsAction.AppSettings.SwitchPrivacySetting.Success)
-                return@launch
-            }
-
-            toggleSaveAccessCodes(state.scanResponse, state.appSettingsState.saveWallets, enable)
-                .doOnFailure {
-                    store.dispatchWithMain(
-                        DetailsAction.AppSettings.SwitchPrivacySetting.Failure(
-                            prevState = !enable,
-                            setting = AppSetting.SaveAccessCode,
-                        ),
-                    )
-                }
-                .doOnSuccess {
-                    store.dispatchWithMain(DetailsAction.AppSettings.SwitchPrivacySetting.Success)
-                }
-        }
-
-        private suspend fun toggleSaveAccessCodes(
-            scanResponse: ScanResponse?,
-            isWalletsSavingEnabled: Boolean,
-            enable: Boolean,
-        ): CompletionResult<Unit> {
-            return if (enable) {
-                if (!isWalletsSavingEnabled) {
-                    saveCurrentWallet(scanResponse, enableAccessCodesSaving = true)
-                } else {
-                    saveAccessCodes(scanResponse)
-                }
-            } else {
-                deleteSavedAccessCodes()
-            }
-        }
-
-        private suspend fun saveCurrentWallet(
-            scanResponse: ScanResponse?,
-            enableAccessCodesSaving: Boolean,
-        ): CompletionResult<Unit> {
-            store.inject(DaggerGraphState::walletsRepository).saveShouldSaveUserWallets(item = true)
-
-            return if (enableAccessCodesSaving) {
-                saveAccessCodes(scanResponse)
-            } else {
-                CompletionResult.Success(Unit)
-            }
-                .doOnSuccess {
-                    Analytics.send(Settings.AppSettings.SaveWalletSwitcherChanged(AnalyticsParam.OnOffState.On))
-                }
-                .doOnFailure { error ->
-                    Timber.e(error, "Unable to save user wallet")
-                }
-        }
-
-        private suspend fun deleteSavedWalletsAndAccessCodes(): CompletionResult<Unit> {
-            Analytics.send(Settings.AppSettings.SaveWalletSwitcherChanged(AnalyticsParam.OnOffState.Off))
-
-            deleteSavedAccessCodes()
-            store.inject(DaggerGraphState::walletsRepository).saveShouldSaveUserWallets(item = false)
-
-            store.dispatchNavigationAction { replaceAll(AppRoute.Home()) }
-
-            return CompletionResult.Success(Unit)
-        }
-
-        private suspend fun saveAccessCodes(scanResponse: ScanResponse?): CompletionResult<Unit> {
-            Analytics.send(Settings.AppSettings.SaveAccessCodeSwitcherChanged(AnalyticsParam.OnOffState.On))
-
-            store.inject(DaggerGraphState::settingsRepository).setShouldSaveAccessCodes(value = true)
-
-            store.inject(DaggerGraphState::cardSdkConfigRepository).setAccessCodeRequestPolicy(
-                isBiometricsRequestPolicy = scanResponse?.card?.isAccessCodeSet == true,
-            )
-
-            return CompletionResult.Success(Unit)
-        }
-
         private suspend fun deleteSavedAccessCodes(): CompletionResult<Unit> {
             return tangemSdkManager.clearSavedUserCodes()
                 .doOnSuccess {

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

@@ -38,15 +38,6 @@ private fun handlePrivacyAction(action: DetailsAction.AppSettings, state: Detail
     return when (action) {
         is DetailsAction.AppSettings.SwitchPrivacySetting -> state.copy(
             appSettingsState = when (action.setting) {
-                AppSetting.SaveWallets -> state.appSettingsState.copy(
-                    isInProgress = true,
-                    saveWallets = action.enable,
-                )
-                AppSetting.SaveAccessCode -> state.appSettingsState.copy(
-                    isInProgress = true,
-                    saveWallets = true, // User can't enable access codes saving without wallets saving
-                    saveAccessCodes = action.enable,
-                )
                 AppSetting.RequireAccessCode -> state.appSettingsState.copy(
                     isInProgress = true,
                     requireAccessCode = action.enable,
@@ -64,14 +55,6 @@ private fun handlePrivacyAction(action: DetailsAction.AppSettings, state: Detail
         )
         is DetailsAction.AppSettings.SwitchPrivacySetting.Failure -> state.copy(
             appSettingsState = when (action.setting) {
-                AppSetting.SaveWallets -> state.appSettingsState.copy(
-                    isInProgress = false,
-                    saveWallets = action.prevState,
-                )
-                AppSetting.SaveAccessCode -> state.appSettingsState.copy(
-                    isInProgress = false,
-                    saveAccessCodes = action.prevState,
-                )
                 AppSetting.RequireAccessCode -> state.appSettingsState.copy(
                     isInProgress = false,
                     requireAccessCode = action.prevState,
@@ -105,9 +88,6 @@ private fun handlePrivacyAction(action: DetailsAction.AppSettings, state: Detail
         // state should be copied to avoid concurrent modifications from different sources
         is DetailsAction.AppSettings.Prepare -> state.copy(
             appSettingsState = state.appSettingsState.copy(
-                saveWallets = action.state.saveWallets,
-                saveAccessCodes = action.state.saveAccessCodes,
-                isBiometricsAvailable = action.state.isBiometricsAvailable,
                 isHidingEnabled = action.state.isHidingEnabled,
                 selectedAppCurrency = action.state.selectedAppCurrency,
                 selectedThemeMode = action.state.selectedThemeMode,

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

@@ -13,12 +13,6 @@ data class DetailsState(
 
 @Suppress("BooleanPropertyNaming")
 data class AppSettingsState(
-    @Deprecated("Delete after hot wallet release")
-    val saveWallets: Boolean = false,
-    @Deprecated("Delete after hot wallet release")
-    val saveAccessCodes: Boolean = false,
-    @Deprecated("Delete after hot wallet release")
-    val isBiometricsAvailable: Boolean = false,
     val requireAccessCode: Boolean = false,
     val useBiometricAuthentication: Boolean = false,
     val needEnrollBiometrics: Boolean = false,
@@ -32,5 +26,5 @@ data class AppSettingsState(
 enum class SecurityOption { LongTap, PassCode, AccessCode }
 
 enum class AppSetting {
-    SaveWallets, SaveAccessCode, RequireAccessCode, BiometricAuthentication,
+    RequireAccessCode, BiometricAuthentication,
 }

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

@@ -9,26 +9,6 @@ import kotlinx.collections.immutable.toImmutableList
 
 internal class AppSettingsDialogsFactory {
 
-    fun createDeleteSavedWalletsAlert(onDelete: () -> Unit, onDismiss: () -> Unit): Dialog.Alert {
-        return Dialog.Alert(
-            title = resourceReference(R.string.common_attention),
-            description = resourceReference(R.string.app_settings_off_saved_wallet_alert_message),
-            confirmText = resourceReference(R.string.common_delete),
-            onConfirm = onDelete,
-            onDismiss = onDismiss,
-        )
-    }
-
-    fun createDeleteSavedAccessCodesAlert(onDelete: () -> Unit, onDismiss: () -> Unit): Dialog.Alert {
-        return Dialog.Alert(
-            title = resourceReference(R.string.common_attention),
-            description = resourceReference(R.string.app_settings_off_saved_access_code_alert_message),
-            confirmText = resourceReference(R.string.common_delete),
-            onConfirm = onDelete,
-            onDismiss = onDismiss,
-        )
-    }
-
     fun createThemeModeSelectorDialog(
         selectedModeIndex: Int,
         onSelect: (AppThemeMode) -> Unit,

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

@@ -19,21 +19,6 @@ internal class AppSettingsItemsFactory {
         )
     }
 
-    fun createSaveWalletsSwitch(
-        isChecked: Boolean,
-        isEnabled: Boolean,
-        onCheckedChange: (Boolean) -> Unit,
-    ): Item.Switch {
-        return Item.Switch(
-            id = ID_SAVE_WALLETS_SWITCH,
-            title = resourceReference(R.string.app_settings_saved_wallet),
-            description = resourceReference(R.string.app_settings_saved_wallet_footer),
-            isEnabled = isEnabled,
-            isChecked = isChecked,
-            onCheckedChange = onCheckedChange,
-        )
-    }
-
     fun createUseBiometricsSwitch(
         isChecked: Boolean,
         isEnabled: Boolean,
@@ -127,7 +112,6 @@ internal class AppSettingsItemsFactory {
 
     companion object {
         const val ID_ENROLL_BIOMETRICS_CARD = "enroll_biometrics_card"
-        const val ID_SAVE_WALLETS_SWITCH = "save_wallets_switch"
         const val ID_SAVE_ACCESS_CODES_SWITCH = "save_access_codes_switch"
         const val ID_FLIP_TO_HIDE_BALANCE_SWITCH = "flip_to_hide_balance_switch"
         const val ID_SELECT_APP_CURRENCY_BUTTON = "select_app_currency_button"

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

@@ -97,7 +97,6 @@ private class AppSettingsScreenStateProvider : CollectionPreviewParameterProvide
         val items = persistentListOf(
             itemsFactory.createEnrollBiometricsCard {},
             itemsFactory.createSelectAppCurrencyButton(currentAppCurrencyName = "US Dollar") {},
-            itemsFactory.createSaveWalletsSwitch(isChecked = true, isEnabled = true, { _ -> }),
             itemsFactory.createSaveAccessCodeSwitch(isChecked = false, isEnabled = true) { _ -> },
             itemsFactory.createFlipToHideBalanceSwitch(isChecked = false, isEnabled = true) { _ -> },
             itemsFactory.createSelectThemeModeButton(AppThemeMode.DEFAULT, {}),

app/src/main/java/com/tangem/tap/features/details/ui/appsettings/components/SettingsAlertDialog.kt

@@ -43,12 +43,12 @@ private fun AlertDialogPreview(@PreviewParameter(AlertDialogProvider::class) dia
     }
 }
 
-private class AlertDialogProvider : CollectionPreviewParameterProvider<Dialog.Alert>(
+private class AlertDialogProvider : CollectionPreviewParameterProvider<Dialog>(
     collection = buildList {
         val dialogsFactory = AppSettingsDialogsFactory()
 
-        add(dialogsFactory.createDeleteSavedAccessCodesAlert({}, {}))
-        add(dialogsFactory.createDeleteSavedWalletsAlert({}, {}))
+        add(dialogsFactory.createThemeModeSelectorDialog(selectedModeIndex = 0, onSelect = {}, onDismiss = {}))
+        add(dialogsFactory.createDisableBiometricAuthenticationAlert(onDisable = {}, onDismiss = {}))
     },
 )
 // endregion Preview

app/src/main/java/com/tangem/tap/features/details/ui/appsettings/model/AppSettingsModel.kt

@@ -14,10 +14,7 @@ import com.tangem.domain.apptheme.model.AppThemeMode
 import com.tangem.domain.apptheme.repository.AppThemeModeRepository
 import com.tangem.domain.balancehiding.repositories.BalanceHidingRepository
 import com.tangem.domain.common.wallets.UserWalletsListRepository
-import com.tangem.domain.settings.CanUseBiometryUseCase
-import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.wallets.repository.WalletsRepository
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.tap.common.analytics.events.AnalyticsParam
 import com.tangem.tap.common.analytics.events.Settings
 import com.tangem.tap.common.extensions.dispatchNavigationAction
@@ -52,14 +49,11 @@ internal class AppSettingsModel @Inject constructor(
     override val dispatchers: CoroutineDispatcherProvider,
     private val appCurrencyRepository: AppCurrencyRepository,
     private val walletsRepository: WalletsRepository,
-    private val canUseBiometryUseCase: CanUseBiometryUseCase,
     private val userWalletsListRepository: UserWalletsListRepository,
     private val balanceHidingRepository: BalanceHidingRepository,
     private val analyticsEventHandler: AnalyticsEventHandler,
     private val appThemeModeRepository: AppThemeModeRepository,
-    private val settingsRepository: SettingsRepository,
     private val appSettingsItemsAnalyticsSender: AppSettingsItemsAnalyticsSender,
-    private val hotWalletFeatureToggles: HotWalletFeatureToggles,
     private val uiMessageSender: UiMessageSender,
 ) : Model(), StoreSubscriber<DetailsState> {
 
@@ -120,47 +114,25 @@ internal class AppSettingsModel @Inject constructor(
                 ),
             )
 
-            if (hotWalletFeatureToggles.isHotWalletEnabled) {
-                val canUseBiometrics =
-                    !state.needEnrollBiometrics && !state.isInProgress && state.hasSecuredWallets
+            val canUseBiometrics =
+                !state.needEnrollBiometrics && !state.isInProgress && state.hasSecuredWallets
 
-                add(
-                    itemsFactory.createUseBiometricsSwitch(
-                        isChecked = state.useBiometricAuthentication,
-                        isEnabled = canUseBiometrics,
-                        onCheckedChange = ::onBiometricAuthenticationToggled,
-                        onDisabledClick = ::onBiometricAuthenticationDisabledClicked,
-                    ),
-                )
+            add(
+                itemsFactory.createUseBiometricsSwitch(
+                    isChecked = state.useBiometricAuthentication,
+                    isEnabled = canUseBiometrics,
+                    onCheckedChange = ::onBiometricAuthenticationToggled,
+                    onDisabledClick = ::onBiometricAuthenticationDisabledClicked,
+                ),
+            )
 
-                add(
-                    itemsFactory.createRequireAccessCodeSwitch(
-                        isChecked = state.requireAccessCode || !state.useBiometricAuthentication,
-                        isEnabled = canUseBiometrics && state.useBiometricAuthentication,
-                        onCheckedChange = ::onRequireAccessCodeToggled,
-                    ),
-                )
-            } else {
-                if (state.isBiometricsAvailable) {
-                    val canUseBiometrics = !state.needEnrollBiometrics && !state.isInProgress
-
-                    add(
-                        itemsFactory.createSaveWalletsSwitch(
-                            isChecked = state.saveWallets,
-                            isEnabled = canUseBiometrics,
-                            onCheckedChange = ::onSaveWalletsToggled,
-                        ),
-                    )
-
-                    add(
-                        itemsFactory.createSaveAccessCodeSwitch(
-                            isChecked = state.saveAccessCodes,
-                            isEnabled = canUseBiometrics,
-                            onCheckedChange = ::onSaveAccessCodesToggled,
-                        ),
-                    )
-                }
-            }
+            add(
+                itemsFactory.createRequireAccessCodeSwitch(
+                    isChecked = state.requireAccessCode || !state.useBiometricAuthentication,
+                    isEnabled = canUseBiometrics && state.useBiometricAuthentication,
+                    onCheckedChange = ::onRequireAccessCodeToggled,
+                ),
+            )
 
             add(
                 itemsFactory.createFlipToHideBalanceSwitch(
@@ -261,42 +233,6 @@ internal class AppSettingsModel @Inject constructor(
         }
     }
 
-    private fun onSaveWalletsToggled(isChecked: Boolean) {
-        if (isChecked) {
-            onSettingsToggled(AppSetting.SaveWallets, enable = true)
-        } else {
-            updateContentState {
-                copy(
-                    dialog = dialogsFactory.createDeleteSavedWalletsAlert(
-                        onDelete = {
-                            onSettingsToggled(AppSetting.SaveWallets, enable = false)
-                            dismissDialog()
-                        },
-                        onDismiss = ::dismissDialog,
-                    ),
-                )
-            }
-        }
-    }
-
-    private fun onSaveAccessCodesToggled(isChecked: Boolean) {
-        if (isChecked) {
-            onSettingsToggled(AppSetting.SaveAccessCode, enable = true)
-        } else {
-            updateContentState {
-                copy(
-                    dialog = dialogsFactory.createDeleteSavedAccessCodesAlert(
-                        onDelete = {
-                            onSettingsToggled(AppSetting.SaveAccessCode, enable = false)
-                            dismissDialog()
-                        },
-                        onDismiss = ::dismissDialog,
-                    ),
-                )
-            }
-        }
-    }
-
     private fun onSettingsToggled(setting: AppSetting, enable: Boolean) {
         store.dispatch(DetailsAction.AppSettings.SwitchPrivacySetting(enable = enable, setting = setting))
     }
@@ -326,9 +262,6 @@ internal class AppSettingsModel @Inject constructor(
 
     private fun bootstrapBiometricsUpdates() = modelScope.launch {
         val state = AppSettingsState(
-            saveWallets = walletsRepository.shouldSaveUserWalletsSync(),
-            saveAccessCodes = settingsRepository.shouldSaveAccessCodes(),
-            isBiometricsAvailable = canUseBiometryUseCase(),
             useBiometricAuthentication = walletsRepository.useBiometricAuthentication(),
             requireAccessCode = walletsRepository.requireAccessCode(),
             isHidingEnabled = balanceHidingRepository.getBalanceHidingSettings().isHidingEnabledInSettings,

app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/model/CardSettingsModel.kt

@@ -107,6 +107,7 @@ internal class CardSettingsModel @Inject constructor(
     private fun scanCard() = modelScope.launch {
         scanCardProcessor.scan(
             analyticsSource = com.tangem.core.analytics.models.AnalyticsParam.ScreensSources.Settings,
+            shouldCheckIsAlreadyActivated = false,
             allowsRequestAccessCodeFromRepository = true,
         )
             .doOnSuccess { scanResponse ->

app/src/main/java/com/tangem/tap/features/details/ui/resetcard/model/ResetCardModel.kt

@@ -14,12 +14,9 @@ import com.tangem.domain.card.ResetCardUseCase
 import com.tangem.domain.card.ResetCardUserCodeParams
 import com.tangem.domain.card.common.util.cardTypesResolver
 import com.tangem.domain.models.wallet.requireColdWallet
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
-import com.tangem.domain.wallets.legacy.asLockable
 import com.tangem.domain.wallets.usecase.DeleteWalletUseCase
 import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
 import com.tangem.domain.wallets.usecase.GetUserWalletUseCase
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.tap.common.analytics.events.Settings
 import com.tangem.tap.common.extensions.dispatchNavigationAction
 import com.tangem.tap.common.extensions.onUserWalletSelected
@@ -52,10 +49,8 @@ internal class ResetCardModel @Inject constructor(
     private val resetCardUseCase: ResetCardUseCase,
     private val deleteSavedAccessCodesUseCase: DeleteSavedAccessCodesUseCase,
     private val deleteWalletUseCase: DeleteWalletUseCase,
-    private val userWalletsListManager: UserWalletsListManager,
     private val analyticsEventHandler: AnalyticsEventHandler,
     private val cardSettingsInteractor: CardSettingsInteractor,
-    private val hotWalletFeatureToggles: HotWalletFeatureToggles,
 ) : Model() {
 
     private val params = paramsContainer.require<ResetCardComponent.Params>()
@@ -277,16 +272,7 @@ internal class ResetCardModel @Inject constructor(
         if (newSelectedWallet != null) {
             store.dispatchNavigationAction { popTo<AppRoute.Wallet>() }
         } else {
-            if (hotWalletFeatureToggles.isHotWalletEnabled) {
-                store.dispatchNavigationAction { replaceAll(AppRoute.Home()) }
-            } else {
-                val isLocked = runCatching { userWalletsListManager.asLockable()?.isLocked }.isSuccess
-                if (isLocked && userWalletsListManager.hasUserWallets) {
-                    store.dispatchNavigationAction { popTo<AppRoute.Welcome>() }
-                } else {
-                    store.dispatchNavigationAction { replaceAll(AppRoute.Home()) }
-                }
-            }
+            store.dispatchNavigationAction { replaceAll(AppRoute.Home()) }
         }
     }
 

app/src/main/java/com/tangem/tap/features/welcome/component/DefaultWelcomeComponent.kt

@@ -1,36 +0,0 @@
-package com.tangem.tap.features.welcome.component
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Modifier
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.tangem.core.decompose.context.AppComponentContext
-import com.tangem.core.decompose.model.getOrCreateModel
-import com.tangem.tap.features.welcome.model.WelcomeModel
-import com.tangem.tap.features.welcome.ui.components.WelcomeScreen
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-
-internal class DefaultWelcomeComponent @AssistedInject constructor(
-    @Assisted context: AppComponentContext,
-    @Assisted params: WelcomeComponent.Params,
-) : WelcomeComponent, AppComponentContext by context {
-
-    private val model: WelcomeModel = getOrCreateModel(params)
-
-    @Composable
-    override fun Content(modifier: Modifier) {
-        val state by model.state.collectAsStateWithLifecycle()
-
-        WelcomeScreen(
-            modifier = modifier,
-            state = state,
-        )
-    }
-
-    @AssistedFactory
-    interface Factory : WelcomeComponent.Factory {
-        override fun create(context: AppComponentContext, params: WelcomeComponent.Params): DefaultWelcomeComponent
-    }
-}

app/src/main/java/com/tangem/tap/features/welcome/component/WelcomeComponent.kt

@@ -1,14 +0,0 @@
-package com.tangem.tap.features.welcome.component
-
-import com.tangem.common.routing.entity.InitScreenLaunchMode
-import com.tangem.core.decompose.factory.ComponentFactory
-import com.tangem.core.ui.decompose.ComposableContentComponent
-
-interface WelcomeComponent : ComposableContentComponent {
-
-    data class Params(
-        val launchMode: InitScreenLaunchMode,
-    )
-
-    interface Factory : ComponentFactory<Params, WelcomeComponent>
-}

app/src/main/java/com/tangem/tap/features/welcome/component/impl/PreviewWelcomeComponent.kt

@@ -1,20 +0,0 @@
-package com.tangem.tap.features.welcome.component.impl
-
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import com.tangem.tap.features.welcome.component.WelcomeComponent
-import com.tangem.tap.features.welcome.ui.WelcomeScreenState
-import com.tangem.tap.features.welcome.ui.components.WelcomeScreen
-
-internal class PreviewWelcomeComponent(
-    private val initialState: WelcomeScreenState = WelcomeScreenState(),
-) : WelcomeComponent {
-
-    @Composable
-    override fun Content(modifier: Modifier) {
-        WelcomeScreen(
-            modifier = modifier,
-            state = initialState,
-        )
-    }
-}

app/src/main/java/com/tangem/tap/features/welcome/di/ComponentModule.kt

@@ -1,18 +0,0 @@
-package com.tangem.tap.features.welcome.di
-
-import com.tangem.tap.features.welcome.component.DefaultWelcomeComponent
-import com.tangem.tap.features.welcome.component.WelcomeComponent
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-internal interface ComponentModule {
-
-    @Binds
-    @Singleton
-    fun bindWelcomeComponentFactory(factory: DefaultWelcomeComponent.Factory): WelcomeComponent.Factory
-}

app/src/main/java/com/tangem/tap/features/welcome/di/ModelModule.kt

@@ -1,20 +0,0 @@
-package com.tangem.tap.features.welcome.di
-
-import com.tangem.core.decompose.di.ModelComponent
-import com.tangem.core.decompose.model.Model
-import com.tangem.tap.features.welcome.model.WelcomeModel
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.multibindings.ClassKey
-import dagger.multibindings.IntoMap
-
-@Module
-@InstallIn(ModelComponent::class)
-internal interface ModelModule {
-
-    @Binds
-    @IntoMap
-    @ClassKey(WelcomeModel::class)
-    fun bindWelcomeModel(model: WelcomeModel): Model
-}

app/src/main/java/com/tangem/tap/features/welcome/model/WelcomeModel.kt

@@ -1,140 +0,0 @@
-package com.tangem.tap.features.welcome.model
-
-import com.tangem.common.core.TangemError
-import com.tangem.common.routing.entity.InitScreenLaunchMode
-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.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.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
-import com.tangem.tap.features.welcome.ui.WelcomeScreenState
-import com.tangem.tap.features.welcome.ui.model.WarningModel
-import com.tangem.tap.store
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.update
-import org.rekotlin.StoreSubscriber
-import javax.inject.Inject
-
-// FIXME: Remove redux: [REDACTED_JIRA]
-@ModelScoped
-internal class WelcomeModel @Inject constructor(
-    override val dispatchers: CoroutineDispatcherProvider,
-    private val appFinisher: AppFinisher,
-    private val analyticsEventsHandler: AnalyticsEventHandler,
-    paramsContainer: ParamsContainer,
-) : Model(), StoreSubscriber<WelcomeState> {
-
-    private val params: WelcomeComponent.Params = paramsContainer.require()
-    private val initialState: WelcomeScreenState = WelcomeScreenState(
-        onPopBack = appFinisher::finish,
-        onUnlockClick = this::unlockWallets,
-        onScanCardClick = this::scanCard,
-        onCloseError = this::closeError,
-    )
-
-    val state: MutableStateFlow<WelcomeScreenState> = MutableStateFlow(initialState)
-
-    init {
-        subscribeToStoreChanges()
-        initGlobalState()
-
-        val welcomeAction = when (params.launchMode) {
-            is InitScreenLaunchMode.WithCardScan -> WelcomeAction.ProceedWithCard
-            is InitScreenLaunchMode.Standard -> WelcomeAction.ProceedWithBiometrics
-        }
-
-        store.dispatch(welcomeAction)
-    }
-
-    private fun unlockWallets() {
-        analyticsEventsHandler.send(SignIn.ButtonBiometricSignIn())
-        store.dispatch(WelcomeAction.ProceedWithBiometrics)
-    }
-
-    private fun scanCard() {
-        analyticsEventsHandler.send(SignIn.ButtonCardSignIn())
-        store.dispatch(WelcomeAction.ProceedWithCard)
-    }
-
-    private fun closeError() {
-        store.dispatch(WelcomeAction.CloseError)
-    }
-
-    override fun newState(state: WelcomeState) {
-        val warning = createWarningIfNeeded(state.error)
-
-        this.state.update { prevState ->
-            prevState.copy(
-                isUnlockWithBiometricsProgressVisible = state.isUnlockWithBiometricsInProgress,
-                isUnlockWithCardProgressVisible = state.isUnlockWithCardInProgress,
-                warning = warning,
-                error = state.error
-                    ?.takeIf { !it.silent && warning == null }
-                    ?.let { error ->
-                        val messageResId = error.messageResId
-                        if (messageResId != null) {
-                            TextReference.Res(messageResId)
-                        } else {
-                            TextReference.Str(error.customMessage)
-                        }
-                    },
-            )
-        }
-    }
-
-    override fun onDestroy() {
-        store.unsubscribe(subscriber = this)
-
-        super.onDestroy()
-    }
-
-    private fun createWarningIfNeeded(error: TangemError?): WarningModel? {
-        return when (error) {
-            is UserWalletsListError.BiometricsAuthenticationLockout -> WarningModel.BiometricsLockoutWarning(
-                isPermanent = error.isPermanent,
-                onDismiss = this::dismissWarning,
-            )
-            is UserWalletsListError.AllKeysInvalidated,
-            is UserWalletsListError.NoUserWalletSelected,
-            -> WarningModel.KeyInvalidatedWarning(
-                onDismiss = this::dismissWarning,
-            )
-            is UserWalletsListError.BiometricsAuthenticationDisabled -> WarningModel.BiometricsDisabledWarning(
-                onDismiss = this::clearUserWallets,
-            )
-            else -> null
-        }
-    }
-
-    private fun dismissWarning() {
-        state.update { prevState ->
-            prevState.copy(
-                warning = null,
-            )
-        }
-        closeError()
-    }
-
-    private fun clearUserWallets() {
-        store.dispatch(WelcomeAction.ClearUserWallets)
-    }
-
-    private fun subscribeToStoreChanges() {
-        store.subscribe(this) { appState ->
-            appState.skip { old, new -> old.welcomeState == new.welcomeState }
-                .select { it.welcomeState }
-        }
-    }
-
-    private fun initGlobalState() {
-        store.dispatch(GlobalAction.RestoreAppCurrency)
-    }
-}

app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeAction.kt

@@ -1,22 +0,0 @@
-package com.tangem.tap.features.welcome.redux
-
-import com.tangem.common.core.TangemError
-import org.rekotlin.Action
-
-internal sealed interface WelcomeAction : Action {
-
-    data object ProceedWithBiometrics : WelcomeAction {
-        object Success : WelcomeAction
-        data class Error(val error: TangemError) : WelcomeAction
-    }
-
-    object ProceedWithCard : WelcomeAction {
-        object Success : WelcomeAction
-        data class Error(val error: TangemError) : WelcomeAction
-        data class ChangeProgress(val isProgress: Boolean) : WelcomeAction
-    }
-
-    object CloseError : WelcomeAction
-
-    object ClearUserWallets : WelcomeAction
-}

app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeMiddleware.kt

@@ -1,164 +0,0 @@
-package com.tangem.tap.features.welcome.redux
-
-import com.tangem.common.core.TangemSdkError
-import com.tangem.common.doOnFailure
-import com.tangem.common.doOnResult
-import com.tangem.common.doOnSuccess
-import com.tangem.common.flatMap
-import com.tangem.common.routing.AppRoute
-import com.tangem.common.routing.utils.popTo
-import com.tangem.core.analytics.Analytics
-import com.tangem.core.analytics.models.AnalyticsParam
-import com.tangem.core.analytics.models.Basic
-import com.tangem.domain.card.analytics.ParamCardCurrencyConverter
-import com.tangem.domain.card.common.util.cardTypesResolver
-import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.wallets.legacy.UserWalletsListManager.Lockable.UnlockType
-import com.tangem.domain.wallets.legacy.unlockIfLockable
-import com.tangem.tap.*
-import com.tangem.tap.common.extensions.*
-import com.tangem.tap.common.redux.AppState
-import com.tangem.tap.proxy.redux.DaggerGraphState
-import kotlinx.coroutines.launch
-import org.rekotlin.Middleware
-import timber.log.Timber
-
-internal class WelcomeMiddleware {
-    val middleware: Middleware<AppState> = { _, appStateProvider ->
-        { next ->
-            { action ->
-                val appState = appStateProvider()
-                if (action is WelcomeAction && appState != null) {
-                    handleAction(action)
-                }
-                next(action)
-            }
-        }
-    }
-
-    private fun handleAction(action: WelcomeAction) {
-        mainScope.launch {
-            when (action) {
-                is WelcomeAction.ProceedWithBiometrics -> proceedWithBiometrics()
-                is WelcomeAction.ProceedWithCard -> proceedWithCard()
-                is WelcomeAction.ClearUserWallets -> disableUserWalletsSaving()
-                else -> Unit
-            }
-        }
-    }
-
-    private suspend fun proceedWithBiometrics() {
-        val userWalletsListManager = store.inject(DaggerGraphState::generalUserWalletsListManager)
-        userWalletsListManager.unlockIfLockable(type = UnlockType.ANY)
-            .doOnFailure { error ->
-                Timber.e(error, "Unable to unlock user wallets with biometrics")
-                store.dispatchWithMain(WelcomeAction.ProceedWithBiometrics.Error(error))
-            }
-            .doOnSuccess { selectedUserWallet ->
-                sendSignedInAnalyticsEvent(
-                    userWallet = selectedUserWallet,
-                    signInType = Basic.SignedInLegacy.SignInType.Biometric,
-                )
-
-                store.dispatchNavigationAction { replaceAll(AppRoute.Wallet) }
-                store.dispatchWithMain(WelcomeAction.ProceedWithBiometrics.Success)
-                store.onUserWalletSelected(userWallet = selectedUserWallet)
-            }
-    }
-
-    private suspend fun proceedWithCard() {
-        scanCardInternal { scanResponse ->
-            val userWalletBuilder = store.inject(DaggerGraphState::coldUserWalletBuilderFactory).create(scanResponse)
-
-            val userWallet = userWalletBuilder.build() ?: return@scanCardInternal
-
-            val userWalletsListManager = store.inject(DaggerGraphState::generalUserWalletsListManager)
-            userWalletsListManager.save(userWallet, canOverride = true)
-                .doOnFailure { error ->
-                    Timber.e(error, "Unable to save user wallet")
-                    store.dispatchWithMain(WelcomeAction.ProceedWithCard.Error(error))
-                }
-                .doOnSuccess {
-                    sendSignedInAnalyticsEvent(userWallet, signInType = Basic.SignedInLegacy.SignInType.Card)
-
-                    store.dispatchNavigationAction { replaceAll(AppRoute.Wallet) }
-                    store.dispatchWithMain(WelcomeAction.ProceedWithCard.Success)
-                    store.onUserWalletSelected(userWallet = userWallet)
-                }
-        }
-    }
-
-    private fun sendSignedInAnalyticsEvent(userWallet: UserWallet, signInType: Basic.SignedInLegacy.SignInType) {
-        if (userWallet !is UserWallet.Cold) {
-            return
-        }
-
-        val scanResponse = userWallet.scanResponse
-        val currency = ParamCardCurrencyConverter().convert(
-            value = scanResponse.cardTypesResolver,
-        )
-
-        val trackingContextProxy = store.inject(DaggerGraphState::trackingContextProxy)
-        trackingContextProxy.addContext(scanResponse)
-
-        if (currency != null) {
-            val userWalletsListManager = store.inject(DaggerGraphState::generalUserWalletsListManager)
-
-            Analytics.send(
-                event = Basic.SignedInLegacy(
-                    currency = currency,
-                    batch = scanResponse.card.batchId,
-                    signInType = signInType,
-                    walletsCount = userWalletsListManager.walletsCount.toString(),
-                    isImported = userWallet.isImported,
-                    hasBackup = scanResponse.card.backupStatus?.isActive,
-                ),
-            )
-        }
-    }
-
-    private suspend fun disableUserWalletsSaving() {
-        val userWalletsListManager = store.inject(DaggerGraphState::generalUserWalletsListManager)
-        userWalletsListManager.clear()
-            .flatMap { tangemSdkManager.clearSavedUserCodes() }
-            .doOnFailure { e ->
-                Timber.e(e, "Unable to clear user wallets")
-            }
-            .doOnResult {
-                store.dispatchWithMain(WelcomeAction.CloseError)
-                store.dispatchNavigationAction { popTo<AppRoute.Home>() }
-            }
-    }
-
-    private suspend inline fun scanCardInternal(crossinline onCardScanned: suspend (ScanResponse) -> Unit) {
-        val shouldSaveAccessCodes = store.inject(DaggerGraphState::settingsRepository).shouldSaveAccessCodes()
-
-        store.inject(DaggerGraphState::cardSdkConfigRepository).setAccessCodeRequestPolicy(
-            isBiometricsRequestPolicy = shouldSaveAccessCodes,
-        )
-
-        store.inject(DaggerGraphState::scanCardProcessor).scan(
-            analyticsSource = AnalyticsParam.ScreensSources.SignIn,
-            onSuccess = { scanResponse ->
-                scope.launch { onCardScanned(scanResponse) }
-            },
-            onFailure = { error ->
-                when (error) {
-                    is TangemSdkError.ExceptionError -> {
-                        store.dispatchOnMain(WelcomeAction.ProceedWithCard.Success)
-                    }
-                    else -> {
-                        store.dispatchOnMain(WelcomeAction.ProceedWithCard.Error(error))
-                    }
-                }
-            },
-            onProgressStateChange = {
-                store.dispatchWithMain(WelcomeAction.ProceedWithCard.ChangeProgress(it))
-            },
-            onWalletNotCreated = {
-                store.dispatchOnMain(WelcomeAction.ProceedWithCard.Success)
-            },
-        )
-    }
-}

app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeReducer.kt

@@ -1,36 +0,0 @@
-package com.tangem.tap.features.welcome.redux
-
-import com.tangem.tap.common.redux.AppState
-import org.rekotlin.Action
-
-internal object WelcomeReducer {
-    fun reduce(action: Action, state: AppState): WelcomeState {
-        return if (action is WelcomeAction) {
-            internalReduce(action, state.welcomeState)
-        } else {
-            state.welcomeState
-        }
-    }
-
-    private fun internalReduce(action: WelcomeAction, state: WelcomeState): WelcomeState {
-        return when (action) {
-            is WelcomeAction.ProceedWithBiometrics -> state.copy(isUnlockWithBiometricsInProgress = true)
-            is WelcomeAction.ProceedWithCard -> state.copy(isUnlockWithCardInProgress = true)
-            is WelcomeAction.ProceedWithBiometrics.Error -> state.copy(
-                error = action.error,
-                isUnlockWithBiometricsInProgress = false,
-            )
-            is WelcomeAction.ProceedWithCard.Error -> state.copy(
-                error = action.error,
-                isUnlockWithCardInProgress = false,
-            )
-            is WelcomeAction.ProceedWithCard.ChangeProgress -> state.copy(
-                isUnlockWithCardInProgress = action.isProgress,
-            )
-            is WelcomeAction.ProceedWithBiometrics.Success -> state.copy(isUnlockWithBiometricsInProgress = false)
-            is WelcomeAction.ProceedWithCard.Success -> state.copy(isUnlockWithCardInProgress = false)
-            is WelcomeAction.CloseError -> state.copy(error = null)
-            else -> state
-        }
-    }
-}

app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeState.kt

@@ -1,10 +0,0 @@
-package com.tangem.tap.features.welcome.redux
-
-import com.tangem.common.core.TangemError
-import org.rekotlin.StateType
-
-data class WelcomeState(
-    val isUnlockWithBiometricsInProgress: Boolean = false,
-    val isUnlockWithCardInProgress: Boolean = false,
-    val error: TangemError? = null,
-) : StateType

app/src/main/java/com/tangem/tap/features/welcome/ui/WelcomeScreenState.kt

@@ -1,15 +0,0 @@
-package com.tangem.tap.features.welcome.ui
-
-import com.tangem.core.ui.extensions.TextReference
-import com.tangem.tap.features.welcome.ui.model.WarningModel
-
-internal data class WelcomeScreenState(
-    val onPopBack: () -> Unit = {},
-    val isUnlockWithBiometricsProgressVisible: Boolean = false,
-    val isUnlockWithCardProgressVisible: Boolean = false,
-    val warning: WarningModel? = null,
-    val error: TextReference? = null,
-    val onUnlockClick: () -> Unit = {},
-    val onScanCardClick: () -> Unit = {},
-    val onCloseError: () -> Unit = {},
-)

app/src/main/java/com/tangem/tap/features/welcome/ui/components/WarningDialog.kt

@@ -1,136 +0,0 @@
-package com.tangem.tap.features.welcome.ui.components
-
-import android.content.res.Configuration
-import androidx.compose.foundation.layout.Column
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.tooling.preview.Preview
-import com.tangem.core.ui.components.BasicDialog
-import com.tangem.core.ui.components.DialogButtonUM
-import com.tangem.core.ui.extensions.stringResourceSafe
-import com.tangem.core.ui.res.TangemThemePreview
-import com.tangem.tap.features.welcome.ui.model.WarningModel
-import com.tangem.wallet.R
-
-@Composable
-internal fun WarningDialog(warning: WarningModel?) {
-    when (warning) {
-        null -> Unit
-        is WarningModel.BiometricsLockoutWarning -> {
-            BasicDialog(
-                title = stringResourceSafe(id = R.string.biometric_lockout_warning_title),
-                message = stringResourceSafe(
-                    id = if (warning.isPermanent) {
-                        R.string.biometric_lockout_permanent_warning_description
-                    } else {
-                        R.string.biometric_lockout_warning_description
-                    },
-                ),
-                onDismissDialog = warning.onDismiss,
-                confirmButton = DialogButtonUM(
-                    title = stringResourceSafe(id = R.string.common_ok),
-                    onClick = warning.onDismiss,
-                ),
-            )
-        }
-        is WarningModel.KeyInvalidatedWarning -> {
-            BasicDialog(
-                title = stringResourceSafe(id = R.string.common_attention),
-                message = stringResourceSafe(id = R.string.key_invalidated_warning_description),
-                onDismissDialog = warning.onDismiss,
-                confirmButton = DialogButtonUM(
-                    title = stringResourceSafe(id = R.string.common_ok),
-                    onClick = warning.onDismiss,
-                ),
-            )
-        }
-        is WarningModel.BiometricsDisabledWarning -> {
-            BasicDialog(
-                title = stringResourceSafe(id = R.string.common_warning),
-                message = stringResourceSafe(id = R.string.biometric_unavailable_warning),
-                onDismissDialog = warning.onDismiss,
-                isDismissable = false,
-                confirmButton = DialogButtonUM(
-                    title = stringResourceSafe(id = R.string.common_ok),
-                    onClick = warning.onDismiss,
-                ),
-            )
-        }
-    }
-}
-
-// region Preview
-@Composable
-private fun BiometricsLockoutDialogSample(modifier: Modifier = Modifier) {
-    Column(modifier = modifier) {
-        WarningDialog(
-            warning = WarningModel.BiometricsLockoutWarning(
-                isPermanent = false,
-                onDismiss = {},
-            ),
-        )
-    }
-}
-
-@Preview(showBackground = true, widthDp = 360)
-@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
-@Composable
-private fun BiometricsLockoutDialogPreview() {
-    TangemThemePreview {
-        BiometricsLockoutDialogSample()
-    }
-}
-
-@Composable
-private fun BiometricsLockoutDialog_Permanent_Sample(modifier: Modifier = Modifier) {
-    Column(modifier = modifier) {
-        WarningDialog(
-            warning = WarningModel.BiometricsLockoutWarning(
-                isPermanent = true,
-                onDismiss = {},
-            ),
-        )
-    }
-}
-
-@Preview(showBackground = true, widthDp = 360)
-@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
-@Composable
-private fun BiometricsLockoutDialog_Permanent_Preview() {
-    TangemThemePreview {
-        BiometricsLockoutDialog_Permanent_Sample()
-    }
-}
-
-@Composable
-private fun KeyInvalidatedWarningSample(modifier: Modifier = Modifier) {
-    Column(modifier = modifier) {
-        WarningDialog(warning = WarningModel.KeyInvalidatedWarning(onDismiss = {}))
-    }
-}
-
-@Preview(showBackground = true, widthDp = 360)
-@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
-@Composable
-private fun KeyInvalidatedWarningPreview() {
-    TangemThemePreview {
-        KeyInvalidatedWarningSample()
-    }
-}
-
-@Composable
-private fun BiometricDisabledWarningSample(modifier: Modifier = Modifier) {
-    Column(modifier = modifier) {
-        WarningDialog(warning = WarningModel.BiometricsDisabledWarning(onDismiss = {}))
-    }
-}
-
-@Preview(showBackground = true, widthDp = 360)
-@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
-@Composable
-private fun BiometricDisabledWarningPreview() {
-    TangemThemePreview {
-        BiometricDisabledWarningSample()
-    }
-}
-// endregion Preview

app/src/main/java/com/tangem/tap/features/welcome/ui/components/WelcomeScreen.kt

@@ -1,101 +0,0 @@
-package com.tangem.tap.features.welcome.ui.components
-
-import android.content.res.Configuration
-import androidx.activity.compose.BackHandler
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.systemBarsPadding
-import androidx.compose.material3.SnackbarHost
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.tooling.preview.PreviewParameter
-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.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
-import com.tangem.tap.features.welcome.ui.model.WarningModel
-
-@Composable
-internal fun WelcomeScreen(state: WelcomeScreenState, modifier: Modifier = Modifier) {
-    val snackbarHostState = remember { SnackbarHostState() }
-    val errorMessage by rememberUpdatedState(newValue = state.error?.resolveReference())
-    val warning by rememberUpdatedState(newValue = state.warning)
-
-    BackHandler(onBack = state.onPopBack)
-
-    Box(
-        modifier = modifier
-            .background(TangemTheme.colors.background.primary)
-            .systemBarsPadding(),
-    ) {
-        WelcomeScreenContent(
-            showUnlockProgress = state.isUnlockWithBiometricsProgressVisible,
-            showScanCardProgress = state.isUnlockWithCardProgressVisible,
-            onUnlockClick = state.onUnlockClick,
-            onScanCardClick = state.onScanCardClick,
-        )
-
-        SnackbarHost(
-            modifier = Modifier
-                .align(Alignment.BottomCenter)
-                .padding(vertical = 16.dp)
-                .fillMaxWidth(),
-            hostState = snackbarHostState,
-        )
-    }
-
-    WarningDialog(warning)
-
-    LaunchedEffect(errorMessage, state.onCloseError) {
-        errorMessage?.let { message ->
-            snackbarHostState.showSnackbar(message)
-            state.onCloseError()
-        }
-    }
-}
-
-// region Preview
-@Composable
-@Preview(showBackground = true, widthDp = 360)
-@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
-private fun Preview_WelcomeScreen(
-    @PreviewParameter(WelcomeComponentPreviewProvider::class) component: WelcomeComponent,
-) {
-    TangemThemePreview {
-        component.Content(Modifier)
-    }
-}
-
-private class WelcomeComponentPreviewProvider : PreviewParameterProvider<WelcomeComponent> {
-    override val values: Sequence<WelcomeComponent>
-        get() = sequenceOf(
-            PreviewWelcomeComponent(),
-            PreviewWelcomeComponent(
-                initialState = WelcomeScreenState(
-                    isUnlockWithBiometricsProgressVisible = true,
-                    isUnlockWithCardProgressVisible = true,
-                ),
-            ),
-            PreviewWelcomeComponent(
-                initialState = WelcomeScreenState(
-                    error = TextReference.Str(value = "Error"),
-                ),
-            ),
-            PreviewWelcomeComponent(
-                initialState = WelcomeScreenState(
-                    warning = WarningModel.KeyInvalidatedWarning(onDismiss = {}),
-                ),
-            ),
-        )
-}
-// endregion Preview

app/src/main/java/com/tangem/tap/features/welcome/ui/components/WelcomeScreenContent.kt

@@ -1,113 +0,0 @@
-package com.tangem.tap.features.welcome.ui.components
-
-import android.content.res.Configuration
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.tooling.preview.Preview
-import com.tangem.core.ui.components.*
-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
-
-@Suppress("LongMethod")
-@Composable
-internal fun WelcomeScreenContent(
-    showUnlockProgress: Boolean,
-    showScanCardProgress: Boolean,
-    onUnlockClick: () -> Unit,
-    onScanCardClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    Column(
-        modifier = modifier,
-        horizontalAlignment = Alignment.CenterHorizontally,
-    ) {
-        SpacerHMax()
-        Icon(
-            modifier = Modifier.size(TangemTheme.dimens.size96),
-            painter = painterResource(id = R.drawable.img_tangem_logo_96),
-            tint = TangemTheme.colors.icon.primary1,
-            contentDescription = null,
-        )
-        SpacerH32()
-        Text(
-            modifier = Modifier
-                .padding(horizontal = TangemTheme.dimens.spacing16)
-                .fillMaxWidth(),
-            text = stringResourceSafe(R.string.welcome_unlock_title),
-            style = TangemTheme.typography.h2,
-            color = TangemTheme.colors.text.primary1,
-            textAlign = TextAlign.Center,
-        )
-        SpacerH12()
-        Text(
-            modifier = Modifier
-                .padding(horizontal = TangemTheme.dimens.spacing44)
-                .fillMaxWidth(),
-            text = stringResourceSafe(
-                id = R.string.welcome_unlock_description,
-                stringResourceSafe(id = R.string.common_biometric_authentication),
-            ),
-            style = TangemTheme.typography.body1,
-            color = TangemTheme.colors.text.secondary,
-            textAlign = TextAlign.Center,
-        )
-        SpacerHMax()
-        SecondaryButton(
-            modifier = Modifier
-                .padding(horizontal = TangemTheme.dimens.spacing16)
-                .fillMaxWidth(),
-            text = stringResourceSafe(
-                id = R.string.welcome_unlock,
-                stringResourceSafe(id = R.string.common_biometrics),
-            ),
-            showProgress = showUnlockProgress,
-            onClick = onUnlockClick,
-        )
-        SpacerH12()
-        PrimaryButtonIconEnd(
-            modifier = Modifier
-                .padding(horizontal = TangemTheme.dimens.spacing16)
-                .fillMaxWidth(),
-            text = stringResourceSafe(R.string.welcome_unlock_card),
-            showProgress = showScanCardProgress,
-            iconResId = R.drawable.ic_tangem_24,
-            onClick = onScanCardClick,
-        )
-        SpacerH16()
-    }
-}
-
-// region Preview
-@Composable
-private fun WelcomeScreenContentSample(modifier: Modifier = Modifier) {
-    Box(
-        modifier = modifier
-            .background(TangemTheme.colors.background.primary),
-    ) {
-        WelcomeScreenContent(
-            showUnlockProgress = false,
-            showScanCardProgress = false,
-            onUnlockClick = { /* no-op */ },
-            onScanCardClick = { /* no-op */ },
-        )
-    }
-}
-
-@Preview(showBackground = true, widthDp = 360)
-@Preview(showBackground = true, widthDp = 360, uiMode = Configuration.UI_MODE_NIGHT_YES)
-@Composable
-private fun WelcomeScreenContentPreview() {
-    TangemThemePreview {
-        WelcomeScreenContentSample()
-    }
-}
-// endregion Preview

app/src/main/java/com/tangem/tap/features/welcome/ui/model/WarningModel.kt

@@ -1,16 +0,0 @@
-package com.tangem.tap.features.welcome.ui.model
-
-internal sealed interface WarningModel {
-    data class BiometricsLockoutWarning(
-        val isPermanent: Boolean,
-        val onDismiss: () -> Unit,
-    ) : WarningModel
-
-    data class KeyInvalidatedWarning(
-        val onDismiss: () -> Unit,
-    ) : WarningModel
-
-    data class BiometricsDisabledWarning(
-        val onDismiss: () -> Unit,
-    ) : WarningModel
-}

app/src/main/java/com/tangem/tap/network/auth/DefaultAuthProvider.kt

@@ -6,14 +6,11 @@ import com.tangem.datasource.api.common.config.ApiEnvironment
 import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.utils.Provider
 import com.tangem.utils.ProviderSuspend
 
 internal class DefaultAuthProvider(
-    private val userWalletsListManager: UserWalletsListManager,
     private val userWalletsListRepository: UserWalletsListRepository,
-    private val shouldUseNewListRepository: Boolean = false,
     private val environmentConfigStorage: EnvironmentConfigStorage,
 ) : AuthProvider {
 
@@ -71,18 +68,10 @@ internal class DefaultAuthProvider(
     }
 
     private suspend fun getWallets(): List<UserWallet> {
-        return if (shouldUseNewListRepository) {
-            userWalletsListRepository.userWalletsSync()
-        } else {
-            userWalletsListManager.userWalletsSync
-        }
+        return userWalletsListRepository.userWalletsSync()
     }
 
     private suspend fun getSelectedWallet(): UserWallet? {
-        return if (shouldUseNewListRepository) {
-            userWalletsListRepository.selectedUserWalletSync()
-        } else {
-            userWalletsListManager.selectedUserWalletSync
-        }
+        return userWalletsListRepository.selectedUserWalletSync()
     }
 }

app/src/main/java/com/tangem/tap/network/auth/di/AuthModule.kt

@@ -3,16 +3,10 @@ package com.tangem.tap.network.auth.di
 import com.tangem.datasource.api.common.AuthProvider
 import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
 import com.tangem.domain.common.wallets.UserWalletsListRepository
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.lib.auth.ExpressAuthProvider
 import com.tangem.lib.auth.P2PEthPoolAuthProvider
 import com.tangem.lib.auth.StakeKitAuthProvider
-import com.tangem.tap.network.auth.DefaultAppVersionProvider
-import com.tangem.tap.network.auth.DefaultAuthProvider
-import com.tangem.tap.network.auth.DefaultExpressAuthProvider
-import com.tangem.tap.network.auth.DefaultP2PEthPoolAuthProvider
-import com.tangem.tap.network.auth.DefaultStakeKitAuthProvider
+import com.tangem.tap.network.auth.*
 import com.tangem.utils.version.AppVersionProvider
 import dagger.Module
 import dagger.Provides
@@ -27,15 +21,11 @@ internal class AuthModule {
     @Provides
     @Singleton
     fun provideAuthProvider(
-        userWalletsListManager: UserWalletsListManager,
         userWalletsListRepository: UserWalletsListRepository,
-        hotWalletFeatureToggles: HotWalletFeatureToggles,
         environmentConfigStorage: EnvironmentConfigStorage,
     ): AuthProvider {
         return DefaultAuthProvider(
-            userWalletsListManager = userWalletsListManager,
             userWalletsListRepository = userWalletsListRepository,
-            shouldUseNewListRepository = hotWalletFeatureToggles.isHotWalletEnabled,
             environmentConfigStorage = environmentConfigStorage,
         )
     }

app/src/main/java/com/tangem/tap/network/exchangeServices/DefaultRampManager.kt

@@ -86,7 +86,7 @@ internal class DefaultRampManager(
         cryptoCurrency: CryptoCurrency,
     ): ScenarioUnavailabilityReason {
         val availabilityState = runSuspendCatching {
-            getExchangeableState(userWalletId, cryptoCurrency)
+            getExchangeableState()
         }.getOrNull() ?: ExpressAvailabilityState.Error
         return availabilityState.toReason(cryptoCurrency.name)
     }
@@ -142,21 +142,9 @@ internal class DefaultRampManager(
         }
     }
 
-    private suspend fun getExchangeableState(
-        userWalletId: UserWalletId,
-        cryptoCurrency: CryptoCurrency,
-    ): ExpressAvailabilityState {
-        val asset = expressServiceFetcher.getInitializationStatus(userWalletId).firstOrNull()
-            ?: return ExpressAvailabilityState.Loading
-        return when (asset) {
-            is Lce.Error -> ExpressAvailabilityState.Error
-            is Lce.Loading -> ExpressAvailabilityState.Loading
-            is Lce.Content -> {
-                val foundAsset = asset.getOrNull()?.find { cryptoCurrency.findAssetPredicate(assetId = it.id) }
-                foundAsset?.isExchangeAvailable?.toSwapAvailabilityState()
-                    ?: ExpressAvailabilityState.AssetNotFound
-            }
-        }
+    private fun getExchangeableState(): ExpressAvailabilityState {
+        // In task [REDACTED_TASK_KEY], removed all checks to make all tokens available
+        return ExpressAvailabilityState.Available
     }
 
     private suspend fun getOnrampAvailableState(
@@ -190,14 +178,6 @@ internal class DefaultRampManager(
         }
     }
 
-    private fun Boolean.toSwapAvailabilityState(): ExpressAvailabilityState {
-        return if (this) {
-            ExpressAvailabilityState.Available
-        } else {
-            ExpressAvailabilityState.NotExchangeable
-        }
-    }
-
     private fun Boolean.toOnrampAvailabilityState(): ExpressAvailabilityState {
         return if (this) {
             ExpressAvailabilityState.Available

app/src/main/java/com/tangem/tap/network/exchangeServices/moonpay/MoonpayBlockchainMapping.kt

@@ -163,4 +163,5 @@ internal val Blockchain.moonPaySupportedCurrency: MoonPaySupportedCurrency?
         Linea, LineaTestnet -> null
         ArbitrumNova -> null
         Plasma, PlasmaTestnet -> null
+        Monad, MonadTestnet -> null
     }

app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphState.kt

@@ -31,9 +31,7 @@ import com.tangem.domain.onboarding.repository.OnboardingRepository
 import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.builder.ColdUserWalletBuilder
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.repository.WalletsRepository
-import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
 import com.tangem.hot.sdk.TangemHotSdk
 import com.tangem.operations.attestation.CardArtworksProvider
@@ -53,7 +51,6 @@ data class DaggerGraphState(
     val appThemeModeRepository: AppThemeModeRepository? = null,
     val balanceHidingRepository: BalanceHidingRepository? = null,
     val walletsRepository: WalletsRepository? = null,
-    val generalUserWalletsListManager: UserWalletsListManager? = null,
     val wasTwinsOnboardingShownUseCase: WasTwinsOnboardingShownUseCase? = null,
     val saveTwinsOnboardingShownUseCase: SaveTwinsOnboardingShownUseCase? = null,
     val cardRepository: CardRepository? = null,
@@ -78,7 +75,6 @@ data class DaggerGraphState(
     val coldUserWalletBuilderFactory: ColdUserWalletBuilder.Factory? = null,
     val userTokensResponseStore: UserTokensResponseStore? = null,
     val userWalletsListRepository: UserWalletsListRepository? = null,
-    val hotWalletFeatureToggles: HotWalletFeatureToggles? = null,
     val tangemHotSdk: TangemHotSdk? = null,
     val trackingContextProxy: TrackingContextProxy? = null,
 ) : StateType

app/src/main/java/com/tangem/tap/routing/component/impl/DefaultRoutingComponent.kt

@@ -29,7 +29,6 @@ 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
@@ -69,7 +68,6 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
     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,
@@ -260,16 +258,14 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
     }
 
     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,
-                ),
-            )
-        }
+        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,
+            ),
+        )
     }
 }