Updated on 2026-08-14

2025-08-14 14:47:48 +03:00 · 2025-08-14 14:47:48 +03:00 · bea775e94b
commit bea775e94b
parent c68cf7165b
46 changed files with 749 additions and 178 deletions
--- a/app/src/main/java/com/tangem/tap/LockTimerWorker.kt
+++ b/app/src/main/java/com/tangem/tap/LockTimerWorker.kt
@ -7,6 +7,8 @@ import androidx.work.WorkerParameters
 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.core.wallets.UserWalletsListRepository
+import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import timber.log.Timber
@ -17,13 +19,22 @@ class LockTimerWorker @AssistedInject constructor(
    @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")
-        val userWalletsListManagerLockable = userWalletsListManager.asLockable() ?: return Result.failure()
-        userWalletsListManagerLockable.lock()
-        settingsRepository.setShouldOpenWelcomeScreenOnResume(value = true)
+        if (hotWalletFeatureToggles.isHotWalletEnabled) {
+            userWalletsListRepository.lockAllWallets()
+                .onRight {
+                    settingsRepository.setShouldOpenWelcomeScreenOnResume(value = true)
+                }
+        } else {
+            val userWalletsListManagerLockable = userWalletsListManager.asLockable() ?: return Result.failure()
+            userWalletsListManagerLockable.lock()
+            settingsRepository.setShouldOpenWelcomeScreenOnResume(value = true)
+        }
        Timber.i("onStart job complete")
        return Result.success()
    }
--- a/app/src/main/java/com/tangem/tap/LockUserWalletsTimer.kt
+++ b/app/src/main/java/com/tangem/tap/LockUserWalletsTimer.kt
@ -10,6 +10,8 @@ import com.tangem.common.routing.AppRoute
 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.core.wallets.UserWalletsListRepository
+import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.tap.LockTimerWorker.Companion.TAG
 import com.tangem.tap.common.extensions.dispatchNavigationAction
 import kotlinx.coroutines.CoroutineScope
@ -25,6 +27,8 @@ internal class LockUserWalletsTimer(
    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,
 ) : LifecycleOwner by context as LifecycleOwner,
    DefaultLifecycleObserver {
@ -108,20 +112,33 @@ internal class LockUserWalletsTimer(

        delay(duration)

-        val userWalletsListManager = userWalletsListManager.asLockable() ?: return@launch
+        if (hotWalletFeatureToggles.isHotWalletEnabled) {
+            val userWallets = userWalletsListRepository.userWalletsSync()
+            if (userWallets.isNotEmpty()) {
+                userWalletsListRepository.lockAllWallets()
+                    .onLeft {
+                        start()
+                    }
+                    .onRight {
+                        store.dispatchNavigationAction { replaceAll(AppRoute.Welcome()) }
+                    }
+            }
+        } else {
+            val userWalletsListManager = userWalletsListManager.asLockable() ?: return@launch

-        if (userWalletsListManager.hasUserWallets) {
-            val currentTime = System.currentTimeMillis()
+            if (userWalletsListManager.hasUserWallets) {
+                val currentTime = System.currentTimeMillis()

-            Timber.i(
-                """
+                Timber.i(
+                    """
                        Finished
                        |- Millis passed: ${currentTime - startTime}
-                """.trimIndent(),
-            )
+                    """.trimIndent(),
+                )

-            userWalletsListManager.lock()
-            store.dispatchNavigationAction { replaceAll(AppRoute.Welcome()) }
+                userWalletsListManager.lock()
+                store.dispatchNavigationAction { replaceAll(AppRoute.Welcome()) }
+            }
        }
    }
 }
--- a/app/src/main/java/com/tangem/tap/MainActivity.kt
+++ b/app/src/main/java/com/tangem/tap/MainActivity.kt
@ -40,6 +40,7 @@ import com.tangem.domain.apptheme.model.AppThemeMode
 import com.tangem.domain.card.ScanCardUseCase
 import com.tangem.domain.card.repository.CardRepository
 import com.tangem.domain.card.repository.CardSdkConfigRepository
+import com.tangem.domain.models.wallet.isLocked
 import com.tangem.domain.settings.SetGooglePayAvailabilityUseCase
 import com.tangem.domain.settings.SetGoogleServicesAvailabilityUseCase
 import com.tangem.domain.settings.ShouldInitiallyAskPermissionUseCase
@ -48,7 +49,9 @@ import com.tangem.domain.staking.SendUnsubmittedHashesUseCase
 import com.tangem.domain.tokens.GetPolkadotCheckHasImmortalUseCase
 import com.tangem.domain.tokens.GetPolkadotCheckHasResetUseCase
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
+import com.tangem.domain.core.wallets.UserWalletsListRepository
 import com.tangem.feature.wallet.presentation.wallet.analytics.WalletScreenAnalyticsEvent
+import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.features.tester.api.TesterMenuLauncher
 import com.tangem.features.walletconnect.components.WalletConnectFeatureToggles
 import com.tangem.google.GoogleServicesHelper
@ -188,6 +191,12 @@ class MainActivity : AppCompatActivity(), ActivityResultCallbackHolder {
    @Inject
    internal lateinit var backgroundScanIntentHandler: BackgroundScanIntentHandler

+    @Inject
+    internal lateinit var userWalletsListRepository: UserWalletsListRepository
+
+    @Inject
+    internal lateinit var hotWalletFeatureToggles: HotWalletFeatureToggles
+
    internal val viewModel: MainViewModel by viewModels()

    private lateinit var appThemeModeFlow: SharedFlow<AppThemeMode>
@ -271,6 +280,8 @@ class MainActivity : AppCompatActivity(), ActivityResultCallbackHolder {
            settingsRepository = settingsRepository,
            userWalletsListManager = userWalletsListManager,
            coroutineScope = mainScope,
+            userWalletsListRepository = userWalletsListRepository,
+            hotWalletFeatureToggles = hotWalletFeatureToggles,
        )

        initIntentHandlers()
@ -429,6 +440,12 @@ class MainActivity : AppCompatActivity(), ActivityResultCallbackHolder {
    }

    private fun navigateToInitialScreenIfNeeded(intentWhichStartedActivity: Intent?) {
+        // TODO refactor this method to return a route instead of navigating directly
+        if (hotWalletFeatureToggles.isHotWalletEnabled) {
+            navigateToInitialScreenIfNeededNew(intentWhichStartedActivity)
+            return
+        }
+
        val backStack = appRouterConfig.stack ?: emptyList()
        // TODO move inital navigation to navigation component ([REDACTED_JIRA])
        val isOnlyInitialRoute = backStack.all { it is AppRoute.Initial }
@ -448,6 +465,57 @@ class MainActivity : AppCompatActivity(), ActivityResultCallbackHolder {
        }
    }

+    @Deprecated("Refactor this method to return a route instead of navigating directly")
+    private fun navigateToInitialScreenIfNeededNew(intentWhichStartedActivity: Intent?) {
+        lifecycleScope.launch {
+            val userWallets = userWalletsListRepository.userWalletsSync()
+            val launchMode = backgroundScanIntentHandler.getInitScreenLaunchMode(intentWhichStartedActivity)
+            if (userWallets.isEmpty()) {
+                val shouldShowTos = !cardRepository.isTangemTOSAccepted()
+
+                val route = if (shouldShowTos) {
+                    AppRoute.Disclaimer(isTosAccepted = false)
+                } else {
+                    AppRoute.Home(launchMode = launchMode)
+                }
+
+                store.dispatchNavigationAction { replaceAll(route) }
+                intentProcessor.handleIntent(
+                    intent = intentWhichStartedActivity,
+                    isFromForeground = false,
+                    skipNavigationHandlers = false,
+                )
+            } else {
+                if (userWallets.any { it.isLocked }) {
+                    store.dispatchNavigationAction {
+                        replaceAll(
+                            AppRoute.Welcome(
+                                launchMode = launchMode,
+                                intent = intentWhichStartedActivity?.let(::SerializableIntent),
+                            ),
+                        )
+                    }
+                } else {
+                    store.dispatchNavigationAction {
+                        replaceAll(AppRoute.Wallet)
+                    }
+                }
+
+                intentProcessor.handleIntent(
+                    intent = intentWhichStartedActivity,
+                    isFromForeground = false,
+                    skipNavigationHandlers = true,
+                )
+            }
+
+            if (intent != null) {
+                handleDeepLink(intent = intent, isFromOnNewIntent = false)
+            }
+
+            viewModel.checkForUnfinishedBackup()
+        }
+    }
+
    private fun navigateToInitialScreen(intentWhichStartedActivity: Intent?) {
        val launchMode = backgroundScanIntentHandler.getInitScreenLaunchMode(intentWhichStartedActivity)
        if (userWalletsListManager.isLockable && userWalletsListManager.hasUserWallets) {
--- a/app/src/main/java/com/tangem/tap/data/RuntimeUserWalletsStore.kt
+++ b/app/src/main/java/com/tangem/tap/data/RuntimeUserWalletsStore.kt
@ -6,7 +6,6 @@ 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
-import kotlinx.coroutines.flow.firstOrNull

 // FIXME: Workaround, remove it once the normal UserWalletsStore has been implemented
 // [REDACTED_JIRA]
@ -28,10 +27,6 @@ internal class RuntimeUserWalletsStore(
        return requireNotNull(getSyncOrNull(key)) { "Unable to find user wallet with provided ID: $key" }
    }

-    override suspend fun getAllSyncOrNull(): List<UserWallet>? {
-        return userWalletsListManager.userWallets.firstOrNull()
-    }
-
    override suspend fun update(
        userWalletId: UserWalletId,
        update: suspend (UserWallet) -> UserWallet,
--- a/app/src/main/java/com/tangem/tap/data/UserWalletsStoreRepositoryProxy.kt
+++ b/app/src/main/java/com/tangem/tap/data/UserWalletsStoreRepositoryProxy.kt
@ -0,0 +1,50 @@
+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.models.wallet.UserWallet
+import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.core.wallets.UserWalletsListRepository
+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 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
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/di/data/UserWalletsStoreModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/data/UserWalletsStoreModule.kt
@ -2,7 +2,10 @@ package com.tangem.tap.di.data

 import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
+import com.tangem.domain.core.wallets.UserWalletsListRepository
+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
@ -15,7 +18,15 @@ internal object UserWalletsStoreModule {

    @Provides
    @Singleton
-    fun provideUserWalletsStore(userWalletsListManager: UserWalletsListManager): UserWalletsStore {
-        return RuntimeUserWalletsStore(userWalletsListManager = userWalletsListManager)
+    fun provideUserWalletsStore(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): UserWalletsStore {
+        return if (hotWalletFeatureToggles.isHotWalletEnabled) {
+            UserWalletsStoreRepositoryProxy(userWalletsListRepository)
+        } else {
+            RuntimeUserWalletsStore(userWalletsListManager = userWalletsListManager)
+        }
    }
 }
--- a/app/src/main/java/com/tangem/tap/di/domain/CardDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/CardDomainModule.kt
@ -7,11 +7,13 @@ import com.tangem.domain.demo.models.DemoConfig
 import com.tangem.domain.demo.IsDemoCardUseCase
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
+import com.tangem.domain.core.wallets.UserWalletsListRepository
 import com.tangem.domain.wallets.usecase.DerivePublicKeysUseCase
 import com.tangem.domain.wallets.usecase.GetExtendedPublicKeyForCurrencyUseCase
 import com.tangem.domain.wallets.usecase.HasMissedDerivationsUseCase
 import com.tangem.domain.wallets.usecase.IsNeedToBackupUseCase
 import com.tangem.domain.wallets.usecase.NetworkHasDerivationUseCase
+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,9 +44,16 @@ internal object CardDomainModule {
    }

    @Provides
-    @Singleton
-    fun provideIsNeedToBackupUseCase(userWalletsListManager: UserWalletsListManager): IsNeedToBackupUseCase {
-        return IsNeedToBackupUseCase(userWalletsListManager = userWalletsListManager)
+    fun provideIsNeedToBackupUseCase(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): IsNeedToBackupUseCase {
+        return IsNeedToBackupUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }

    @Provides
--- a/app/src/main/java/com/tangem/tap/di/domain/CardLegacyDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/CardLegacyDomainModule.kt
@ -3,7 +3,9 @@ package com.tangem.tap.di.domain
 import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 import com.tangem.domain.card.ScanCardProcessor
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
+import com.tangem.domain.core.wallets.UserWalletsListRepository
 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
@ -31,7 +33,15 @@ internal object CardLegacyDomainModule {

    @Provides
    @Singleton
-    fun providesWalletNameGenerateUseCase(userWalletsListManager: UserWalletsListManager): GenerateWalletNameUseCase {
-        return GenerateWalletNameUseCase(userWalletsListManager)
+    fun providesWalletNameGenerateUseCase(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): GenerateWalletNameUseCase {
+        return GenerateWalletNameUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }
 }
--- a/app/src/main/java/com/tangem/tap/di/domain/MarketsDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/MarketsDomainModule.kt
@ -13,6 +13,8 @@ import com.tangem.domain.staking.StakingIdFactory
 import com.tangem.domain.staking.multi.MultiYieldBalanceFetcher
 import com.tangem.domain.tokens.repository.CurrenciesRepository
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
+import com.tangem.domain.core.wallets.UserWalletsListRepository
+import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@ -81,10 +83,14 @@ object MarketsDomainModule {
    @Singleton
    fun provideFilterNetworksUseCase(
        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
        excludedBlockchains: ExcludedBlockchains,
    ): FilterAvailableNetworksForWalletUseCase {
        return FilterAvailableNetworksForWalletUseCase(
            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
            excludedBlockchains = excludedBlockchains,
        )
    }
--- a/app/src/main/java/com/tangem/tap/di/domain/WalletsDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/WalletsDomainModule.kt
@ -10,11 +10,13 @@ import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.delegate.DefaultUserWalletsSyncDelegate
 import com.tangem.domain.wallets.delegate.UserWalletsSyncDelegate
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
+import com.tangem.domain.core.wallets.UserWalletsListRepository
 import com.tangem.domain.wallets.repository.WalletNamesMigrationRepository
 import com.tangem.domain.wallets.repository.WalletsRepository
 import com.tangem.domain.wallets.usecase.*
 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
@ -31,18 +33,30 @@ 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,
        )
    }

    @Provides
    @Singleton
-    fun providesGetWalletsUseCase(userWalletsListManager: UserWalletsListManager): GetWalletsUseCase {
-        return GetWalletsUseCase(userWalletsListManager = userWalletsListManager)
+    fun providesGetWalletsUseCase(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): GetWalletsUseCase {
+        return GetWalletsUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewListRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }

    @Provides
@ -50,37 +64,71 @@ internal object WalletsDomainModule {
    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): GetUserWalletUseCase {
-        return GetUserWalletUseCase(userWalletsListManager = userWalletsListManager)
+    fun providesGetUserWalletUseCase(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): GetUserWalletUseCase {
+        return GetUserWalletUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewListRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }

    @Provides
    @Singleton
    fun providesGetSelectedWalletSyncUseCase(
        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
    ): GetSelectedWalletSyncUseCase {
-        return GetSelectedWalletSyncUseCase(userWalletsListManager = userWalletsListManager)
+        return GetSelectedWalletSyncUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }

    @Provides
    @Singleton
-    fun providesGetSelectedWalletUseCase(userWalletsListManager: UserWalletsListManager): GetSelectedWalletUseCase {
-        return GetSelectedWalletUseCase(userWalletsListManager = userWalletsListManager)
+    fun providesGetSelectedWalletUseCase(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): GetSelectedWalletUseCase {
+        return GetSelectedWalletUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }

    @Provides
    @Singleton
-    fun providesSaveWalletUseCase(userWalletsListManager: UserWalletsListManager): SaveWalletUseCase {
-        return SaveWalletUseCase(userWalletsListManager = userWalletsListManager)
+    fun providesSaveWalletUseCase(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): SaveWalletUseCase {
+        return SaveWalletUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }

    @Provides
@ -99,15 +147,30 @@ internal object WalletsDomainModule {
    @Singleton
    fun providesSelectWalletUseCase(
        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
        reduxStateHolder: ReduxStateHolder,
    ): SelectWalletUseCase {
-        return SelectWalletUseCase(userWalletsListManager = userWalletsListManager, reduxStateHolder = reduxStateHolder)
+        return SelectWalletUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+            reduxStateHolder = reduxStateHolder,
+        )
    }

    @Provides
    @Singleton
-    fun providesUpdateWalletUseCase(userWalletsListManager: UserWalletsListManager): UpdateWalletUseCase {
-        return UpdateWalletUseCase(userWalletsListManager = userWalletsListManager)
+    fun providesUpdateWalletUseCase(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): UpdateWalletUseCase {
+        return UpdateWalletUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }

    @Provides
@ -124,14 +187,30 @@ internal object WalletsDomainModule {

    @Provides
    @Singleton
-    fun providesGetWalletsSyncUseCase(userWalletsListManager: UserWalletsListManager): GetWalletNamesUseCase {
-        return GetWalletNamesUseCase(userWalletsListManager = userWalletsListManager)
+    fun providesGetWalletsSyncUseCase(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): GetWalletNamesUseCase {
+        return GetWalletNamesUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }

    @Provides
    @Singleton
-    fun providesDeleteWalletUseCase(userWalletsListManager: UserWalletsListManager): DeleteWalletUseCase {
-        return DeleteWalletUseCase(userWalletsListManager = userWalletsListManager)
+    fun providesDeleteWalletUseCase(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): DeleteWalletUseCase {
+        return DeleteWalletUseCase(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }

    @Provides
@ -214,9 +293,13 @@ internal object WalletsDomainModule {
    @Singleton
    fun providesGetSavedWalletChangesIdUseCase(
        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
    ): GetSavedWalletsCountUseCase {
        return GetSavedWalletsCountUseCase(
            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewRepository = hotWalletFeatureToggles.isHotWalletEnabled,
        )
    }

--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt
@ -30,6 +30,7 @@ import com.tangem.tap.domain.userWalletList.utils.toUserWallets
 import com.tangem.tap.domain.userWalletList.utils.updateWith
 import com.tangem.utils.Provider
 import com.tangem.utils.ProviderSuspend
+import com.tangem.utils.extensions.indexOfFirstOrNull
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.update

@ -173,6 +174,8 @@ internal class DefaultUserWalletsListRepository(

        userWalletEncryptionKeysRepository.delete(userWalletIds)

+        val userWalletsBeforeDelete = userWallets.value ?: return@either
+
        userWallets.update { currentWallets ->
            currentWallets?.filterNot { it.walletId in userWalletIds }
        }
@ -181,7 +184,7 @@ internal class DefaultUserWalletsListRepository(
            if (currentSelected == null) return@update null

            userWallets.value?.findAvailableUserWallet(
-                userWallets.value?.indexOfFirst { it.walletId == currentSelected.walletId } ?: 0,
+                userWalletsBeforeDelete.indexOfFirstOrNull { it.walletId == currentSelected.walletId } ?: 0,
            )
        }
    }
@ -199,7 +202,7 @@ internal class DefaultUserWalletsListRepository(

        when (unlockMethod) {
            UserWalletsListRepository.UnlockMethod.Biometric -> {
-                unlockAllWallets()
+                unlockAllWallets().bind()
                select(userWalletId)
            }
            UserWalletsListRepository.UnlockMethod.AccessCode -> {
@ -225,7 +228,7 @@ internal class DefaultUserWalletsListRepository(
                }

                sensitiveInformationRepository.getAll(listOf(encryptionKey))
-                    .doOnSuccess { userWallets.value?.updateWith(it) }
+                    .doOnSuccess { sensitiveInfo -> userWallets.update { it?.updateWith(sensitiveInfo) } }
                    .doOnFailure { error ->
                        raise(UnlockWalletError.UnableToUnlock)
                    }
@ -255,6 +258,7 @@ internal class DefaultUserWalletsListRepository(
    }

    override suspend fun unlockAllWallets(): Either<UnlockWalletError, Unit> = either {
+        val userWalletIds = userWalletsSync().map { it.walletId }.toSet()
        val biometricKeys = runCatching {
            userWalletEncryptionKeysRepository.getAllBiometric()
        }.getOrElse {
@ -264,8 +268,14 @@ internal class DefaultUserWalletsListRepository(

        val unsecuredKeys = userWalletEncryptionKeysRepository.getAllUnsecured()
        val allKeys = biometricKeys + unsecuredKeys
+
+        if (allKeys.all { it.walletId in userWalletIds }.not()) {
+            raise(UnlockWalletError.UnableToUnlock)
+        }
+
        sensitiveInformationRepository.getAll(allKeys)
-            .doOnSuccess { userWallets.value?.updateWith(it) }
+            .doOnSuccess { sensitiveInfo -> userWallets.update { it?.updateWith(sensitiveInfo) } }
+            .doOnFailure { raise(UnlockWalletError.UnableToUnlock) }
    }

    override suspend fun lockAllWallets(): Either<LockWalletsError, Unit> = either {
@ -297,7 +307,7 @@ internal class DefaultUserWalletsListRepository(
        biometryFallback: suspend () -> Either<UnlockWalletError, Unit>,
    ): Either<UnlockWalletError, UserWalletEncryptionKey?> {
        val result = passwordRequester.requestPassword(
-            hasBiometry = tangemSdkManagerProvider.invoke().needEnrollBiometrics,
+            hasBiometry = tangemSdkManagerProvider.invoke().canUseBiometry,
        )

        return when (result) {
@ -312,6 +322,7 @@ internal class DefaultUserWalletsListRepository(
                    requestPasswordRecursive(block, biometryFallback)
                } else {
                    passwordRequester.successfulAuthentication()
+                    passwordRequester.dismiss()
                    decrypted.right()
                }
            }
@ -319,9 +330,9 @@ internal class DefaultUserWalletsListRepository(
                biometryFallback()
                    .onRight {
                        passwordRequester.successfulAuthentication()
+                        passwordRequester.dismiss()
                    }
-                passwordRequester.dismiss()
-                null.right()
+                    .map { null }
            }
        }
    }
--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/UserWalletEncryptionKeysRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/UserWalletEncryptionKeysRepository.kt
@ -62,15 +62,16 @@ internal class UserWalletEncryptionKeysRepository(
        }
    }

-    suspend fun getEncryptedWithPassword(userWalletId: UserWalletId, password: CharArray): UserWalletEncryptionKey? {
-        val encrypted = secureStorage.get(
-            account = StorageKey.UserWalletEncryptionKeyEncrypted(userWalletId).name,
-        ) ?: return null
+    suspend fun getEncryptedWithPassword(userWalletId: UserWalletId, password: CharArray): UserWalletEncryptionKey? =
+        withContext(dispatchers.io) {
+            val encrypted = secureStorage.get(
+                account = StorageKey.UserWalletEncryptionKeyEncrypted(userWalletId).name,
+            ) ?: return@withContext null

-        val decrypted = AESEncryptionProtocol.decryptWithPassword(password, encrypted)
-
-        return decrypted.decodeToKey()
-    }
+            withContext(dispatchers.default) {
+                AESEncryptionProtocol.decryptWithPassword(password, encrypted).decodeToKey()
+            }
+        }

    suspend fun getAllBiometric(): List<UserWalletEncryptionKey> = withContext(dispatchers.io) {
        val keys = getUserWalletsIds().map { userWalletId ->
--- a/app/src/main/java/com/tangem/tap/domain/walletconnect2/di/WalletConnectInteractorModule.kt
+++ b/app/src/main/java/com/tangem/tap/domain/walletconnect2/di/WalletConnectInteractorModule.kt
@ -11,7 +11,7 @@ import com.tangem.domain.walletconnect.WcPairService
 import com.tangem.domain.walletconnect.model.legacy.WalletConnectSessionsRepository
 import com.tangem.domain.walletconnect.usecase.initialize.WcInitializeUseCase
 import com.tangem.domain.walletmanager.WalletManagersFacade
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
+import com.tangem.domain.wallets.usecase.GetSelectedWalletUseCase
 import com.tangem.features.walletconnect.components.WalletConnectFeatureToggles
 import com.tangem.tap.domain.walletconnect.WalletConnectSdkHelper
 import com.tangem.tap.domain.walletconnect2.app.TangemWcBlockchainHelper
@ -42,9 +42,9 @@ internal object WalletConnectInteractorModule {
        wcSessionsRepository: WalletConnectSessionsRepository,
        currenciesRepository: CurrenciesRepository,
        walletManagersFacade: WalletManagersFacade,
-        userWalletsListManager: UserWalletsListManager,
        walletConnectFeatureToggles: WalletConnectFeatureToggles,
        coroutineDispatcherProvider: CoroutineDispatcherProvider,
+        getSelectedWalletUseCase: GetSelectedWalletUseCase,
    ): WalletConnectInteractor {
        return WalletConnectInteractor(
            handler = WalletConnectEventsHandlerImpl(),
@ -54,7 +54,7 @@ internal object WalletConnectInteractorModule {
            blockchainHelper = TangemWcBlockchainHelper(),
            currenciesRepository = currenciesRepository,
            walletManagersFacade = walletManagersFacade,
-            userWalletsListManager = userWalletsListManager,
+            getSelectedWalletUseCase = getSelectedWalletUseCase,
            dispatchers = coroutineDispatcherProvider,
            walletConnectFeatureToggles = walletConnectFeatureToggles,
        )
--- a/app/src/main/java/com/tangem/tap/domain/walletconnect2/domain/WalletConnectInteractor.kt
+++ b/app/src/main/java/com/tangem/tap/domain/walletconnect2/domain/WalletConnectInteractor.kt
@ -13,7 +13,6 @@ import com.tangem.domain.walletconnect.model.legacy.Account
 import com.tangem.domain.walletconnect.model.legacy.Session
 import com.tangem.domain.walletconnect.model.legacy.WalletConnectSessionsRepository
 import com.tangem.domain.walletmanager.WalletManagersFacade
-import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.usecase.GetSelectedWalletUseCase
 import com.tangem.features.walletconnect.components.WalletConnectFeatureToggles
 import com.tangem.tap.common.extensions.dispatchOnMain
@ -38,18 +37,14 @@ class WalletConnectInteractor(
    private val dispatchers: CoroutineDispatcherProvider,
    private val walletManagersFacade: WalletManagersFacade,
    private val currenciesRepository: CurrenciesRepository,
-    private val userWalletsListManager: UserWalletsListManager,
    private val walletConnectFeatureToggles: WalletConnectFeatureToggles,
+    private val getSelectedWalletUseCase: GetSelectedWalletUseCase,
    val blockchainHelper: WcBlockchainHelper,
 ) {
    private val isNewWc by lazy { walletConnectFeatureToggles.isRedesignedWalletConnectEnabled }

    private var isWalletConnectReadyForDeepLinks = false

-    private val getSelectedWalletUseCase by lazy(LazyThreadSafetyMode.NONE) {
-        GetSelectedWalletUseCase(userWalletsListManager)
-    }
-
    private val wcScope = CoroutineScope(
        SupervisorJob() + dispatchers.io + CoroutineExceptionHandler { _, throwable ->
            Timber.e("CoroutineException: from: LISTENER SCOPE, exception: $throwable")
--- a/app/src/main/java/com/tangem/tap/network/auth/DefaultAuthProvider.kt
+++ b/app/src/main/java/com/tangem/tap/network/auth/DefaultAuthProvider.kt
@ -4,11 +4,16 @@ import com.tangem.common.extensions.toHexString
 import com.tangem.datasource.api.common.AuthProvider
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
+import com.tangem.domain.core.wallets.UserWalletsListRepository

-internal class DefaultAuthProvider(private val userWalletsListManager: UserWalletsListManager) : AuthProvider {
+internal class DefaultAuthProvider(
+    private val userWalletsListManager: UserWalletsListManager,
+    private val userWalletsListRepository: UserWalletsListRepository,
+    private val useNewListRepository: Boolean = false,
+) : AuthProvider {

-    override fun getCardPublicKey(): String {
-        val userWallet = userWalletsListManager.selectedUserWalletSync
+    override suspend fun getCardPublicKey(): String {
+        val userWallet = getSelectedWallet()

        if (userWallet !is UserWallet.Cold) {
            return ""
@ -17,8 +22,8 @@ internal class DefaultAuthProvider(private val userWalletsListManager: UserWalle
        return userWallet.scanResponse.card.cardPublicKey.toHexString()
    }

-    override fun getCardId(): String {
-        val userWallet = userWalletsListManager.selectedUserWalletSync
+    override suspend fun getCardId(): String {
+        val userWallet = getSelectedWallet()

        if (userWallet !is UserWallet.Cold) {
            return ""
@ -27,9 +32,25 @@ internal class DefaultAuthProvider(private val userWalletsListManager: UserWalle
        return userWallet.scanResponse.card.cardId
    }

-    override fun getCardsPublicKeys(): Map<String, String> {
-        return userWalletsListManager.userWalletsSync.filterIsInstance<UserWallet.Cold>().associate {
+    override suspend fun getCardsPublicKeys(): Map<String, String> {
+        return getWallets().filterIsInstance<UserWallet.Cold>().associate {
            it.scanResponse.card.cardId to it.scanResponse.card.cardPublicKey.toHexString()
        }
    }
+
+    private suspend fun getWallets(): List<UserWallet> {
+        return if (useNewListRepository) {
+            userWalletsListRepository.userWalletsSync()
+        } else {
+            userWalletsListManager.userWalletsSync
+        }
+    }
+
+    private suspend fun getSelectedWallet(): UserWallet? {
+        return if (useNewListRepository) {
+            userWalletsListRepository.selectedUserWalletSync()
+        } else {
+            userWalletsListManager.selectedUserWalletSync
+        }
+    }
 }
--- a/app/src/main/java/com/tangem/tap/network/auth/di/AuthModule.kt
+++ b/app/src/main/java/com/tangem/tap/network/auth/di/AuthModule.kt
@ -3,6 +3,8 @@ 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.wallets.legacy.UserWalletsListManager
+import com.tangem.domain.core.wallets.UserWalletsListRepository
+import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.lib.auth.ExpressAuthProvider
 import com.tangem.lib.auth.StakeKitAuthProvider
 import com.tangem.tap.network.auth.DefaultAppVersionProvider
@ -22,8 +24,16 @@ internal class AuthModule {

    @Provides
    @Singleton
-    fun provideAuthProvider(userWalletsListManager: UserWalletsListManager): AuthProvider {
-        return DefaultAuthProvider(userWalletsListManager)
+    fun provideAuthProvider(
+        userWalletsListManager: UserWalletsListManager,
+        userWalletsListRepository: UserWalletsListRepository,
+        hotWalletFeatureToggles: HotWalletFeatureToggles,
+    ): AuthProvider {
+        return DefaultAuthProvider(
+            userWalletsListManager = userWalletsListManager,
+            userWalletsListRepository = userWalletsListRepository,
+            useNewListRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+        )
    }

    @Provides