Updated on 2026-08-14

app/build.gradle.kts

@@ -33,13 +33,13 @@ configurations.all {
 
 dependencies {
     implementation(files("libs/walletconnect-1.5.6.aar"))
-    implementation(project(":domain:legacy"))
-    implementation(project(":domain:models"))
-    implementation(project(":domain:core"))
+    implementation(projects.domain.legacy)
+    implementation(projects.domain.models)
+    implementation(projects.domain.core)
     implementation(projects.domain.card)
     implementation(projects.domain.demo)
-    implementation(project(":domain:wallets"))
-    implementation(project(":domain:wallets:models"))
+    implementation(projects.domain.wallets)
+    implementation(projects.domain.wallets.models)
     implementation(projects.domain.settings)
     implementation(projects.domain.tokens)
     implementation(projects.domain.tokens.models)
@@ -48,21 +48,24 @@ dependencies {
     implementation(projects.domain.appCurrency.models)
     implementation(projects.domain.appTheme)
     implementation(projects.domain.appTheme.models)
+    implementation(projects.domain.balanceHiding)
+    implementation(projects.domain.balanceHiding.models)
 
-    implementation(project(":common"))
-    implementation(project(":core:analytics"))
+    implementation(projects.common)
+    implementation(projects.core.analytics)
     implementation(projects.core.analytics.models)
-    implementation(project(":core:navigation"))
-    implementation(project(":core:featuretoggles"))
-    implementation(project(":core:res"))
-    implementation(project(":core:ui"))
-    implementation(project(":core:datasource"))
-    implementation(project(":core:utils"))
-    implementation(project(":libs:crypto"))
-    implementation(project(":libs:auth"))
+    implementation(projects.core.navigation)
+    implementation(projects.core.featuretoggles)
+    implementation(projects.core.res)
+    implementation(projects.core.ui)
+    implementation(projects.core.datasource)
+    implementation(projects.core.utils)
+    implementation(projects.libs.crypto)
+    implementation(projects.libs.auth)
 
     implementation(projects.data.appCurrency)
     implementation(projects.data.appTheme)
+    implementation(projects.data.balanceHiding)
     implementation(projects.data.card)
     implementation(projects.data.common)
     implementation(projects.data.settings)
@@ -72,22 +75,23 @@ dependencies {
     implementation(projects.data.wallets)
 
     /** Features */
-    implementation(project(":features:onboarding"))
-    implementation(project(":features:learn2earn:api"))
-    implementation(project(":features:learn2earn:impl"))
-    implementation(project(":features:referral:presentation"))
-    implementation(project(":features:referral:domain"))
-    implementation(project(":features:referral:data"))
-    implementation(project(":features:swap:api"))
-    implementation(project(":features:swap:presentation"))
-    implementation(project(":features:swap:domain"))
-    implementation(project(":features:swap:data"))
-    implementation(project(":features:tester:api"))
-    implementation(project(":features:tester:impl"))
-    implementation(project(":features:wallet:api"))
-    implementation(project(":features:wallet:impl"))
+    implementation(projects.features.onboarding)
+    implementation(projects.features.learn2earn.api)
+    implementation(projects.features.learn2earn.impl)
+    implementation(projects.features.referral.presentation)
+    implementation(projects.features.referral.domain)
+    implementation(projects.features.referral.data)
+    implementation(projects.features.swap.api)
+    implementation(projects.features.swap.presentation)
+    implementation(projects.features.swap.domain)
+    implementation(projects.features.swap.data)
+    implementation(projects.features.tester.api)
+    implementation(projects.features.tester.impl)
+    implementation(projects.features.wallet.api)
+    implementation(projects.features.wallet.impl)
     implementation(projects.features.tokendetails.api)
     implementation(projects.features.tokendetails.impl)
+    implementation(projects.features.send.api)
 
     /** AndroidX libraries */
     implementation(deps.androidx.core.ktx)
@@ -106,6 +110,7 @@ dependencies {
     /** Compose libraries */
     implementation(deps.compose.constraintLayout)
     implementation(deps.compose.material)
+    implementation(deps.compose.material3)
     implementation(deps.compose.animation)
     implementation(deps.compose.coil)
     implementation(deps.compose.constraintLayout)

app/src/main/assets/testnet_tokens.json

@@ -517,6 +517,17 @@
                     "networkId": "aleph-zero/test"
                 }
             ]
+        },
+        {
+            "id": "near",
+            "symbol": "NEAR",
+            "name": "NEAR",
+            "networks":
+            [
+                {
+                    "networkId": "near-protocol/test"
+                }
+            ]
         }
     ]
 }

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

@@ -1,12 +0,0 @@
-package com.tangem.tap
-
-import com.tangem.domain.apptheme.model.AppThemeMode
-
-internal sealed class GlobalSettingsState {
-
-    object Loading : GlobalSettingsState()
-
-    data class Content(
-        val appThemeMode: AppThemeMode,
-    ) : GlobalSettingsState()
-}

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

@@ -1,19 +1,26 @@
 package com.tangem.tap
 
+import android.annotation.SuppressLint
 import android.content.Intent
 import android.content.pm.ActivityInfo
+import android.content.res.Configuration
 import android.os.Bundle
 import android.view.View
-import androidx.activity.viewModels
 import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.appcompat.app.AppCompatDelegate.setDefaultNightMode
+import androidx.core.os.bundleOf
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.WindowCompat
+import androidx.lifecycle.flowWithLifecycle
 import androidx.lifecycle.lifecycleScope
+import arrow.core.getOrElse
 import by.kirich1409.viewbindingdelegate.viewBinding
 import com.google.android.material.snackbar.Snackbar
 import com.tangem.core.navigation.AppScreen
 import com.tangem.core.navigation.NavigationAction
 import com.tangem.data.card.sdk.CardSdkLifecycleObserver
+import com.tangem.domain.apptheme.model.AppThemeMode
 import com.tangem.domain.card.ScanCardUseCase
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
@@ -27,15 +34,11 @@ import com.tangem.tap.common.DialogManager
 import com.tangem.tap.common.OnActivityResultCallback
 import com.tangem.tap.common.SnackbarHandler
 import com.tangem.tap.common.apptheme.MutableAppThemeModeHolder
-import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.redux.NotificationsHandler
-import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.common.shop.googlepay.GooglePayService
 import com.tangem.tap.common.shop.googlepay.GooglePayService.Companion.LOAD_PAYMENT_DATA_REQUEST_CODE
 import com.tangem.tap.common.shop.googlepay.GooglePayUtil.createPaymentsClient
 import com.tangem.tap.domain.TangemSdkManager
-import com.tangem.tap.domain.userWalletList.di.provideBiometricImplementation
-import com.tangem.tap.domain.userWalletList.di.provideRuntimeImplementation
 import com.tangem.tap.domain.walletconnect2.domain.WalletConnectInteractor
 import com.tangem.tap.features.intentHandler.IntentProcessor
 import com.tangem.tap.features.intentHandler.handlers.BackgroundScanIntentHandler
@@ -44,19 +47,15 @@ import com.tangem.tap.features.intentHandler.handlers.SellCurrencyIntentHandler
 import com.tangem.tap.features.intentHandler.handlers.WalletConnectLinkIntentHandler
 import com.tangem.tap.features.onboarding.products.wallet.redux.BackupAction
 import com.tangem.tap.features.shop.redux.ShopAction
-import com.tangem.tap.features.welcome.redux.WelcomeAction
+import com.tangem.tap.features.welcome.ui.WelcomeFragment
 import com.tangem.tap.proxy.AppStateHolder
 import com.tangem.tap.proxy.redux.DaggerGraphAction
 import com.tangem.utils.coroutines.FeatureCoroutineExceptionHandler
 import com.tangem.wallet.R
 import com.tangem.wallet.databinding.ActivityMainBinding
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
 import java.lang.ref.WeakReference
 import javax.inject.Inject
 import kotlin.coroutines.CoroutineContext
@@ -112,8 +111,7 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
     @Inject
     lateinit var walletConnectInteractor: WalletConnectInteractor
 
-    private val viewModel: MainViewModel by viewModels()
-    private var isInitializing: Boolean = true
+    private lateinit var appThemeModeFlow: SharedFlow<AppThemeMode?>
 
     // TODO: fixme: inject through DI
     private val intentProcessor: IntentProcessor = IntentProcessor()
@@ -125,34 +123,31 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
     private val onActivityResultCallbacks = mutableListOf<OnActivityResultCallback>()
 
     override fun onCreate(savedInstanceState: Bundle?) {
-        val splashScreen = installSplashScreen()
+        installSplashScreen()
+        installAppTheme() // We need to call it before onCreate to prevent unnecessary activity recreation
 
         super.onCreate(savedInstanceState)
 
-        cardSdkLifecycleObserver.onCreate(context = this)
-
-        bootstrapMainStateUpdates()
-
-        splashScreen.setKeepOnScreenCondition { isInitializing }
+        installActivityDependencies()
+        observeAppThemeModeUpdates()
 
         setContentView(R.layout.activity_main)
-        systemActions()
+        initContent()
 
+        checkGooglePayAvailability()
+    }
+
+    private fun installActivityDependencies() {
         store.dispatch(NavigationAction.ActivityCreated(WeakReference(this)))
 
+        cardSdkLifecycleObserver.onCreate(context = this)
         tangemSdkManager = injectedTangemSdkManager
         appStateHolder.tangemSdkManager = tangemSdkManager
         backupService = BackupService.init(cardSdkConfigRepository.sdk, this)
         lockUserWalletsTimer = LockUserWalletsTimer(owner = this)
 
-        initUserWalletsListManager()
         initIntentHandlers()
 
-        store.dispatch(
-            ShopAction.CheckIfGooglePayAvailable(
-                GooglePayService(createPaymentsClient(this), this),
-            ),
-        )
         store.dispatch(
             DaggerGraphAction.SetActivityDependencies(
                 testerRouter = testerRouter,
@@ -165,6 +160,59 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
         )
     }
 
+    private fun installAppTheme() {
+        appThemeModeFlow = createAppThemeModeFlow()
+        val mode = runBlocking { appThemeModeFlow.filterNotNull().first() }
+
+        updateAppTheme(mode)
+    }
+
+    private fun observeAppThemeModeUpdates() {
+        appThemeModeFlow
+            .filterNotNull()
+            .flowWithLifecycle(lifecycle)
+            .onEach(::updateAppTheme)
+            .launchIn(lifecycleScope)
+    }
+
+    @SuppressLint("SourceLockedOrientationActivity")
+    private fun initContent() {
+        WindowCompat.setDecorFitsSystemWindows(window, false)
+
+        supportFragmentManager.registerFragmentLifecycleCallbacks(
+            NavBarInsetsFragmentLifecycleCallback(),
+            true,
+        )
+
+        requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+    }
+
+    private fun checkGooglePayAvailability() {
+        store.dispatch(
+            ShopAction.CheckIfGooglePayAvailable(
+                GooglePayService(createPaymentsClient(this), this),
+            ),
+        )
+    }
+
+    private fun createAppThemeModeFlow(): SharedFlow<AppThemeMode?> {
+        val tapApplication = application as TapApplication
+        val featureToggle = tapApplication.darkThemeFeatureToggle
+
+        return if (featureToggle.isDarkThemeEnabled) {
+            tapApplication.getAppThemeModeUseCase()
+                .map { maybeMode ->
+                    maybeMode.getOrElse { AppThemeMode.DEFAULT }
+                }
+                .shareIn(
+                    scope = lifecycleScope + Dispatchers.IO,
+                    started = SharingStarted.WhileSubscribed(stopTimeoutMillis = 5_000),
+                )
+        } else {
+            MutableStateFlow(AppThemeMode.FORCE_LIGHT)
+        }
+    }
+
     override fun onStart() {
         super.onStart()
         dialogManager.onStart(this)
@@ -175,7 +223,7 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
         // TODO: RESEARCH! NotificationsHandler is created in onResume and destroyed in onStop
         notificationsHandler = NotificationsHandler(binding.fragmentContainer)
 
-        navigateToInitialScreenIfNeededOnResume(intent)
+        navigateToInitialScreenIfNeeded(intent)
     }
 
     override fun onStop() {
@@ -193,53 +241,33 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
 
     private fun initIntentHandlers() {
         val hasSavedWalletsProvider = { store.state.globalState.userWalletsListManager?.hasUserWallets == true }
-        intentProcessor.addHandler(
-            BackgroundScanIntentHandler(
-                hasSavedWalletsProvider,
-                lifecycleScope,
-            ),
-        )
+        intentProcessor.addHandler(BackgroundScanIntentHandler(hasSavedWalletsProvider, lifecycleScope))
         intentProcessor.addHandler(WalletConnectLinkIntentHandler())
         intentProcessor.addHandler(BuyCurrencyIntentHandler())
         intentProcessor.addHandler(SellCurrencyIntentHandler())
     }
 
-    private fun initUserWalletsListManager() {
-        val manager = if (preferencesStorage.shouldSaveUserWallets) {
-            UserWalletsListManager.provideBiometricImplementation(
-                context = applicationContext,
-                tangemSdkManager = tangemSdkManager,
-            )
-        } else {
-            UserWalletsListManager.provideRuntimeImplementation()
+    private fun updateAppTheme(appThemeMode: AppThemeMode) {
+        MutableAppThemeModeHolder.value = appThemeMode
+        MutableAppThemeModeHolder.isDarkThemeActive = isDarkTheme()
+
+        val mode = when (appThemeMode) {
+            AppThemeMode.FORCE_DARK -> AppCompatDelegate.MODE_NIGHT_YES
+            AppThemeMode.FORCE_LIGHT -> AppCompatDelegate.MODE_NIGHT_NO
+            AppThemeMode.FOLLOW_SYSTEM -> AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
         }
-        store.dispatch(GlobalAction.UpdateUserWalletsListManager(manager))
+
+        setDefaultNightMode(mode)
+        delegate.localNightMode = mode
     }
 
-    private fun bootstrapMainStateUpdates() {
-        viewModel.state
-            .onEach { state ->
-                isInitializing = state is GlobalSettingsState.Loading
-
-                when (state) {
-                    is GlobalSettingsState.Content -> {
-                        MutableAppThemeModeHolder.value = state.appThemeMode
-                    }
-                    is GlobalSettingsState.Loading -> Unit
-                }
-            }
-            .launchIn(lifecycleScope)
-    }
-
-    private fun systemActions() {
-        WindowCompat.setDecorFitsSystemWindows(window, false)
-
-        supportFragmentManager.registerFragmentLifecycleCallbacks(
-            NavBarInsetsFragmentLifecycleCallback(),
-            true,
-        )
-
-        requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+    private fun isDarkTheme(): Boolean {
+        return when (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) {
+            Configuration.UI_MODE_NIGHT_YES -> true
+            Configuration.UI_MODE_NIGHT_NO -> false
+            Configuration.UI_MODE_NIGHT_UNDEFINED -> false
+            else -> false
+        }
     }
 
     override fun onNewIntent(intent: Intent?) {
@@ -303,43 +331,40 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
         lockUserWalletsTimer?.restart()
     }
 
-    private fun navigateToInitialScreenIfNeededOnResume(intentWhichStartedActivity: Intent?) {
+    private fun navigateToInitialScreenIfNeeded(intentWhichStartedActivity: Intent?) {
         val backStackIsEmpty = supportFragmentManager.backStackEntryCount == 0
         val isNotScannedBefore = store.state.globalState.scanResponse == null
         val isOnboardingServiceNotActive = store.state.globalState.onboardingState.onboardingStarted
         val isShopNotOpened = store.state.shopState.total != null
+
         when {
             !backStackIsEmpty && isNotScannedBefore && isOnboardingServiceNotActive && isShopNotOpened -> {
-                navigateToInitialScreenOnResume(intentWhichStartedActivity)
+                navigateToInitialScreen(intentWhichStartedActivity)
             }
             backStackIsEmpty -> {
-                navigateToInitialScreenOnResume(intentWhichStartedActivity)
+                navigateToInitialScreen(intentWhichStartedActivity)
             }
             else -> Unit
         }
     }
 
-    private fun navigateToInitialScreenOnResume(intentWhichStartedActivity: Intent?) {
+    private fun navigateToInitialScreen(intentWhichStartedActivity: Intent?) {
         if (store.state.globalState.userWalletsListManager?.hasUserWallets == true) {
-            store.dispatchOnMain(NavigationAction.NavigateTo(AppScreen.Welcome))
-            store.dispatchOnMain(WelcomeAction.SetInitialIntent(intentWhichStartedActivity))
-            lifecycleScope.launch {
-                val handler = BackgroundScanIntentHandler(
-                    hasSavedUserWalletsProvider = { true },
-                    lifecycleCoroutineScope = lifecycleScope,
-                )
-                val isBackgroundScanHandled = handler.handleIntent(intentWhichStartedActivity)
-                val hasNotIncompletedBackup = !backupService.hasIncompletedBackup
-                if (!isBackgroundScanHandled && hasNotIncompletedBackup) {
-                    store.dispatchOnMain(WelcomeAction.ProceedWithBiometrics)
-                }
-            }
+            store.dispatch(
+                NavigationAction.NavigateTo(
+                    screen = AppScreen.Welcome,
+                    bundle = intentWhichStartedActivity?.let {
+                        bundleOf(WelcomeFragment.INITIAL_INTENT_KEY to it)
+                    },
+                ),
+            )
         } else {
-            store.dispatchOnMain(NavigationAction.NavigateTo(AppScreen.Home))
+            store.dispatch(NavigationAction.NavigateTo(AppScreen.Home))
             lifecycleScope.launch {
                 intentProcessor.handleIntent(intentWhichStartedActivity)
             }
         }
+
         store.dispatch(BackupAction.CheckForUnfinishedBackup)
     }
 }

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

@@ -1,35 +0,0 @@
-package com.tangem.tap
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import arrow.core.getOrElse
-import com.tangem.domain.apptheme.GetAppThemeModeUseCase
-import com.tangem.domain.apptheme.model.AppThemeMode
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import javax.inject.Inject
-
-@HiltViewModel
-internal class MainViewModel @Inject constructor(
-    private val getAppThemeModeUseCase: GetAppThemeModeUseCase,
-) : ViewModel() {
-
-    val state: StateFlow<GlobalSettingsState> = createMainStateFlow()
-
-    private fun createMainStateFlow(): StateFlow<GlobalSettingsState> {
-        return getAppThemeModeUseCase()
-            .map { maybeMode ->
-                val mode = maybeMode.getOrElse { AppThemeMode.DEFAULT }
-
-                GlobalSettingsState.Content(appThemeMode = mode)
-            }
-            .stateIn(
-                scope = viewModelScope,
-                started = SharingStarted.WhileSubscribed(stopTimeoutMillis = 5_000),
-                initialValue = GlobalSettingsState.Loading,
-            )
-    }
-}

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

@@ -22,13 +22,20 @@ import com.tangem.datasource.config.ConfigManager
 import com.tangem.datasource.config.FeaturesLocalLoader
 import com.tangem.datasource.config.models.Config
 import com.tangem.datasource.connection.NetworkConnectionManager
-import com.tangem.domain.DomainLayer
+import com.tangem.datasource.local.token.UserTokensStore
 import com.tangem.domain.appcurrency.repository.AppCurrencyRepository
+import com.tangem.domain.apptheme.GetAppThemeModeUseCase
+import com.tangem.domain.apptheme.repository.AppThemeModeRepository
+import com.tangem.domain.balancehiding.repositories.BalanceHidingRepository
 import com.tangem.domain.card.ScanCardProcessor
 import com.tangem.domain.common.LogConfig
+import com.tangem.domain.settings.repositories.AppRatingRepository
+import com.tangem.domain.tokens.repository.CurrenciesRepository
+import com.tangem.domain.tokens.repository.NetworksRepository
 import com.tangem.domain.walletmanager.WalletManagersFacade
+import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.legacy.WalletManagersRepository
-import com.tangem.features.tokendetails.featuretoggles.TokenDetailsFeatureToggles
+import com.tangem.domain.wallets.repository.WalletsRepository
 import com.tangem.features.wallet.featuretoggles.WalletFeatureToggles
 import com.tangem.tap.common.analytics.AnalyticsFactory
 import com.tangem.tap.common.analytics.api.AnalyticsHandlerBuilder
@@ -48,9 +55,13 @@ import com.tangem.tap.common.redux.appReducer
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.common.shop.TangemShopService
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessagesManager
+import com.tangem.tap.domain.tasks.product.DerivationsFinder
 import com.tangem.tap.domain.tokens.UserTokensRepository
+import com.tangem.tap.domain.tokens.UserTokensStorageService
 import com.tangem.tap.domain.totalBalance.TotalFiatBalanceCalculator
 import com.tangem.tap.domain.totalBalance.di.provideDefaultImplementation
+import com.tangem.tap.domain.userWalletList.di.provideBiometricImplementation
+import com.tangem.tap.domain.userWalletList.di.provideRuntimeImplementation
 import com.tangem.tap.domain.walletCurrencies.WalletCurrenciesManager
 import com.tangem.tap.domain.walletCurrencies.di.provideDefaultImplementation
 import com.tangem.tap.domain.walletStores.WalletStoresManager
@@ -61,8 +72,11 @@ import com.tangem.tap.domain.walletStores.repository.di.provideDefaultImplementa
 import com.tangem.tap.domain.walletconnect.WalletConnectRepository
 import com.tangem.tap.domain.walletconnect2.domain.WalletConnectSessionsRepository
 import com.tangem.tap.features.customtoken.api.featuretoggles.CustomTokenFeatureToggles
+import com.tangem.tap.features.details.DarkThemeFeatureToggle
+import com.tangem.tap.features.details.featuretoggles.DetailsFeatureToggles
 import com.tangem.tap.proxy.AppStateHolder
 import com.tangem.tap.proxy.redux.DaggerGraphState
+import com.tangem.utils.coroutines.AppCoroutineDispatcherProvider
 import com.tangem.wallet.BuildConfig
 import dagger.hilt.android.HiltAndroidApp
 import kotlinx.coroutines.runBlocking
@@ -78,7 +92,8 @@ lateinit var activityResultCaller: ActivityResultCaller
 lateinit var preferencesStorage: PreferencesDataSource
 lateinit var walletConnectRepository: WalletConnectRepository
 lateinit var shopService: TangemShopService
-lateinit var userTokensRepository: UserTokensRepository
+internal lateinit var userTokensRepository: UserTokensRepository
+internal lateinit var derivationsFinder: DerivationsFinder
 
 private val walletStoresRepository by lazy { WalletStoresRepository.provideDefaultImplementation() }
 private val walletManagersRepository by lazy {
@@ -119,8 +134,9 @@ val totalFiatBalanceCalculator by lazy {
 }
 
 @HiltAndroidApp
-class TapApplication : Application(), ImageLoaderFactory {
+internal class TapApplication : Application(), ImageLoaderFactory {
 
+    // region Injected
     @Inject
     lateinit var appStateHolder: AppStateHolder
 
@@ -154,9 +170,6 @@ class TapApplication : Application(), ImageLoaderFactory {
     // @Inject
     // lateinit var learn2earnInteractor: Learn2earnInteractor
 
-    @Inject
-    lateinit var tokenDetailsFeatureToggles: TokenDetailsFeatureToggles
-
     @Inject
     lateinit var scanCardProcessor: ScanCardProcessor
 
@@ -169,29 +182,41 @@ class TapApplication : Application(), ImageLoaderFactory {
     @Inject
     lateinit var walletManagersFacade: WalletManagersFacade
 
+    @Inject
+    lateinit var networksRepository: NetworksRepository
+
+    @Inject
+    lateinit var currenciesRepository: CurrenciesRepository
+
+    @Inject
+    lateinit var appThemeModeRepository: AppThemeModeRepository
+
+    @Inject
+    lateinit var balanceHidingRepository: BalanceHidingRepository
+
+    @Inject
+    lateinit var detailsFeatureToggles: DetailsFeatureToggles
+
+    @Inject
+    lateinit var darkThemeFeatureToggle: DarkThemeFeatureToggle
+
+    @Inject
+    lateinit var userTokensStore: UserTokensStore
+
+    @Inject
+    lateinit var appRatingRepository: AppRatingRepository
+
+    @Inject
+    lateinit var getAppThemeModeUseCase: GetAppThemeModeUseCase
+
+    @Inject
+    lateinit var walletsRepository: WalletsRepository
+    // endregion Injected
+
     override fun onCreate() {
         super.onCreate()
 
-        store = Store(
-            reducer = { action, state ->
-                appReducer(action, state, appStateHolder)
-            },
-            middleware = AppState.getMiddleware(),
-            state = AppState(
-                daggerGraphState = DaggerGraphState(
-                    assetReader = assetReader,
-                    networkConnectionManager = networkConnectionManager,
-                    customTokenFeatureToggles = customTokenFeatureToggles,
-                    walletFeatureToggles = walletFeatureToggles,
-                    walletConnectRepository = walletConnect2Repository,
-                    walletConnectSessionsRepository = walletConnectSessionsRepository,
-                    tokenDetailsFeatureToggles = tokenDetailsFeatureToggles,
-                    scanCardProcessor = scanCardProcessor,
-                    appCurrencyRepository = appCurrencyRepository,
-                    walletManagersFacade = walletManagersFacade,
-                ),
-            ),
-        )
+        store = createReduxStore()
 
         if (BuildConfig.DEBUG) {
             Logger.addLogAdapter(AndroidLogAdapter(TimberFormatStrategy()))
@@ -208,10 +233,19 @@ class TapApplication : Application(), ImageLoaderFactory {
         activityResultCaller = foregroundActivityObserver
         registerActivityLifecycleCallbacks(foregroundActivityObserver.callbacks)
 
-        DomainLayer.init()
         preferencesStorage = preferencesDataSource
         walletConnectRepository = WalletConnectRepository(this)
 
+        // TODO: Try to performance and user experience.
+        //  [REDACTED_JIRA]
+        runBlocking {
+            walletsRepository.initialize()
+            initUserWalletsListManager()
+            featureTogglesManager.init()
+            appRatingRepository.initialize()
+            // learn2earnInteractor.init()
+        }
+
         val configLoader = FeaturesLocalLoader(assetReader, MoshiConverter.sdkMoshi, BuildConfig.ENVIRONMENT)
         initConfigManager(configLoader, ::initWithConfigDependency)
         initWarningMessagesManager()
@@ -224,26 +258,53 @@ class TapApplication : Application(), ImageLoaderFactory {
             )
         }
 
+        val userTokensStorageService = UserTokensStorageService.init(context = this)
         userTokensRepository = UserTokensRepository.init(
-            context = this,
             tangemTechService = store.state.domainNetworks.tangemTechService,
             networkConnectionManager = networkConnectionManager,
+            storageService = userTokensStorageService,
+        )
+        derivationsFinder = DerivationsFinder(
+            legacyTokensStore = userTokensStorageService,
+            newTokensStore = userTokensStore,
+            walletFeatureToggles = walletFeatureToggles,
+            dispatchers = AppCoroutineDispatcherProvider(),
         )
         appStateHolder.mainStore = store
         appStateHolder.userTokensRepository = userTokensRepository
         appStateHolder.walletStoresManager = walletStoresManager
 
-        // TODO: Try to performance and user experience.
-        //  [REDACTED_JIRA]
-        runBlocking {
-            featureTogglesManager.init()
-            // learn2earnInteractor.init()
-        }
-
         initTopUpController()
         walletConnect2Repository.init(projectId = configManager.config.walletConnectProjectId)
     }
 
+    private fun createReduxStore(): Store<AppState> {
+        return Store(
+            reducer = { action, state -> appReducer(action, state, appStateHolder) },
+            middleware = AppState.getMiddleware(),
+            state = AppState(
+                daggerGraphState = DaggerGraphState(
+                    assetReader = assetReader,
+                    networkConnectionManager = networkConnectionManager,
+                    customTokenFeatureToggles = customTokenFeatureToggles,
+                    walletFeatureToggles = walletFeatureToggles,
+                    walletConnectRepository = walletConnect2Repository,
+                    walletConnectSessionsRepository = walletConnectSessionsRepository,
+                    scanCardProcessor = scanCardProcessor,
+                    appCurrencyRepository = appCurrencyRepository,
+                    walletManagersFacade = walletManagersFacade,
+                    appStateHolder = appStateHolder,
+                    networksRepository = networksRepository,
+                    currenciesRepository = currenciesRepository,
+                    appThemeModeRepository = appThemeModeRepository,
+                    balanceHidingRepository = balanceHidingRepository,
+                    detailsFeatureToggles = detailsFeatureToggles,
+                    walletsRepository = walletsRepository,
+                ),
+            ),
+        )
+    }
+
     private fun initTopUpController() {
         val topUpController = TopUpController(
             scanResponseProvider = {
@@ -303,14 +364,16 @@ class TapApplication : Application(), ImageLoaderFactory {
         foregroundActivityObserver: ForegroundActivityObserver,
         store: Store<AppState>,
     ) {
-        fun initAdditionalFeedbackInfo(context: Context): AdditionalFeedbackInfo = AdditionalFeedbackInfo().apply {
-            appVersion = try {
-                // TODO don't use deprecated method
-                val pInfo = context.packageManager.getPackageInfo(context.packageName, 0)
-                pInfo.versionName
-            } catch (e: PackageManager.NameNotFoundException) {
-                e.printStackTrace()
-                "x.y.z"
+        fun initAdditionalFeedbackInfo(context: Context): AdditionalFeedbackInfo {
+            return AdditionalFeedbackInfo().apply {
+                appVersion = try {
+                    // TODO don't use deprecated method
+                    val pInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+                    pInfo.versionName
+                } catch (e: PackageManager.NameNotFoundException) {
+                    e.printStackTrace()
+                    "x.y.z"
+                }
             }
         }
 
@@ -344,4 +407,14 @@ class TapApplication : Application(), ImageLoaderFactory {
     private fun initWarningMessagesManager() {
         store.dispatch(GlobalAction.SetWarningManager(WarningMessagesManager()))
     }
+
+    private suspend fun initUserWalletsListManager() {
+        val manager = if (walletsRepository.shouldSaveUserWalletsSync()) {
+            UserWalletsListManager.provideBiometricImplementation(applicationContext)
+        } else {
+            UserWalletsListManager.provideRuntimeImplementation()
+        }
+
+        store.dispatch(GlobalAction.UpdateUserWalletsListManager(manager))
+    }
 }

app/src/main/java/com/tangem/tap/common/CompositionCounter.kt

@@ -1,40 +0,0 @@
-package com.tangem.tap.common
-
-import timber.log.Timber
-
-class CompositionCounter(
-    val id: String,
-    count: Int = 0,
-) {
-    var count: Int = count
-        private set
-
-    fun increase(id: String): CompositionCounter {
-        if (this.id != id) return this
-
-        count += 1
-        return CompositionCounter(id, count)
-    }
-}
-
-class CompositionLogger(
-    private val recomposeViewId: String,
-    private val tag: String = recomposeViewId,
-    private var turnOnForIds: List<String> = listOf(recomposeViewId),
-) {
-    val count: Int
-        get() = compositionCounter.count
-
-    private var compositionCounter: CompositionCounter = CompositionCounter(recomposeViewId)
-
-    fun nextComposition() {
-        compositionCounter = compositionCounter.increase(recomposeViewId)
-        log("")
-    }
-
-    fun log(message: String) {
-        if (!turnOnForIds.contains(recomposeViewId)) return
-
-        Timber.d("$tag[$recomposeViewId]:[${compositionCounter.count}]: $message")
-    }
-}

app/src/main/java/com/tangem/tap/common/CustomTabsManager.kt

@@ -4,6 +4,9 @@ import android.content.Context
 import android.net.Uri
 import androidx.browser.customtabs.CustomTabColorSchemeParams
 import androidx.browser.customtabs.CustomTabsIntent
+import androidx.browser.customtabs.CustomTabsIntent.COLOR_SCHEME_DARK
+import androidx.browser.customtabs.CustomTabsIntent.COLOR_SCHEME_LIGHT
+import com.tangem.tap.common.apptheme.MutableAppThemeModeHolder
 import com.tangem.tap.common.extensions.getColorCompat
 import com.tangem.wallet.R
 
@@ -15,6 +18,9 @@ class CustomTabsManager {
                     .setNavigationBarColor(context.getColorCompat(R.color.toolbarColor))
                     .build(),
             )
+            .setColorScheme(
+                if (MutableAppThemeModeHolder.isDarkThemeActive) COLOR_SCHEME_DARK else COLOR_SCHEME_LIGHT,
+            )
             .build()
         customTabsIntent.launchUrl(context, Uri.parse(url))
     }

app/src/main/java/com/tangem/tap/common/DialogManager.kt

@@ -2,6 +2,7 @@ package com.tangem.tap.common
 
 import android.app.Dialog
 import android.content.Context
+import com.tangem.core.navigation.StateDialog
 import com.tangem.tap.common.redux.AppDialog
 import com.tangem.tap.common.redux.global.GlobalState
 import com.tangem.tap.common.ui.SimpleAlertDialog
@@ -53,7 +54,7 @@ class DialogManager : StoreSubscriber<GlobalState> {
             is AppDialog.SimpleOkDialogRes -> SimpleOkDialog.create(state.dialog, context)
             is AppDialog.SimpleOkErrorDialog -> SimpleOkDialog.create(state.dialog, context)
             is AppDialog.SimpleOkWarningDialog -> SimpleOkDialog.create(state.dialog, context)
-            is AppDialog.ScanFailsDialog -> ScanFailsDialog.create(context)
+            is StateDialog.ScanFailsDialog -> ScanFailsDialog.create(context)
             is AppDialog.AddressInfoDialog -> AddressInfoBottomSheetDialog(state.dialog, context)
             is AppDialog.TestActionsDialog -> TestActionsBottomSheetDialog(state.dialog, context)
             is OnboardingDialog.TwinningProcessNotCompleted -> TwinningProcessNotCompletedDialog.create(context)
@@ -105,7 +106,7 @@ class DialogManager : StoreSubscriber<GlobalState> {
                     context.getString(R.string.wallet_connect_scanner_error_unsupported_network)
                 } else {
                     context.getString(R.string.wallet_connect_error_unsupported_blockchains) +
-                        state.dialog.networks
+                        state.dialog.networks.joinToString()
                 }
                 SimpleAlertDialog.create(
                     titleRes = R.string.wallet_connect_title,

app/src/main/java/com/tangem/tap/common/analytics/DefaultChangeCardAnalyticsContextUseCase.kt

@@ -0,0 +1,13 @@
+package com.tangem.tap.common.analytics
+
+import com.tangem.core.analytics.Analytics
+import com.tangem.domain.analytics.ChangeCardAnalyticsContextUseCase
+import com.tangem.domain.models.scan.ScanResponse
+import com.tangem.tap.common.extensions.setContext
+
+internal class DefaultChangeCardAnalyticsContextUseCase : ChangeCardAnalyticsContextUseCase {
+
+    override fun invoke(scanResponse: ScanResponse) {
+        Analytics.setContext(scanResponse)
+    }
+}

app/src/main/java/com/tangem/tap/common/analytics/events/AnalyticsParam.kt

@@ -8,10 +8,7 @@ sealed class AnalyticsParam {
         class Currency(currency: com.tangem.tap.features.wallet.models.Currency) : CurrencyType(currency.currencySymbol)
         class Blockchain(blockchain: com.tangem.blockchain.common.Blockchain) : CurrencyType(blockchain.currency)
         class Token(token: com.tangem.blockchain.common.Token) : CurrencyType(token.symbol)
-        class FiatCurrency(
-            fiatCurrency: com.tangem.tap.common.entities.FiatCurrency,
-        ) : CurrencyType(fiatCurrency.code)
-
+        class FiatCurrency(fiatCurrency: com.tangem.tap.common.entities.FiatCurrency) : CurrencyType(fiatCurrency.code)
         class Amount(amount: com.tangem.blockchain.common.Amount) : CurrencyType(amount.currencySymbol)
     }
 
@@ -136,9 +133,9 @@ sealed class AnalyticsParam {
     }
 
     sealed class WalletCreationType(val value: String) {
-        object PrivateKey : WalletCreationType("Private key")
-        object NewSeed : WalletCreationType("New seed")
-        object SeedImport : WalletCreationType("Seed import")
+        object PrivateKey : WalletCreationType(value = "Private Key")
+        object NewSeed : WalletCreationType(value = "New Seed")
+        object SeedImport : WalletCreationType(value = "Seed Import")
     }
 
     companion object Key {
@@ -155,7 +152,8 @@ sealed class AnalyticsParam {
         const val ERROR_DESCRIPTION = "Error Description"
         const val ERROR_CODE = "Error Code"
         const val ERROR_KEY = "Error Key"
-        const val CREATION_TYPE = "Creation type"
+        const val CREATION_TYPE = "Creation Type"
+        const val SEED_PHRASE_LENGTH = "Seed Phrase Length"
         const val DAPP_NAME = "DApp Name"
         const val DAPP_URL = "DApp Url"
         const val METHOD_NAME = "Method Name"

app/src/main/java/com/tangem/tap/common/analytics/events/Basic.kt

@@ -32,14 +32,18 @@ sealed class Basic(
         batch: String,
         signInType: SignInType,
         walletsCount: String,
+        hasBackup: Boolean?,
     ) : Basic(
         event = "Signed in",
-        params = mapOf(
-            AnalyticsParam.CURRENCY to currency.value,
-            AnalyticsParam.BATCH to batch,
-            "Sign in type" to signInType.name,
-            "Wallets Count" to walletsCount,
-        ),
+        params = buildMap {
+            put(AnalyticsParam.CURRENCY, currency.value)
+            put(AnalyticsParam.BATCH, batch)
+            put("Sign in type", signInType.name)
+            put("Wallets Count", walletsCount)
+            if (hasBackup != null) {
+                put("Backuped", if (hasBackup) "Yes" else "No")
+            }
+        },
     ) {
         enum class SignInType {
             Card, Biometric

app/src/main/java/com/tangem/tap/common/analytics/events/Onboarding.kt

@@ -23,9 +23,14 @@ sealed class Onboarding(
         class ButtonCreateWallet : CreateWallet("Button - Create Wallet")
         class WalletCreatedSuccessfully(
             creationType: AnalyticsParam.WalletCreationType = AnalyticsParam.WalletCreationType.PrivateKey,
+            seedPhraseLength: Int? = null,
         ) : CreateWallet(
             event = "Wallet Created Successfully",
-            params = mapOf(AnalyticsParam.CREATION_TYPE to creationType.value),
+            params = buildMap {
+                put(AnalyticsParam.CREATION_TYPE, creationType.value)
+
+                if (seedPhraseLength != null) put(AnalyticsParam.SEED_PHRASE_LENGTH, seedPhraseLength.toString())
+            },
         )
     }
 

app/src/main/java/com/tangem/tap/common/analytics/events/Portfolio.kt

@@ -12,6 +12,10 @@ sealed class Portfolio(
 ) : AnalyticsEvent("Portfolio", event, params) {
 
     class Refreshed : Portfolio("Refreshed")
+
     class ButtonManageTokens : Portfolio("Button - Manage Tokens")
+
     class TokenTapped : Portfolio("Token is Tapped")
+
+    class OrganizeTokens : Portfolio("Button - Organize Tokens")
 }

app/src/main/java/com/tangem/tap/common/analytics/events/Settings.kt

@@ -22,6 +22,7 @@ sealed class Settings(
     class ButtonAppSettings : Settings(event = "Button - App Settings")
     class ButtonCreateBackup : Settings(event = "Button - Create Backup")
     class ButtonWalletConnect : Settings(event = "Button - Wallet Connect")
+    object ScanNewCard : Settings(event = "Button - Scan New Card")
 
     class ButtonSocialNetwork(network: SocialNetwork) : Settings(
         event = "Button - Social Network",
@@ -78,5 +79,10 @@ sealed class Settings(
         )
 
         object ButtonEnableBiometricAuthentication : AppSettings(event = "Button - Enable Biometric Authentication")
+
+        class MainCurrencyChanged(currencyType: String) : MainScreen(
+            event = "Main Currency Changed",
+            params = mapOf("Currency Type" to currencyType),
+        )
     }
 }

app/src/main/java/com/tangem/tap/common/apptheme/MutableAppThemeModeHolder.kt

@@ -14,4 +14,6 @@ internal object MutableAppThemeModeHolder : AppThemeModeHolder {
             appThemeMode.value = value
         }
         get() = appThemeMode.value
+
+    var isDarkThemeActive: Boolean = false
 }

app/src/main/java/com/tangem/tap/common/compose/OutlinedTextFieldWidget.kt

@@ -1,277 +0,0 @@
-package com.tangem.tap.common.compose
-
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.animateContentSize
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.slideOutVertically
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.LinearProgressIndicator
-import androidx.compose.material.OutlinedTextField
-import androidx.compose.material.Text
-import androidx.compose.material.TextFieldColors
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.input.VisualTransformation
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import com.tangem.common.module.ModuleError
-import com.tangem.core.ui.res.TangemTheme
-import com.tangem.domain.common.form.Field
-import com.tangem.tap.common.CompositionLogger
-import com.tangem.tap.common.compose.extensions.stringResourceDefault
-import com.tangem.tap.domain.moduleMessage.ModuleMessageConverter
-
-/**
-[REDACTED_AUTHOR]
- */
-@Composable
-fun OutlinedTextFieldWidget(
-    fieldData: Field.Data<String>,
-    labelId: Int? = null,
-    label: String = "",
-    placeholderId: Int? = null,
-    placeholder: String = "",
-    trailingIcon: @Composable (() -> Unit)? = null,
-    isEnabled: Boolean = true,
-    isVisible: Boolean = true,
-    isLoading: Boolean = false,
-    error: ModuleError? = null,
-    errorConverter: ModuleMessageConverter? = null,
-    debounceTextChanges: Long = 400,
-    visualTransformation: VisualTransformation = VisualTransformation.None,
-    keyboardOptions: KeyboardOptions = KeyboardOptions.Default,
-    onTextChange: (String) -> Unit,
-) {
-    if (!isVisible) return
-
-    Column(modifier = Modifier.animateContentSize()) {
-        OutlinedProgressTextField(
-            fieldData = fieldData,
-            label = stringResourceDefault(labelId, label),
-            placeholder = stringResourceDefault(placeholderId, placeholder),
-            trailingIcon = trailingIcon,
-            isEnabled = isEnabled,
-            isLoading = isLoading,
-            error = error,
-            debounce = debounceTextChanges,
-            visualTransformation = visualTransformation,
-            keyboardOptions = keyboardOptions,
-            onTextChange = onTextChange,
-        )
-        errorConverter?.let { AnimatedErrorView(errorConverter = it, error = error) }
-    }
-}
-
-@Suppress("LongMethod", "NestedBlockDepth", "MagicNumber", "MaxLineLength")
-@Composable
-private fun OutlinedProgressTextField(
-    fieldData: Field.Data<String>,
-    label: String = "",
-    placeholder: String = "",
-    isEnabled: Boolean = true,
-    isLoading: Boolean = false,
-    error: ModuleError? = null,
-    debounce: Long = 400,
-    visualTransformation: VisualTransformation = VisualTransformation.None,
-    keyboardOptions: KeyboardOptions = KeyboardOptions.Default,
-    colors: TextFieldColors = TangemTextFieldsDefault.defaultTextFieldColors,
-    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
-    trailingIcon: @Composable (() -> Unit)? = null,
-    onTextChange: (String) -> Unit,
-) {
-    val logger = remember {
-        CompositionLogger(label, "OutlinedProgressTextField", listOf("Символ токена"))
-    }
-    logger.nextComposition()
-
-    val textValueState = remember { mutableStateOf(fieldData.value) }
-    val textDebouncer = valueDebouncerAsState(
-        initialValue = fieldData.value,
-        debounce = debounce,
-        onEmitValueReceive = {
-            logger.log("DEBOUNCER: onEmitValueReceived: [$it]")
-            logger.log("DEBOUNCER: start RECOMPOSE by new value for textValueState.value = [$it]")
-            textValueState.value = it
-        },
-        onValueChange = {
-            logger.log("DEBOUNCER: onValueChanged:  >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  dispatch.toStore([$it])")
-            onTextChange(it)
-        },
-    )
-
-    logger.log("RECOMPOSE ---------------------------------------------------------------START [${logger.count}]")
-    logger.log("RECOMPOSE --data: fieldData.value: [$fieldData]")
-    logger.log("RECOMPOSE --data: textValueState.value: [${textValueState.value}]")
-    logger.log("RECOMPOSE --data: textDebouncer.emittedValue = [${textDebouncer.emittedValue}]")
-    logger.log("RECOMPOSE --data: textDebouncer.debounced = [${textDebouncer.debounced}]")
-
-    if (!fieldData.isUserInput) {
-        // initial value is not from an user
-        val isNotUserInput = "-- IS NOT USER INPUT"
-        logger.log("recompose $isNotUserInput")
-        if (textValueState.value == fieldData.value) {
-            logger.log("$isNotUserInput: внешние данные ОДИНАКОВЫ с данными в поле")
-        } else {
-            logger.log("$isNotUserInput: внешние данные РАЗЛИЧАЮТСЯ с данными в поле")
-            if (textDebouncer.emittedValue != textDebouncer.debounced || textDebouncer.emitsCountBeforeDebounce > 0) {
-                logger.log("$isNotUserInput: пользователь ВВОДИТ данные -> внешние данные игнорируем, ждем RECOMPOSE")
-            } else {
-                logger.log("$isNotUserInput: пользователь НЕ вводит данные -> пытаемся обработать внешние данные")
-                if (textValueState.value != textDebouncer.emittedValue ||
-                    textValueState.value != textDebouncer.debounced
-                ) {
-                    logger.log("$isNotUserInput: даннные в поле не соответствуют данным из textDebouncer")
-                    if (textDebouncer.emittedValue.isEmpty() && textDebouncer.debounced.isEmpty()) {
-                        logger.log(
-                            "$isNotUserInput: даннные в textDebouncer ПУСТЫ -> start RECOMPOSE новые данные для " +
-                                "textValueState.value = [${fieldData.value}]",
-                        )
-                        textValueState.value = fieldData.value
-                    } else {
-                        logger.log(
-                            "$isNotUserInput: даннные в textDebouncer НЕ ПУСТЫ  -> start RECOMPOSE новые данные для " +
-                                "textValueState.value = [${fieldData.value}]",
-                        )
-                        textValueState.value = fieldData.value
-                    }
-                } else {
-                    logger.log(
-                        "$isNotUserInput: в пустое поле вставляются данные -> start RECOMPOSE новые данные для " +
-                            "textValueState.value = [${fieldData.value}]",
-                    )
-                    textValueState.value = fieldData.value
-                }
-            }
-        }
-    }
-    logger.log("recompose --------------------------------------------------------------FINISH [${logger.count}]")
-
-    Box {
-        OutlinedTextField(
-            modifier = Modifier
-                .fillMaxWidth(),
-            value = textValueState.value,
-            onValueChange = {
-                logger.log("WIDGET: textDebouncer.emmit([$it])")
-                textDebouncer.emmit(it)
-            },
-            keyboardOptions = keyboardOptions,
-            label = {
-                Text(
-                    text = label,
-                    style = TangemTheme.typography.caption,
-                    color = colors.labelColor(
-                        enabled = isEnabled,
-                        error = error != null,
-                        interactionSource = interactionSource,
-                    ).value,
-                )
-            },
-            placeholder = {
-                Text(
-                    text = placeholder,
-                    style = TangemTheme.typography.body1,
-                    color = colors.placeholderColor(enabled = isEnabled).value,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis,
-                )
-            },
-            trailingIcon = trailingIcon,
-            singleLine = true,
-            enabled = isEnabled,
-            isError = error != null,
-            visualTransformation = visualTransformation,
-            colors = colors,
-            interactionSource = interactionSource,
-        )
-        AnimatedVisibility(
-            modifier = Modifier
-                .fillMaxWidth()
-                .align(Alignment.BottomCenter)
-                .padding(start = 6.dp, top = 0.dp, end = 6.dp, bottom = 6.dp),
-            visible = isLoading,
-        ) {
-            LinearProgressIndicator(
-                color = TangemTheme.colors.icon.primary1,
-            )
-        }
-    }
-}
-
-@Composable
-private fun AnimatedErrorView(errorConverter: ModuleMessageConverter, error: ModuleError? = null) {
-    AnimatedVisibility(
-        visible = error != null,
-        enter = fadeIn() + slideInVertically(),
-        exit = slideOutVertically() + fadeOut(),
-    ) {
-        error?.let {
-            ErrorView(
-                text = errorConverter.convert(it).message,
-                style = TextStyle(fontSize = 14.sp),
-            )
-        }
-    }
-}
-
-@Preview
-@Composable
-private fun OutlinedTextFieldWithErrorTest() {
-    val context = LocalContext.current
-    val converter = remember { ModuleMessageConverter(context) }
-
-    class SimpleError(
-        override val code: Int = 1,
-        override val message: String = "Error message",
-        override val data: Any? = null,
-    ) : ModuleError()
-
-    val modifier = Modifier
-        .fillMaxWidth()
-        .padding(16.dp)
-    Column {
-        OutlinedTextFieldWidget(
-            fieldData = Field.Data("", false),
-            label = "First label",
-            placeholder = "1 placeholder",
-            error = null,
-            errorConverter = converter,
-        ) {}
-        OutlinedTextFieldWidget(
-            fieldData = Field.Data("First", false),
-            label = "First label",
-            placeholder = "1 placeholder",
-            error = null,
-            errorConverter = converter,
-        ) {}
-        OutlinedTextFieldWidget(
-            fieldData = Field.Data("First", false),
-            label = "First label",
-            placeholder = "1 placeholder",
-            isLoading = true,
-            error = null,
-            errorConverter = converter,
-        ) {}
-        OutlinedTextFieldWidget(
-            fieldData = Field.Data("First", false),
-            label = "First label",
-            placeholder = "1 placeholder",
-            error = SimpleError(),
-            errorConverter = converter,
-        ) {}
-    }
-}

app/src/main/java/com/tangem/tap/common/compose/Undefined.kt

@@ -1,24 +0,0 @@
-package com.tangem.tap.common.compose
-
-import androidx.compose.foundation.layout.Column
-import androidx.compose.material.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.unit.sp
-
-/**
-[REDACTED_AUTHOR]
- * Compose views are not typically used as a main or base view.
- */
-
-@Composable
-fun TitleSubtitle(title: String, subtitle: String) {
-    Column {
-        Text(text = title)
-        Text(
-            text = subtitle,
-            fontSize = 12.sp,
-            color = Color.Gray,
-        )
-    }
-}

app/src/main/java/com/tangem/tap/common/compose/extensions/Resources.kt

@@ -1,21 +0,0 @@
-package com.tangem.tap.common.compose.extensions
-
-import android.content.res.Resources
-import androidx.annotation.StringRes
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.platform.LocalContext
-
-/**
-[REDACTED_AUTHOR]
- */
-@Composable
-fun stringResourceDefault(@StringRes id: Int?, default: String = ""): String {
-    val resources = LocalContext.current.resources
-    return try {
-        resources.getString(requireNotNull(id))
-    } catch (ex: Resources.NotFoundException) {
-        default
-    } catch (ex: IllegalArgumentException) {
-        default
-    }
-}

app/src/main/java/com/tangem/tap/common/extensions/Blockchain.kt

@@ -47,6 +47,7 @@ fun Blockchain.getGreyedOutIconRes(): Int {
         Blockchain.AlephZero, Blockchain.AlephZeroTestnet -> R.drawable.ic_azero_no_color
         Blockchain.OctaSpace, Blockchain.OctaSpaceTestnet -> R.drawable.ic_octaspace_no_color
         Blockchain.Chia, Blockchain.ChiaTestnet -> R.drawable.ic_chia_no_color
+        Blockchain.Near, Blockchain.NearTestnet -> R.drawable.ic_near_no_color
         else -> R.drawable.ic_tangem_logo
     }
 }

app/src/main/java/com/tangem/tap/common/extensions/Navigation.kt

@@ -6,7 +6,8 @@ import com.tangem.core.navigation.AppScreen
 import com.tangem.core.navigation.FragmentShareTransition
 import com.tangem.feature.referral.ReferralFragment
 import com.tangem.feature.swap.presentation.SwapFragment
-import com.tangem.tap.features.customtoken.legacy.AddCustomTokenFragment
+import com.tangem.tap.features.customtoken.impl.presentation.AddCustomTokenFragment
+import com.tangem.tap.features.details.ui.appcurrency.AppCurrencySelectorFragment
 import com.tangem.tap.features.details.ui.appsettings.AppSettingsFragment
 import com.tangem.tap.features.details.ui.cardsettings.CardSettingsFragment
 import com.tangem.tap.features.details.ui.cardsettings.coderecovery.AccessCodeRecoveryFragment
@@ -33,7 +34,6 @@ import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.store
 import com.tangem.wallet.R
 import timber.log.Timber
-import com.tangem.tap.features.customtoken.impl.presentation.AddCustomTokenFragment as RedesignedAddCustomTokenFragment
 
 fun FragmentActivity.openFragment(
     screen: AppScreen,
@@ -155,21 +155,10 @@ private fun fragmentFactory(screen: AppScreen): Fragment {
         AppScreen.AccessCodeRecovery -> AccessCodeRecoveryFragment()
         AppScreen.Disclaimer -> DisclaimerFragment()
         AppScreen.AddTokens -> TokensListFragment()
-
-        AppScreen.AddCustomToken -> {
-            val featureToggles = store.state.daggerGraphState.get(
-                getDependency = DaggerGraphState::customTokenFeatureToggles,
-            )
-            if (featureToggles.isRedesignedScreenEnabled) {
-                RedesignedAddCustomTokenFragment()
-            } else {
-                AddCustomTokenFragment()
-            }
-        }
-
+        AppScreen.AddCustomToken -> AddCustomTokenFragment()
         AppScreen.WalletDetails -> {
             val featureToggles = store.state.daggerGraphState.get(
-                getDependency = DaggerGraphState::tokenDetailsFeatureToggles,
+                getDependency = DaggerGraphState::walletFeatureToggles,
             )
             if (featureToggles.isRedesignedScreenEnabled) {
                 store.state.daggerGraphState
@@ -186,5 +175,6 @@ private fun fragmentFactory(screen: AppScreen): Fragment {
         AppScreen.Welcome -> WelcomeFragment()
         AppScreen.SaveWallet -> SaveWalletBottomSheetFragment()
         AppScreen.WalletSelector -> WalletSelectorBottomSheetFragment()
+        AppScreen.AppCurrencySelector -> AppCurrencySelectorFragment()
     }
 }

app/src/main/java/com/tangem/tap/common/extensions/Store.kt

@@ -1,10 +1,10 @@
 package com.tangem.tap.common.extensions
 
 import com.tangem.core.navigation.NavigationAction
+import com.tangem.core.navigation.StateDialog
 import com.tangem.domain.common.extensions.withMainContext
 import com.tangem.domain.wallets.models.UserWallet
 import com.tangem.tap.common.redux.AppState
-import com.tangem.tap.common.redux.StateDialog
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.domain.TapError
 import com.tangem.tap.scope

app/src/main/java/com/tangem/tap/common/extensions/ValueCallback.kt

@@ -1,6 +0,0 @@
-package com.tangem.tap.common.extensions
-
-/**
-[REDACTED_AUTHOR]
- */
-typealias ValueCallback<T> = (T) -> Unit

app/src/main/java/com/tangem/tap/common/extensions/WalletManager.kt

@@ -1,12 +1,12 @@
 package com.tangem.tap.common.extensions
 
-import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.BlockchainSdkError
 import com.tangem.blockchain.common.Wallet
 import com.tangem.blockchain.common.WalletManager
 import com.tangem.common.services.Result
 import com.tangem.domain.common.extensions.amountToCreateAccount
 import com.tangem.tap.common.TestActions
+import com.tangem.tap.common.apptheme.MutableAppThemeModeHolder
 import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.getFirstToken
 import com.tangem.tap.domain.model.WalletDataModel
@@ -26,10 +26,8 @@ import timber.log.Timber
         "or WalletCurrenciesManager.update(...) (to update only one user wallet blockchain and its tokens) instead",
 )
 @Suppress("MagicNumber")
-suspend fun WalletManager.safeUpdate(): Result<Wallet> = try {
-    val scanResponse = store.state.globalState.scanResponse
-
-    if (scanResponse?.isDemoCard() == true || TestActions.testAmountInjectionForWalletManagerEnabled) {
+suspend fun WalletManager.safeUpdate(isDemoCard: Boolean): Result<Wallet> = try {
+    if (isDemoCard || TestActions.testAmountInjectionForWalletManagerEnabled) {
         delay(500)
         TestActions.testAmountInjectionForWalletManagerEnabled = false
         Result.Success(wallet)
@@ -71,6 +69,7 @@ fun WalletManager.getTopUpUrl(): String? {
         cryptoCurrencyName = wallet.blockchain.currency,
         fiatCurrencyName = globalState.appCurrency.code,
         walletAddress = defaultAddress,
+        isDarkTheme = MutableAppThemeModeHolder.isDarkThemeActive,
     )
 }
 
@@ -79,12 +78,4 @@ fun WalletManager?.getAddressData(): WalletDataModel.AddressData? {
 
     val addressDataList = wallet.createAddressesData()
     return if (addressDataList.isEmpty()) null else addressDataList[0]
-}
-
-fun <T> WalletManager.Companion.stub(): T {
-    val wallet = Wallet(Blockchain.Unknown, setOf(), Wallet.PublicKey(byteArrayOf(), null), setOf())
-    return object : WalletManager(wallet) {
-        override val currentHost: String = ""
-        override suspend fun update() {}
-    } as T
 }

app/src/main/java/com/tangem/tap/common/feedback/AdditionalFeedbackInfo.kt

@@ -9,13 +9,21 @@ import com.tangem.domain.userwallets.UserWalletIdBuilder
 import com.tangem.tap.common.extensions.stripZeroPlainString
 
 class AdditionalFeedbackInfo {
+
     class EmailWalletInfo(
-        var blockchain: Blockchain = Blockchain.Unknown,
-        var derivationPath: String = "",
-        var outputsCount: String? = null,
-        var host: String = "",
-        var addresses: String = "",
-        var explorerLink: String = "",
+        val blockchain: Blockchain = Blockchain.Unknown,
+        val derivationPath: String = "",
+        val outputsCount: String? = null,
+        val host: String = "",
+        val addresses: String = "",
+        val explorerLink: String = "",
+        val tokens: List<EmailTokenInfo> = emptyList(),
+    )
+
+    class EmailTokenInfo(
+        val id: String?,
+        val name: String,
+        val contractAddress: String,
     )
 
     var appVersion: String = ""
@@ -28,24 +36,33 @@ class AdditionalFeedbackInfo {
     var userWalletId: String = ""
 
     // wallets
-    internal val walletsInfo = mutableListOf<EmailWalletInfo>()
-    internal val tokens = mutableMapOf<Blockchain, Collection<Token>>()
-    internal var onSendErrorWalletInfo: EmailWalletInfo? = null
+    var walletsInfo = emptyList<EmailWalletInfo>()
+        private set
+    var onSendErrorWalletInfo: EmailWalletInfo? = null
+        private set
     var signedHashesCount: String = ""
+        private set
 
     // device
     var phoneModel: String = Build.MODEL
+        private set
     var osVersion: String = Build.VERSION.SDK_INT.toString()
+        private set
 
     // send error
     var destinationAddress: String = ""
+        private set
     var amount: String = ""
+        private set
     var fee: String = ""
+        private set
     var token: String = ""
+        private set
 
     private val Address.name: String
         get() = type.javaClass.simpleName
 
+    @Deprecated("Don't use it directly")
     fun setCardInfo(data: ScanResponse) {
         cardId = data.card.cardId
         cardBlockchain = data.walletData?.blockchain ?: ""
@@ -55,27 +72,25 @@ class AdditionalFeedbackInfo {
         userWalletId = UserWalletIdBuilder.scanResponse(data).build()?.stringValue ?: ""
     }
 
+    @Deprecated("Don't use it directly")
     fun setWalletsInfo(walletManagers: List<WalletManager>) {
-        walletsInfo.clear()
-        tokens.clear()
-        walletManagers.forEach { manager ->
-            walletsInfo.add(createEmailWalletInfo(manager))
-            if (manager.cardTokens.isNotEmpty()) {
-                tokens[manager.wallet.blockchain] = manager.cardTokens
-            }
-        }
+        walletsInfo = walletManagers.map(::createEmailWalletInfo)
     }
 
     fun updateOnSendError(
         walletManager: WalletManager,
         amountToSend: Amount,
-        feeAmount: Amount,
+        feeAmount: Amount?,
         destinationAddress: String,
     ) {
         onSendErrorWalletInfo = createEmailWalletInfo(walletManager)
         this.destinationAddress = destinationAddress
         amount = amountToSend.value?.stripZeroPlainString() ?: "0"
-        fee = feeAmount.value?.stripZeroPlainString() ?: "0"
+        fee = if (feeAmount != null) {
+            feeAmount.value?.stripZeroPlainString() ?: "0"
+        } else {
+            "Unable to receive"
+        }
         token = if (amountToSend.type is AmountType.Token) amountToSend.currencySymbol else ""
     }
 
@@ -87,6 +102,9 @@ class AdditionalFeedbackInfo {
             host = walletManager.currentHost,
             addresses = formatAddresses(walletManager.wallet),
             explorerLink = formatExploreUrls(walletManager.wallet),
+            tokens = walletManager.cardTokens.map { token ->
+                EmailTokenInfo(token.id, token.name, token.contractAddress)
+            },
         )
     }
 

app/src/main/java/com/tangem/tap/common/feedback/FeedbackDataBuilder.kt

@@ -33,10 +33,10 @@ class FeedbackDataBuilder(
             builder.appendKeyValue("Derivation path", it.derivationPath)
             builder.appendKeyValue("Outputs count", it.outputsCount)
 
-            infoHolder.tokens[it.blockchain]?.let { tokens ->
+            if (it.tokens.isNotEmpty()) {
                 builder.append("Tokens:")
                 breakLine()
-                tokens.forEach { token ->
+                it.tokens.forEach { token ->
                     builder.appendKeyValue("ID", token.id ?: "[custom token]")
                     builder.appendKeyValue("Name", token.name)
                     builder.appendKeyValue("Contract address", token.contractAddress)

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

@@ -1,6 +1,7 @@
 package com.tangem.tap.common.redux
 
 import com.tangem.common.extensions.VoidCallback
+import com.tangem.core.navigation.StateDialog
 import com.tangem.tap.common.TestAction
 import com.tangem.tap.domain.model.WalletDataModel
 import com.tangem.tap.features.wallet.models.Currency
@@ -8,8 +9,6 @@ import com.tangem.tap.features.wallet.models.Currency
 /**
 [REDACTED_AUTHOR]
  */
-interface StateDialog
-
 sealed class AppDialog : StateDialog {
     data class SimpleOkDialog(val header: String, val message: String, val onOk: VoidCallback? = null) : AppDialog()
     data class SimpleOkErrorDialog(val message: String, val onOk: VoidCallback? = null) : AppDialog()
@@ -33,8 +32,6 @@ sealed class AppDialog : StateDialog {
         val action: VoidCallback? = null,
     )
 
-    object ScanFailsDialog : AppDialog()
-
     data class AddressInfoDialog(
         val currency: Currency,
         val addressData: WalletDataModel.AddressData,

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

@@ -6,6 +6,7 @@ import com.tangem.domain.redux.domainStore
 import com.tangem.domain.redux.global.NetworkServices
 import com.tangem.tap.common.redux.global.GlobalMiddleware
 import com.tangem.tap.common.redux.global.GlobalState
+import com.tangem.tap.common.redux.legacy.LegacyMiddleware
 import com.tangem.tap.common.redux.navigation.navigationMiddleware
 import com.tangem.tap.features.details.redux.DetailsMiddleware
 import com.tangem.tap.features.details.redux.DetailsState
@@ -68,7 +69,7 @@ data class AppState(
     val daggerGraphState: DaggerGraphState = DaggerGraphState(),
 ) : StateType {
 
-    val domainState: DomainState
+    private val domainState: DomainState
         get() = domainStore.state
 
     val domainNetworks: NetworkServices
@@ -107,6 +108,7 @@ data class AppState(
                 AccessCodeRequestPolicyMiddleware().middleware,
                 SignInMiddleware.middleware,
                 DaggerGraphMiddleware.daggerGraphMiddleware,
+                LegacyMiddleware.legacyMiddleware,
             )
         }
     }

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

@@ -1,18 +1,21 @@
 package com.tangem.tap.common.redux.global
 
-import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.WalletManager
 import com.tangem.common.CompletionResult
-import com.tangem.common.core.TangemError
+import com.tangem.core.navigation.StateDialog
 import com.tangem.datasource.config.ConfigManager
 import com.tangem.datasource.config.models.ChatConfig
+import com.tangem.domain.apptheme.model.AppThemeMode
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.tap.common.analytics.topup.TopUpController
 import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.common.feedback.FeedbackData
 import com.tangem.tap.common.feedback.FeedbackManager
-import com.tangem.tap.common.redux.*
+import com.tangem.tap.common.redux.DebugErrorAction
+import com.tangem.tap.common.redux.ErrorAction
+import com.tangem.tap.common.redux.NotificationAction
+import com.tangem.tap.common.redux.ToastNotificationAction
 import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessage
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessagesManager
@@ -48,13 +51,6 @@ sealed class GlobalAction : Action {
         object Stop : Onboarding()
     }
 
-    data class ScanCard(
-        val additionalBlockchainsToDerive: Collection<Blockchain>? = null,
-        val onSuccess: ((ScanResponse) -> Unit)? = null,
-        val onFailure: ((TangemError) -> Unit)? = null,
-        val messageResId: Int? = null,
-    ) : GlobalAction()
-
     object ScanFailsCounter {
         data class ChooseBehavior(val result: CompletionResult<ScanResponse>) : GlobalAction()
         object Reset : GlobalAction()
@@ -103,4 +99,5 @@ sealed class GlobalAction : Action {
     }
 
     data class UpdateUserWalletsListManager(val manager: UserWalletsListManager) : GlobalAction()
+    data class ChangeAppThemeMode(val appThemeMode: AppThemeMode) : GlobalAction()
 }

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

@@ -3,20 +3,19 @@ package com.tangem.tap.common.redux.global
 import com.tangem.common.CompletionResult
 import com.tangem.common.core.TangemSdkError
 import com.tangem.common.extensions.guard
+import com.tangem.core.analytics.Analytics
+import com.tangem.core.navigation.StateDialog
 import com.tangem.datasource.config.models.Config
 import com.tangem.domain.common.LogConfig
-import com.tangem.domain.common.extensions.withMainContext
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.tap.*
+import com.tangem.tap.common.analytics.events.Basic
 import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
 import com.tangem.tap.common.extensions.dispatchDialogShow
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.extensions.dispatchWithMain
-import com.tangem.tap.common.redux.AppDialog
 import com.tangem.tap.common.redux.AppState
-import com.tangem.tap.domain.configurable.warningMessage.WarningMessagesManager
 import com.tangem.tap.features.send.redux.SendAction
 import com.tangem.tap.features.wallet.redux.WalletAction
 import com.tangem.tap.network.exchangeServices.BuyExchangeService
@@ -26,11 +25,15 @@ import com.tangem.tap.network.exchangeServices.ExchangeService
 import com.tangem.tap.network.exchangeServices.mercuryo.MercuryoEnvironment
 import com.tangem.tap.network.exchangeServices.mercuryo.MercuryoService
 import com.tangem.tap.network.exchangeServices.moonpay.MoonPayService
+import com.tangem.tap.preferencesStorage
 import com.tangem.tap.proxy.redux.DaggerGraphState
-import kotlinx.coroutines.flow.firstOrNull
+import com.tangem.tap.scope
+import com.tangem.tap.store
+import com.tangem.tap.walletCurrenciesManager
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import org.rekotlin.Action
-import org.rekotlin.DispatchFunction
 import org.rekotlin.Middleware
 import java.util.Locale
 
@@ -41,14 +44,14 @@ object GlobalMiddleware {
 private val globalMiddlewareHandler: Middleware<AppState> = { dispatch, appState ->
     { nextDispatch ->
         { action ->
-            handleAction(action, appState, dispatch)
+            handleAction(action, appState)
             nextDispatch(action)
         }
     }
 }
 
 @Suppress("LongMethod", "ComplexMethod")
-private fun handleAction(action: Action, appState: () -> AppState?, dispatch: DispatchFunction) {
+private fun handleAction(action: Action, appState: () -> AppState?) {
     when (action) {
         is GlobalAction.ScanFailsCounter.ChooseBehavior -> {
             when (action.result) {
@@ -57,7 +60,7 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
                     if (action.result.error is TangemSdkError.UserCancelled) {
                         store.dispatch(GlobalAction.ScanFailsCounter.Increment)
                         if (store.state.globalState.scanCardFailsCounter >= 2) {
-                            store.dispatchDialogShow(AppDialog.ScanFailsDialog)
+                            store.dispatchDialogShow(StateDialog.ScanFailsDialog)
                         }
                     } else {
                         store.dispatch(GlobalAction.ScanFailsCounter.Reset)
@@ -66,7 +69,13 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
             }
         }
         is GlobalAction.RestoreAppCurrency -> {
-            if (store.state.daggerGraphState.get(DaggerGraphState::walletFeatureToggles).isRedesignedScreenEnabled) {
+            val daggerGraphState = store.state.daggerGraphState
+            val walletFeatureToggles = daggerGraphState.get(DaggerGraphState::walletFeatureToggles)
+            val detailsFeatureToggles = daggerGraphState.get(DaggerGraphState::detailsFeatureToggles)
+
+            if (walletFeatureToggles.isRedesignedScreenEnabled ||
+                detailsFeatureToggles.isRedesignedAppCurrencySelectorEnabled
+            ) {
                 restoreAppCurrencyNew()
             } else {
                 restoreAppCurrencyLegacy()
@@ -75,10 +84,10 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
         is GlobalAction.HideWarningMessage -> {
             store.state.globalState.warningManager?.let {
                 if (it.hideWarning(action.warning)) {
-                    if (WarningMessagesManager.isAlreadySignedHashesWarning(action.warning)) {
-                        // TODO: No appropriate warningMessage identification. Make it better later
-                        store.dispatch(WalletAction.Warnings.CheckHashesCount.SaveCardId)
-                    }
+                    // if (WarningMessagesManager.isAlreadySignedHashesWarning()) {
+                    //     // TODO: No appropriate warningMessage identification. Make it better later
+                    //     store.dispatch(WalletAction.Warnings.CheckHashesCount.SaveCardId)
+                    // }
 
                     store.dispatch(WalletAction.Warnings.Update)
                     store.dispatch(SendAction.Warnings.Update)
@@ -131,6 +140,8 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
                     sellService = makeSellExchangeService(config),
                     primaryRules = CardExchangeRules(cardProvider),
                 )
+                // TODO: for refactoring (after remove old design refactor CurrencyExchangeManager and use 1 instance)
+                store.state.daggerGraphState.get(DaggerGraphState::appStateHolder).exchangeService = exchangeManager
                 store.dispatchOnMain(GlobalAction.ExchangeManager.Init.Success(exchangeManager))
                 store.dispatchOnMain(GlobalAction.ExchangeManager.Update)
             }
@@ -143,28 +154,6 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
             }
             scope.launch { exchangeManager.update() }
         }
-        is GlobalAction.ScanCard -> {
-            scope.launch {
-                tangemSdkManager.changeDisplayedCardIdNumbersCount(null)
-                val result = tangemSdkManager.scanProduct(
-                    userTokensRepository = userTokensRepository,
-                    additionalBlockchainsToDerive = action.additionalBlockchainsToDerive,
-                    messageRes = action.messageResId,
-                )
-                withMainContext {
-                    store.dispatch(GlobalAction.ScanFailsCounter.ChooseBehavior(result))
-                    when (result) {
-                        is CompletionResult.Success -> {
-                            tangemSdkManager.changeDisplayedCardIdNumbersCount(result.data)
-                            action.onSuccess?.invoke(result.data)
-                        }
-                        is CompletionResult.Failure -> {
-                            action.onFailure?.invoke(result.error)
-                        }
-                    }
-                }
-            }
-        }
         is GlobalAction.FetchUserCountry -> {
             scope.launch {
                 // TODO("After adding DI") get dependencies by DI
@@ -186,6 +175,30 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
         is GlobalAction.SetTopUpController -> {
             walletCurrenciesManager.addListener(action.topUpController)
         }
+        is GlobalAction.UpdateUserWalletsListManager -> {
+            val walletManagersFacade = store.state.daggerGraphState.get(DaggerGraphState::walletManagersFacade)
+
+            /*
+             * If implementation of the UserWalletsListManager is changed,
+             * then all observers of selectedUserWallet become irrelevant.
+             */
+            action.manager.selectedUserWallet
+                .distinctUntilChanged()
+                .onEach { userWallet ->
+                    Analytics.send(Basic.WalletOpened())
+
+                    store.state.globalState.feedbackManager?.infoHolder?.let { infoHolder ->
+                        infoHolder.setCardInfo(userWallet.scanResponse)
+
+                        walletManagersFacade
+                            .getAll(userWallet.walletId)
+                            .onEach(infoHolder::setWalletsInfo)
+                            .launchIn(scope)
+                    }
+                }
+                .flowOn(Dispatchers.IO)
+                .launchIn(scope)
+        }
     }
 }
 

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

@@ -97,6 +97,9 @@ fun globalReducer(action: Action, state: AppState, appStateHolder: AppStateHolde
                 userWalletsListManager = action.manager,
             )
         }
+        is GlobalAction.ChangeAppThemeMode -> globalState.copy(
+            appThemeMode = action.appThemeMode,
+        )
         else -> globalState
     }
 }

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

@@ -1,12 +1,13 @@
 package com.tangem.tap.common.redux.global
 
+import com.tangem.core.navigation.StateDialog
 import com.tangem.datasource.config.ConfigManager
+import com.tangem.domain.apptheme.model.AppThemeMode
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.tap.common.analytics.topup.TopUpController
 import com.tangem.tap.common.entities.FiatCurrency
 import com.tangem.tap.common.feedback.FeedbackManager
-import com.tangem.tap.common.redux.StateDialog
 import com.tangem.tap.domain.TapWalletManager
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessagesManager
 import com.tangem.tap.features.onboarding.OnboardingManager
@@ -29,6 +30,7 @@ data class GlobalState(
     val userCountryCode: String? = null,
     val userWalletsListManager: UserWalletsListManager? = null,
     val topUpController: TopUpController? = null,
+    val appThemeMode: AppThemeMode = AppThemeMode.DEFAULT,
 ) : StateType
 
 typealias CryptoCurrencyName = String

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

@@ -0,0 +1,22 @@
+package com.tangem.tap.common.redux.legacy
+
+import com.tangem.domain.redux.LegacyAction
+import com.tangem.tap.common.feedback.RateCanBeBetterEmail
+import com.tangem.tap.common.redux.AppState
+import com.tangem.tap.store
+import org.rekotlin.Middleware
+
+internal object LegacyMiddleware {
+    val legacyMiddleware: Middleware<AppState> = { _, _ ->
+        { next ->
+            { action ->
+                when (action) {
+                    is LegacyAction.SendEmailRateCanBeBetter -> {
+                        store.state.globalState.feedbackManager?.sendEmail(RateCanBeBetterEmail())
+                    }
+                }
+                next(action)
+            }
+        }
+    }
+}

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

@@ -8,10 +8,7 @@ import com.tangem.core.navigation.AppScreen
 import com.tangem.core.navigation.NavigationAction
 import com.tangem.tap.activityResultCaller
 import com.tangem.tap.common.CustomTabsManager
-import com.tangem.tap.common.extensions.dispatchOnMain
-import com.tangem.tap.common.extensions.openFragment
-import com.tangem.tap.common.extensions.popBackTo
-import com.tangem.tap.common.extensions.shareText
+import com.tangem.tap.common.extensions.*
 import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.store
 import org.rekotlin.Middleware
@@ -60,6 +57,7 @@ val navigationMiddleware: Middleware<AppState> = { _, state ->
                         intent.data = action.url
                         navState?.activity?.get()?.startActivity(intent)
                     }
+                    is NavigationAction.OpenDialog -> store.dispatchDialogShow(action.stateDialog)
                     is NavigationAction.OpenBiometricsSettings -> {
                         val settingsAction = when {
                             Build.VERSION.SDK_INT >= Build.VERSION_CODES.R -> {

app/src/main/java/com/tangem/tap/common/ui/SimpleAlertDialog.kt

@@ -2,6 +2,7 @@ package com.tangem.tap.common.ui
 
 import android.content.Context
 import androidx.appcompat.app.AlertDialog
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.store
 import com.tangem.wallet.R
@@ -39,7 +40,7 @@ object SimpleCancelableAlertDialog {
         secondaryButtonAction: () -> Unit = {},
         context: Context,
     ): AlertDialog {
-        return AlertDialog.Builder(context).apply {
+        return MaterialAlertDialogBuilder(context, R.style.CustomMaterialDialog).apply {
             setTitle(titleRes?.let { context.getString(it) } ?: title)
             setMessage(messageRes?.let { context.getString(it) } ?: message)
             setPositiveButton(context.getText(primaryButtonRes)) { _, _ -> primaryButtonAction() }

app/src/main/java/com/tangem/tap/di/ActivityModule.kt

@@ -3,14 +3,19 @@ package com.tangem.tap.di
 import android.content.Context
 import com.tangem.domain.card.ScanCardUseCase
 import com.tangem.domain.card.repository.CardSdkConfigRepository
+import com.tangem.domain.exchange.RampStateManager
 import com.tangem.tap.domain.TangemSdkManager
 import com.tangem.tap.domain.scanCard.repository.DefaultScanCardRepository
-import com.tangem.tap.userTokensRepository
+import com.tangem.tap.network.exchangeServices.DefaultRampManager
+import com.tangem.tap.proxy.AppStateHolder
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import javax.inject.Singleton
 
 @Module
@@ -35,9 +40,21 @@ internal object ActivityModule {
         return ScanCardUseCase(
             cardSdkConfigRepository = cardSdkConfigRepository,
             scanCardRepository = DefaultScanCardRepository(
-                userTokensRepository = userTokensRepository,
                 tangemSdkManager = tangemSdkManager,
             ),
         )
     }
+
+    @Provides
+    @Singleton
+    fun provideDefaultRampManager(appStateHolder: AppStateHolder): RampStateManager {
+        return DefaultRampManager(appStateHolder.exchangeService)
+    }
+
+    @Provides
+    @Singleton
+    @DelayedWork
+    fun provideActivityDelayedWorkCoroutineScope(): CoroutineScope {
+        return CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    }
 }

app/src/main/java/com/tangem/tap/di/Qualifiers.kt

@@ -0,0 +1,8 @@
+@file:Suppress("Filename")
+package com.tangem.tap.di
+
+import javax.inject.Qualifier
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class DelayedWork

app/src/main/java/com/tangem/tap/di/analytics/AnalyticsModule.kt

@@ -0,0 +1,20 @@
+package com.tangem.tap.di.analytics
+
+import com.tangem.domain.analytics.ChangeCardAnalyticsContextUseCase
+import com.tangem.tap.common.analytics.DefaultChangeCardAnalyticsContextUseCase
+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 AnalyticsModule {
+
+    @Provides
+    @Singleton
+    fun provideChangeCardAnalyticsContextUseCase(): ChangeCardAnalyticsContextUseCase {
+        return DefaultChangeCardAnalyticsContextUseCase()
+    }
+}

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

@@ -1,22 +1,34 @@
 package com.tangem.tap.di.domain
 
+import com.tangem.domain.appcurrency.GetAvailableCurrenciesUseCase
 import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
+import com.tangem.domain.appcurrency.SelectAppCurrencyUseCase
 import com.tangem.domain.appcurrency.repository.AppCurrencyRepository
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.components.ViewModelComponent
-import dagger.hilt.android.scopes.ViewModelScoped
 
 @Module
 @InstallIn(ViewModelComponent::class)
 internal object AppCurrencyDomainModule {
 
     @Provides
-    @ViewModelScoped
     fun provideGetSelectedAppCurrencyUseCase(
         appCurrencyRepository: AppCurrencyRepository,
     ): GetSelectedAppCurrencyUseCase {
         return GetSelectedAppCurrencyUseCase(appCurrencyRepository)
     }
+
+    @Provides
+    fun provideSelectAppCurrencyUseCase(appCurrencyRepository: AppCurrencyRepository): SelectAppCurrencyUseCase {
+        return SelectAppCurrencyUseCase(appCurrencyRepository)
+    }
+
+    @Provides
+    fun provideGetAvailableCurrenciesUseCase(
+        appCurrencyRepository: AppCurrencyRepository,
+    ): GetAvailableCurrenciesUseCase {
+        return GetAvailableCurrenciesUseCase(appCurrencyRepository)
+    }
 }

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

@@ -6,10 +6,10 @@ import com.tangem.domain.apptheme.repository.AppThemeModeRepository
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
-import dagger.hilt.android.components.ViewModelComponent
+import dagger.hilt.components.SingletonComponent
 
 @Module
-@InstallIn(ViewModelComponent::class)
+@InstallIn(SingletonComponent::class)
 internal object AppThemeDomainModule {
 
     @Provides

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

@@ -5,6 +5,10 @@ import com.tangem.domain.card.repository.CardRepository
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.demo.DemoConfig
 import com.tangem.domain.demo.IsDemoCardUseCase
+import com.tangem.domain.wallets.legacy.WalletsStateHolder
+import com.tangem.domain.wallets.usecase.IsNeedToBackupUseCase
+import com.tangem.tap.domain.TangemSdkManager
+import com.tangem.tap.domain.card.DefaultDerivePublicKeysUseCase
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -41,11 +45,29 @@ internal object CardDomainModule {
 
     @Provides
     @ViewModelScoped
-    fun provideGetCardWasScannedUseCase(cardRepository: CardRepository): GetCardWasScannedUseCase {
-        return GetCardWasScannedUseCase(cardRepository = cardRepository)
+    fun provideWasWalletAlreadySignedHashesConfirmedUseCase(cardRepository: CardRepository): WasCardScannedUseCase {
+        return WasCardScannedUseCase(cardRepository = cardRepository)
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun provideSetCardWasScannedUseCase(cardRepository: CardRepository): SetCardWasScannedUseCase {
+        return SetCardWasScannedUseCase(cardRepository = cardRepository)
     }
 
     @Provides
     @ViewModelScoped
     fun provideIsDemoCardUseCase(): IsDemoCardUseCase = IsDemoCardUseCase(config = DemoConfig())
+
+    @Provides
+    @ViewModelScoped
+    fun provideDerivePublicKeysUseCase(tangemSdkManager: TangemSdkManager): DerivePublicKeysUseCase {
+        return DefaultDerivePublicKeysUseCase(tangemSdkManager = tangemSdkManager)
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun provideIsNeedToBackupUseCase(walletStateHolder: WalletsStateHolder): IsNeedToBackupUseCase {
+        return IsNeedToBackupUseCase(walletStateHolder)
+    }
 }

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

@@ -1,8 +1,11 @@
 package com.tangem.tap.di.domain
 
-import com.tangem.domain.settings.CanUseBiometryUseCase
-import com.tangem.domain.settings.IsUserAlreadyRateAppUseCase
-import com.tangem.domain.settings.ShouldShowSaveWalletScreenUseCase
+import com.tangem.domain.balancehiding.DeviceFlipDetector
+import com.tangem.domain.balancehiding.IsBalanceHiddenUseCase
+import com.tangem.domain.balancehiding.ListenToFlipsUseCase
+import com.tangem.domain.balancehiding.repositories.BalanceHidingRepository
+import com.tangem.domain.settings.*
+import com.tangem.domain.settings.repositories.AppRatingRepository
 import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.tap.domain.TangemSdkManager
 import com.tangem.tap.domain.settings.DefaultLegacySettingsRepository
@@ -18,8 +21,28 @@ internal object SettingsDomainModule {
 
     @Provides
     @ViewModelScoped
-    fun providesGetWalletsUseCase(settingsRepository: SettingsRepository): IsUserAlreadyRateAppUseCase {
-        return IsUserAlreadyRateAppUseCase(settingsRepository = settingsRepository)
+    fun providesIsReadyToShowRatingUseCase(appRatingRepository: AppRatingRepository): IsReadyToShowRateAppUseCase {
+        return IsReadyToShowRateAppUseCase(appRatingRepository = appRatingRepository)
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun providesRemindToRateAppLaterUseCase(appRatingRepository: AppRatingRepository): RemindToRateAppLaterUseCase {
+        return RemindToRateAppLaterUseCase(appRatingRepository = appRatingRepository)
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun providesNeverToSuggestRateAppUseCase(appRatingRepository: AppRatingRepository): NeverToSuggestRateAppUseCase {
+        return NeverToSuggestRateAppUseCase(appRatingRepository = appRatingRepository)
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun providesSetWalletWithFundsFoundUseCase(
+        appRatingRepository: AppRatingRepository,
+    ): SetWalletWithFundsFoundUseCase {
+        return SetWalletWithFundsFoundUseCase(appRatingRepository = appRatingRepository)
     }
 
     @Provides
@@ -37,4 +60,24 @@ internal object SettingsDomainModule {
             legacySettingsRepository = DefaultLegacySettingsRepository(tangemSdkManager = tangemSdkManager),
         )
     }
+
+    @Provides
+    @ViewModelScoped
+    fun providesIsBalanceHiddenUseCase(balanceHidingRepository: BalanceHidingRepository): IsBalanceHiddenUseCase {
+        return IsBalanceHiddenUseCase(
+            balanceHidingRepository = balanceHidingRepository,
+        )
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun providesListenUseCase(
+        flipDetector: DeviceFlipDetector,
+        balanceHidingRepository: BalanceHidingRepository,
+    ): ListenToFlipsUseCase {
+        return ListenToFlipsUseCase(
+            flipDetector = flipDetector,
+            balanceHidingRepository = balanceHidingRepository,
+        )
+    }
 }

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

@@ -1,9 +1,12 @@
 package com.tangem.tap.di.domain
 
+import com.tangem.domain.exchange.RampStateManager
 import com.tangem.domain.tokens.*
 import com.tangem.domain.tokens.repository.CurrenciesRepository
+import com.tangem.domain.tokens.repository.MarketCryptoCurrencyRepository
 import com.tangem.domain.tokens.repository.NetworksRepository
 import com.tangem.domain.tokens.repository.QuotesRepository
+import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.Module
 import dagger.Provides
@@ -13,6 +16,7 @@ import dagger.hilt.android.scopes.ViewModelScoped
 
 @Module
 @InstallIn(ViewModelComponent::class)
+@Suppress("TooManyFunctions")
 internal object TokensDomainModule {
 
     @Provides
@@ -25,6 +29,14 @@ internal object TokensDomainModule {
         return FetchTokenListUseCase(currenciesRepository, networksRepository, quotesRepository)
     }
 
+    @Provides
+    @ViewModelScoped
+    fun provideFetchPendingTransactionsUseCase(
+        networksRepository: NetworksRepository,
+    ): FetchPendingTransactionsUseCase {
+        return FetchPendingTransactionsUseCase(networksRepository)
+    }
+
     @Provides
     @ViewModelScoped
     fun provideGetTokenListUseCase(
@@ -36,13 +48,24 @@ internal object TokensDomainModule {
         return GetTokenListUseCase(currenciesRepository, quotesRepository, networksRepository, dispatchers)
     }
 
+    @Provides
+    @ViewModelScoped
+    fun provideGetCardTokensListUseCase(
+        currenciesRepository: CurrenciesRepository,
+        quotesRepository: QuotesRepository,
+        networksRepository: NetworksRepository,
+        dispatchers: CoroutineDispatcherProvider,
+    ): GetCardTokensListUseCase {
+        return GetCardTokensListUseCase(currenciesRepository, quotesRepository, networksRepository, dispatchers)
+    }
+
     @Provides
     @ViewModelScoped
     fun provideRemoveCurrencyUseCase(
         currenciesRepository: CurrenciesRepository,
-        dispatchers: CoroutineDispatcherProvider,
+        walletManagersFacade: WalletManagersFacade,
     ): RemoveCurrencyUseCase {
-        return RemoveCurrencyUseCase(currenciesRepository, dispatchers)
+        return RemoveCurrencyUseCase(currenciesRepository, walletManagersFacade)
     }
 
     @Provides
@@ -56,6 +79,24 @@ internal object TokensDomainModule {
         return GetCurrencyStatusUpdatesUseCase(currenciesRepository, quotesRepository, networksRepository, dispatchers)
     }
 
+    @Provides
+    @ViewModelScoped
+    fun provideGetCurrencyWarningsUseCase(
+        walletManagersFacade: WalletManagersFacade,
+        currenciesRepository: CurrenciesRepository,
+        quotesRepository: QuotesRepository,
+        networksRepository: NetworksRepository,
+        dispatchers: CoroutineDispatcherProvider,
+    ): GetCurrencyWarningsUseCase {
+        return GetCurrencyWarningsUseCase(
+            walletManagersFacade = walletManagersFacade,
+            currenciesRepository = currenciesRepository,
+            quotesRepository = quotesRepository,
+            networksRepository = networksRepository,
+            dispatchers = dispatchers,
+        )
+    }
+
     @Provides
     @ViewModelScoped
     fun provideGetPrimaryCurrencyUseCase(
@@ -82,6 +123,22 @@ internal object TokensDomainModule {
         return FetchCurrencyStatusUseCase(currenciesRepository, networksRepository, quotesRepository)
     }
 
+    @Provides
+    @ViewModelScoped
+    fun provideFetchCardTokenListUseCase(
+        currenciesRepository: CurrenciesRepository,
+        quotesRepository: QuotesRepository,
+        networksRepository: NetworksRepository,
+    ): FetchCardTokenListUseCase {
+        return FetchCardTokenListUseCase(currenciesRepository, networksRepository, quotesRepository)
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun provideGetCryptoCurrencyUseCase(currenciesRepository: CurrenciesRepository): GetCryptoCurrencyUseCase {
+        return GetCryptoCurrencyUseCase(currenciesRepository)
+    }
+
     @Provides
     @ViewModelScoped
     fun provideToggleTokenListGroupingUseCase(
@@ -108,8 +165,70 @@ internal object TokensDomainModule {
     @Provides
     @ViewModelScoped
     fun provideGetCryptoCurrencyActionsUseCase(
+        rampStateManager: RampStateManager,
+        marketCryptoCurrencyRepository: MarketCryptoCurrencyRepository,
+        currenciesRepository: CurrenciesRepository,
+        quotesRepository: QuotesRepository,
+        networksRepository: NetworksRepository,
         dispatchers: CoroutineDispatcherProvider,
     ): GetCryptoCurrencyActionsUseCase {
-        return GetCryptoCurrencyActionsUseCase(dispatchers)
+        return GetCryptoCurrencyActionsUseCase(
+            rampManager = rampStateManager,
+            marketCryptoCurrencyRepository = marketCryptoCurrencyRepository,
+            currenciesRepository = currenciesRepository,
+            quotesRepository = quotesRepository,
+            networksRepository = networksRepository,
+            dispatchers = dispatchers,
+        )
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun provideGetCurrencyStatusByNetworkUseCase(
+        currenciesRepository: CurrenciesRepository,
+        quotesRepository: QuotesRepository,
+        networksRepository: NetworksRepository,
+        dispatchers: CoroutineDispatcherProvider,
+    ): GetNetworkCoinStatusUseCase {
+        return GetNetworkCoinStatusUseCase(
+            currenciesRepository = currenciesRepository,
+            quotesRepository = quotesRepository,
+            networksRepository = networksRepository,
+            dispatchers = dispatchers,
+        )
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun provideGetCurrenciesUseCase(currenciesRepository: CurrenciesRepository): GetCryptoCurrenciesUseCase {
+        return GetCryptoCurrenciesUseCase(currenciesRepository = currenciesRepository)
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun provideIsCryptoCurrencyCoinCouldHideUseCase(
+        currenciesRepository: CurrenciesRepository,
+    ): IsCryptoCurrencyCoinCouldHideUseCase {
+        return IsCryptoCurrencyCoinCouldHideUseCase(
+            currenciesRepository = currenciesRepository,
+        )
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun provideUpdateDelayedCurrencyStatusUseCase(
+        networksRepository: NetworksRepository,
+    ): UpdateDelayedNetworkStatusUseCase {
+        return UpdateDelayedNetworkStatusUseCase(
+            networksRepository = networksRepository,
+        )
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun provideHasMissedAddressesCryptoCurrenciesUseCase(
+        currenciesRepository: CurrenciesRepository,
+    ): GetMissedAddressesCryptoCurrenciesUseCase {
+        return GetMissedAddressesCryptoCurrenciesUseCase(currenciesRepository = currenciesRepository)
     }
 }

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

@@ -2,6 +2,7 @@ package com.tangem.tap.di.domain
 
 import com.tangem.domain.tokens.*
 import com.tangem.domain.txhistory.repository.TxHistoryRepository
+import com.tangem.domain.txhistory.usecase.GetExplorerTransactionUrlUseCase
 import com.tangem.domain.txhistory.usecase.GetTxHistoryItemsCountUseCase
 import com.tangem.domain.txhistory.usecase.GetTxHistoryItemsUseCase
 import dagger.Module
@@ -25,4 +26,12 @@ internal object TxHistoryDomainModule {
     fun provideGetTxHistoryItemsUseCase(txHistoryRepository: TxHistoryRepository): GetTxHistoryItemsUseCase {
         return GetTxHistoryItemsUseCase(repository = txHistoryRepository)
     }
+
+    @Provides
+    @ViewModelScoped
+    fun providesGetExplorerTransactionUrlUseCase(
+        txHistoryRepository: TxHistoryRepository,
+    ): GetExplorerTransactionUrlUseCase {
+        return GetExplorerTransactionUrlUseCase(repository = txHistoryRepository)
+    }
 }

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

@@ -1,6 +1,9 @@
 package com.tangem.tap.di.domain
 
+import com.squareup.moshi.Moshi
+import com.tangem.datasource.asset.AssetReader
 import com.tangem.datasource.config.ConfigManager
+import com.tangem.datasource.di.SdkMoshi
 import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.datasource.local.walletmanager.WalletManagersStore
 import com.tangem.domain.walletmanager.DefaultWalletManagersFacade
@@ -21,7 +24,15 @@ internal object WalletManagersFacadeModule {
         walletManagersStore: WalletManagersStore,
         userWalletsStore: UserWalletsStore,
         configManager: ConfigManager,
+        assetReader: AssetReader,
+        @SdkMoshi moshi: Moshi,
     ): WalletManagersFacade {
-        return DefaultWalletManagersFacade(walletManagersStore, userWalletsStore, configManager)
+        return DefaultWalletManagersFacade(
+            walletManagersStore = walletManagersStore,
+            userWalletsStore = userWalletsStore,
+            configManager = configManager,
+            assetReader = assetReader,
+            moshi = moshi,
+        )
     }
 }

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

@@ -1,5 +1,6 @@
 package com.tangem.tap.di.domain
 
+import com.tangem.domain.redux.ReduxStateHolder
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.legacy.WalletsStateHolder
 import com.tangem.domain.wallets.repository.WalletsRepository
@@ -20,6 +21,18 @@ internal object WalletsDomainModule {
         return GetWalletsUseCase(walletsStateHolder = walletsStateHolder)
     }
 
+    @Provides
+    @ViewModelScoped
+    fun providesGetUserWalletUseCase(walletsStateHolder: WalletsStateHolder): GetUserWalletUseCase {
+        return GetUserWalletUseCase(walletsStateHolder = walletsStateHolder)
+    }
+
+    @Provides
+    @ViewModelScoped
+    fun providesGetSelectedWalletSyncUseCase(walletsStateHolder: WalletsStateHolder): GetSelectedWalletSyncUseCase {
+        return GetSelectedWalletSyncUseCase(walletsStateHolder = walletsStateHolder)
+    }
+
     @Provides
     @ViewModelScoped
     fun providesGetSelectedWalletUseCase(walletsStateHolder: WalletsStateHolder): GetSelectedWalletUseCase {
@@ -46,8 +59,11 @@ internal object WalletsDomainModule {
 
     @Provides
     @ViewModelScoped
-    fun providesSelectWalletUseCase(walletsStateHolder: WalletsStateHolder): SelectWalletUseCase {
-        return SelectWalletUseCase(walletsStateHolder = walletsStateHolder)
+    fun providesSelectWalletUseCase(
+        walletsStateHolder: WalletsStateHolder,
+        reduxStateHolder: ReduxStateHolder,
+    ): SelectWalletUseCase {
+        return SelectWalletUseCase(walletsStateHolder, reduxStateHolder)
     }
 
     @Provides
@@ -62,6 +78,14 @@ internal object WalletsDomainModule {
         return DeleteWalletUseCase(walletsStateHolder = walletsStateHolder)
     }
 
+    @Provides
+    @ViewModelScoped
+    fun providesShouldSaveUserWalletsSyncUseCase(
+        walletsRepository: WalletsRepository,
+    ): ShouldSaveUserWalletsSyncUseCase {
+        return ShouldSaveUserWalletsSyncUseCase(walletsRepository = walletsRepository)
+    }
+
     @Provides
     @ViewModelScoped
     fun providesShouldSaveUserWalletsUseCase(walletsRepository: WalletsRepository): ShouldSaveUserWalletsUseCase {

app/src/main/java/com/tangem/tap/domain/RatesRepository.kt

@@ -1,74 +0,0 @@
-package com.tangem.tap.domain
-
-import com.tangem.common.services.Result
-import com.tangem.datasource.api.tangemTech.TangemTechApi
-import com.tangem.domain.common.ThrottlerWithValues
-import com.tangem.tap.features.wallet.models.Currency
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.coroutines.withContext
-import java.math.BigDecimal
-
-class RatesRepository(
-    private val tangemTechApi: TangemTechApi,
-    private val dispatchers: CoroutineDispatcherProvider,
-) {
-    private val throttler = ThrottlerWithValues<Currency, Result<BigDecimal>?>(60000)
-
-    suspend fun loadFiatRate(currencyId: String, coinsList: List<Currency>): Result<RatesResult> =
-        withContext(dispatchers.io) {
-            // get and submit previous result of equivalents.
-            val throttledResult = coinsList.filter { throttler.isStillThrottled(it) }.map {
-                Pair(it, throttler.geValue(it))
-            }
-
-            val currenciesToUpdate = coinsList.filter { !throttler.isStillThrottled(it) }
-            val coinIds = currenciesToUpdate.mapNotNull { it.coinId }.distinct()
-            if (coinIds.isEmpty()) return@withContext handleFiatRatesResult(throttledResult.toMap())
-
-            runCatching { tangemTechApi.getRates(currencyId.lowercase(), coinIds.joinToString(",")) }
-                .onSuccess { response ->
-                    val ratesResultList: Map<String, Result<BigDecimal>> = response.rates.mapValues {
-                        Result.Success(it.value.toBigDecimal())
-                    }
-                    val updatedCurrencies = throttledResult.toMap().toMutableMap()
-                    coinsList.forEach { currency ->
-                        ratesResultList[currency.coinId]?.let {
-                            updatedCurrencies[currency] = it
-                            throttler.updateThrottlingTo(currency)
-                            throttler.setValue(currency, it)
-                        }
-                    }
-                    return@withContext handleFiatRatesResult(updatedCurrencies)
-                }
-                .onFailure { Result.Failure(it) }
-
-            error("Unreachable code because runCatching must return result")
-        }
-
-    private fun handleFiatRatesResult(rates: Map<Currency, Result<BigDecimal>?>): Result.Success<RatesResult> {
-        val success = mutableMapOf<Currency, BigDecimal>()
-        val failures = mutableMapOf<Currency, Throwable>()
-
-        rates.mapNotNull { (currency, priceResult) ->
-            when (priceResult) {
-                is Result.Success -> success[currency] = priceResult.data
-                is Result.Failure -> failures[currency] = priceResult.error
-                else -> null
-            }
-        }
-
-        return Result.Success(success to failures)
-    }
-
-    fun clear() {
-        throttler.clear()
-    }
-}
-
-typealias RatesResult = Pair<MutableMap<Currency, BigDecimal>, MutableMap<Currency, Throwable>>
-
-val RatesResult.loadedRates
-    get() = this.first
-
-val RatesResult.failedRates
-    get() = this.second

app/src/main/java/com/tangem/tap/domain/TangemSdkManager.kt

@@ -5,12 +5,12 @@ import androidx.annotation.DrawableRes
 import androidx.annotation.StringRes
 import com.tangem.Message
 import com.tangem.TangemSdk
-import com.tangem.blockchain.common.Blockchain
 import com.tangem.common.*
-import com.tangem.common.biometric.BiometricManager
+import com.tangem.common.authentication.KeystoreManager
 import com.tangem.common.card.FirmwareVersion
 import com.tangem.common.core.*
 import com.tangem.common.extensions.ByteArrayKey
+import com.tangem.common.services.secure.SecureStorage
 import com.tangem.common.usersCode.UserCodeRepository
 import com.tangem.core.analytics.Analytics
 import com.tangem.crypto.bip39.DefaultMnemonic
@@ -26,12 +26,12 @@ import com.tangem.operations.derivation.DeriveMultipleWalletPublicKeysTask
 import com.tangem.operations.pins.SetUserCodeCommand
 import com.tangem.operations.usersetttings.SetUserCodeRecoveryAllowedTask
 import com.tangem.tap.common.analytics.events.Basic
+import com.tangem.tap.derivationsFinder
 import com.tangem.tap.domain.tasks.CreateWalletAndRescanTask
 import com.tangem.tap.domain.tasks.product.CreateProductWalletTask
 import com.tangem.tap.domain.tasks.product.CreateProductWalletTaskResponse
 import com.tangem.tap.domain.tasks.product.ResetToFactorySettingsTask
 import com.tangem.tap.domain.tasks.product.ScanProductTask
-import com.tangem.tap.domain.tokens.UserTokensRepository
 import com.tangem.wallet.R
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.suspendCancellableCoroutine
@@ -39,31 +39,38 @@ import kotlinx.coroutines.withContext
 import kotlin.coroutines.resume
 
 @Suppress("TooManyFunctions")
-class TangemSdkManager(private val cardSdkConfigRepository: CardSdkConfigRepository, private val resources: Resources) {
+class TangemSdkManager(
+    private val cardSdkConfigRepository: CardSdkConfigRepository,
+    private val resources: Resources,
+) {
 
     private val tangemSdk: TangemSdk
         get() = cardSdkConfigRepository.sdk
 
     private val userCodeRepository by lazy {
         UserCodeRepository(
-            biometricManager = tangemSdk.biometricManager,
+            keystoreManager = tangemSdk.keystoreManager,
             secureStorage = tangemSdk.secureStorage,
         )
     }
 
     val canUseBiometry: Boolean
-        get() = tangemSdk.biometricManager.canAuthenticate || needEnrollBiometrics
+        get() = tangemSdk.authenticationManager.canAuthenticate || needEnrollBiometrics
 
     val needEnrollBiometrics: Boolean
-        get() = tangemSdk.biometricManager.canEnrollBiometrics
+        get() = tangemSdk.authenticationManager.needEnrollBiometrics
 
-    val biometricManager: BiometricManager
-        get() = tangemSdk.biometricManager
+    val keystoreManager: KeystoreManager
+        get() = tangemSdk.keystoreManager
+
+    val secureStorage: SecureStorage
+        get() = tangemSdk.secureStorage
+
+    val userCodeRequestPolicy: UserCodeRequestPolicy
+        get() = tangemSdk.config.userCodeRequestPolicy
 
     suspend fun scanProduct(
-        userTokensRepository: UserTokensRepository,
         cardId: String? = null,
-        additionalBlockchainsToDerive: Collection<Blockchain>? = null,
         messageRes: Int? = null,
         allowsRequestAccessCodeFromRepository: Boolean = false,
     ): CompletionResult<ScanResponse> {
@@ -71,8 +78,7 @@ class TangemSdkManager(private val cardSdkConfigRepository: CardSdkConfigReposit
         return runTaskAsyncReturnOnMain(
             runnable = ScanProductTask(
                 card = null,
-                userTokensRepository = userTokensRepository,
-                additionalBlockchainsToDerive = additionalBlockchainsToDerive,
+                derivationsFinder = derivationsFinder,
                 allowsRequestAccessCodeFromRepository = allowsRequestAccessCodeFromRepository,
             ),
             cardId = cardId,
@@ -141,7 +147,9 @@ class TangemSdkManager(private val cardSdkConfigRepository: CardSdkConfigReposit
         allowsRequestAccessCodeFromRepository: Boolean,
     ): CompletionResult<CardDTO> {
         return runTaskAsyncReturnOnMain(
-            runnable = ResetToFactorySettingsTask(allowsRequestAccessCodeFromRepository),
+            runnable = ResetToFactorySettingsTask(
+                allowsRequestAccessCodeFromRepository = allowsRequestAccessCodeFromRepository,
+            ),
             cardId = cardId,
             initialMessage = Message(resources.getString(R.string.card_settings_reset_card_to_factory)),
         )
@@ -247,17 +255,8 @@ class TangemSdkManager(private val cardSdkConfigRepository: CardSdkConfigReposit
         return resources.getString(stringResId, *formatArgs)
     }
 
-    fun setAccessCodeRequestPolicy(useBiometricsForAccessCode: Boolean) {
-        tangemSdk.config.userCodeRequestPolicy = if (useBiometricsForAccessCode) {
-            UserCodeRequestPolicy.AlwaysWithBiometrics(codeType = UserCodeType.AccessCode)
-        } else {
-            UserCodeRequestPolicy.Default
-        }
-    }
-
-    fun useBiometricsForAccessCode(): Boolean {
-        val policy = tangemSdk.config.userCodeRequestPolicy
-        return policy is UserCodeRequestPolicy.AlwaysWithBiometrics && policy.codeType == UserCodeType.AccessCode
+    fun setUserCodeRequestPolicy(policy: UserCodeRequestPolicy) {
+        tangemSdk.config.userCodeRequestPolicy = policy
     }
 
     companion object {

app/src/main/java/com/tangem/tap/domain/TapWalletManager.kt

@@ -19,6 +19,7 @@ import com.tangem.tap.common.analytics.events.Basic
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.extensions.dispatchWithMain
 import com.tangem.tap.common.extensions.setContext
+import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.domain.walletStores.WalletStoresError
 import com.tangem.tap.domain.walletconnect2.domain.WalletConnectInteractor
@@ -28,11 +29,13 @@ import com.tangem.tap.features.disclaimer.createDisclaimer
 import com.tangem.tap.features.disclaimer.redux.DisclaimerAction
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsAction
 import com.tangem.tap.features.wallet.redux.WalletAction
+import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.utils.coroutines.AppCoroutineDispatcherProvider
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
+import org.rekotlin.Store
 import timber.log.Timber
 
 class TapWalletManager(
@@ -75,17 +78,34 @@ class TapWalletManager(
         withMainContext {
             // Order is important
             store.dispatch(DisclaimerAction.SetDisclaimer(card.createDisclaimer()))
-            store.dispatch(WalletAction.UserWalletChanged(userWallet))
-            store.dispatch(WalletAction.UpdateCanSaveUserWallets(preferencesStorage.shouldSaveUserWallets))
+            store.dispatchWalletAction(action = WalletAction.UserWalletChanged(userWallet))
+            store.dispatchWalletAction(
+                action = WalletAction.UpdateCanSaveUserWallets(
+                    canSaveUserWallets = store.state.daggerGraphState.get(DaggerGraphState::walletsRepository)
+                        .shouldSaveUserWalletsSync(),
+                ),
+            )
             store.dispatch(TwinCardsAction.IfTwinsPrepareState(scanResponse))
             store.dispatch(WalletConnectAction.ResetState)
             store.dispatch(GlobalAction.SaveScanResponse(scanResponse))
             store.dispatch(WalletConnectAction.RestoreSessions(scanResponse))
             store.dispatch(GlobalAction.SetIfCardVerifiedOnline(!attestationFailed))
-            store.dispatch(WalletAction.Warnings.CheckIfNeeded)
+            store.dispatchWalletAction(action = WalletAction.Warnings.CheckIfNeeded)
+        }
+
+        val walletFeatureToggles = store.state.daggerGraphState.get(DaggerGraphState::walletFeatureToggles)
+        if (!walletFeatureToggles.isRedesignedScreenEnabled) {
+            setupWalletConnectV2(userWallet)
+            loadData(userWallet = userWallet, refresh = refresh)
+        }
+    }
+
+    private fun Store<AppState>.dispatchWalletAction(action: WalletAction) {
+        val walletFeatureToggles = state.daggerGraphState.get(DaggerGraphState::walletFeatureToggles)
+
+        if (!walletFeatureToggles.isRedesignedScreenEnabled) {
+            dispatch(action = action)
         }
-        setupWalletConnectV2(userWallet)
-        loadData(userWallet, refresh)
     }
 
     private fun setupWalletConnectV2(userWallet: UserWallet) {
@@ -142,21 +162,31 @@ class TapWalletManager(
             }
     }
 
-    private fun getAccountsForWc(wcInteractor: WalletConnectInteractor): List<Account> {
-        return store.state.walletState.walletManagers
-            .mapNotNull {
-                val wallet = it.wallet
-                val chainId = wcInteractor.blockchainHelper.networkIdToChainIdOrNull(
-                    wallet.blockchain.toNetworkId(),
+    private suspend fun getAccountsForWc(wcInteractor: WalletConnectInteractor): List<Account> {
+        val walletManagerToggles = store.state.daggerGraphState
+            .get(DaggerGraphState::walletFeatureToggles)
+        val walletManagers = if (walletManagerToggles.isRedesignedScreenEnabled) {
+            val walletManagerFacade = store.state.daggerGraphState
+                .get(DaggerGraphState::walletManagersFacade)
+            val userWallet = userWalletsListManager.selectedUserWalletSync ?: return emptyList()
+            walletManagerFacade.getStoredWalletManagers(userWallet.walletId)
+        } else {
+            store.state.walletState.walletManagers
+        }
+
+        return walletManagers.mapNotNull {
+            val wallet = it.wallet
+            val chainId = wcInteractor.blockchainHelper.networkIdToChainIdOrNull(
+                wallet.blockchain.toNetworkId(),
+            )
+            chainId?.let {
+                Account(
+                    chainId,
+                    wallet.address,
+                    wallet.publicKey.derivationPath?.rawPath,
                 )
-                chainId?.let {
-                    Account(
-                        chainId,
-                        wallet.address,
-                        wallet.publicKey.derivationPath?.rawPath,
-                    )
-                }
             }
+        }
     }
 
     fun updateConfigManager(data: ScanResponse) {

app/src/main/java/com/tangem/tap/domain/card/DefaultDerivePublicKeysUseCase.kt

@@ -0,0 +1,29 @@
+package com.tangem.tap.domain.card
+
+import arrow.core.Either
+import arrow.core.left
+import arrow.core.right
+import com.tangem.common.doOnFailure
+import com.tangem.common.doOnSuccess
+import com.tangem.common.extensions.ByteArrayKey
+import com.tangem.crypto.hdWallet.DerivationPath
+import com.tangem.domain.card.DerivePublicKeysUseCase
+import com.tangem.operations.derivation.DerivationTaskResponse
+import com.tangem.tap.domain.TangemSdkManager
+
+// TODO: [REDACTED_JIRA]
+internal class DefaultDerivePublicKeysUseCase(
+    private val tangemSdkManager: TangemSdkManager,
+) : DerivePublicKeysUseCase {
+
+    override suspend fun invoke(
+        cardId: String?,
+        derivations: Map<ByteArrayKey, List<DerivationPath>>,
+    ): Either<Unit, DerivationTaskResponse> {
+        tangemSdkManager.derivePublicKeys(cardId = cardId, derivations = derivations)
+            .doOnSuccess { return it.right() }
+            .doOnFailure { return Unit.left() }
+
+        return Unit.left()
+    }
+}

app/src/main/java/com/tangem/tap/domain/configurable/warningMessage/WarningMessagesManager.kt

@@ -8,6 +8,8 @@ import java.util.concurrent.CopyOnWriteArrayList
 /**
 [REDACTED_AUTHOR]
  */
+// TODO: Delete with WalletFeatureToggles
+@Deprecated(message = "Used only in old wallet screen")
 class WarningMessagesManager {
 
     private val warningsList = CopyOnWriteArrayList<WarningMessage>()
@@ -73,7 +75,7 @@ class WarningMessagesManager {
             location = listOf(WarningMessage.Location.MainScreen),
             blockchains = null,
             titleResId = R.string.common_warning,
-            messageResId = R.string.alert_developer_card,
+            // messageResId = R.string.alert_developer_card,
             origin = WarningMessage.Origin.Local,
         )
 
@@ -85,7 +87,7 @@ class WarningMessagesManager {
             location = listOf(WarningMessage.Location.MainScreen),
             blockchains = null,
             titleResId = R.string.common_warning,
-            messageResId = R.string.alert_card_signed_transactions,
+            // messageResId = R.string.alert_card_signed_transactions,
             origin = WarningMessage.Origin.Local,
         )
 
@@ -96,8 +98,8 @@ class WarningMessagesManager {
             priority = WarningMessage.Priority.Info,
             location = listOf(WarningMessage.Location.MainScreen),
             blockchains = null,
-            titleResId = R.string.warning_important_security_info,
-            messageResId = R.string.warning_signed_tx_previously,
+            // titleResId = R.string.warning_important_security_info,
+            // messageResId = R.string.warning_signed_tx_previously,
             origin = WarningMessage.Origin.Local,
             buttonTextId = R.string.warning_button_learn_more,
             titleFormatArg = "\u26A0",
@@ -147,7 +149,7 @@ class WarningMessagesManager {
             location = listOf(WarningMessage.Location.MainScreen),
             blockchains = null,
             titleResId = R.string.common_warning,
-            messageResId = R.string.alert_demo_message,
+            // messageResId = R.string.alert_demo_message,
             origin = WarningMessage.Origin.Local,
         )
 
@@ -160,14 +162,14 @@ class WarningMessagesManager {
                 location = listOf(WarningMessage.Location.MainScreen),
                 blockchains = null,
                 titleResId = R.string.common_warning,
-                messageResId = R.string.warning_low_signatures_format,
+                // messageResId = R.string.warning_low_signatures_format,
                 origin = WarningMessage.Origin.Local,
                 messageFormatArg = remainingSignatures.toString(),
             )
         }
 
-        fun isAlreadySignedHashesWarning(warning: WarningMessage): Boolean {
-            return warning.messageResId == R.string.alert_card_signed_transactions
-        }
+        // fun isAlreadySignedHashesWarning(warning: WarningMessage): Boolean {
+        //     return warning.messageResId == R.string.alert_card_signed_transactions
+        // }
     }
 }

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

@@ -15,7 +15,10 @@ import com.tangem.domain.common.util.twinsIsTwinned
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.tap.*
 import com.tangem.tap.common.analytics.paramsInterceptor.CardContextInterceptor
-import com.tangem.tap.common.extensions.*
+import com.tangem.tap.common.extensions.addContext
+import com.tangem.tap.common.extensions.dispatchOnMain
+import com.tangem.tap.common.extensions.dispatchWithMain
+import com.tangem.tap.common.extensions.setContext
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.features.disclaimer.createDisclaimer
 import com.tangem.tap.features.disclaimer.redux.DisclaimerAction
@@ -23,6 +26,7 @@ import com.tangem.tap.features.disclaimer.redux.DisclaimerCallback
 import com.tangem.tap.features.onboarding.OnboardingHelper
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsAction
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsStep
+import com.tangem.utils.extensions.DELAY_SDK_DIALOG_CLOSE
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -34,8 +38,7 @@ internal object LegacyScanProcessor {
         allowsRequestAccessCodeFromRepository: Boolean = false,
     ): CompletionResult<ScanResponse> {
         return tangemSdkManager.scanProduct(
-            userTokensRepository,
-            cardId,
+            cardId = cardId,
             allowsRequestAccessCodeFromRepository = allowsRequestAccessCodeFromRepository,
         )
     }
@@ -56,10 +59,7 @@ internal object LegacyScanProcessor {
 
         tangemSdkManager.changeDisplayedCardIdNumbersCount(null)
 
-        val result = tangemSdkManager.scanProduct(
-            userTokensRepository = userTokensRepository,
-            cardId = cardId,
-        )
+        val result = tangemSdkManager.scanProduct(cardId)
 
         store.dispatchOnMain(GlobalAction.ScanFailsCounter.ChooseBehavior(result))
 

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

@@ -8,13 +8,13 @@ import com.tangem.core.navigation.AppScreen
 import com.tangem.core.navigation.NavigationAction
 import com.tangem.domain.card.ScanCardException
 import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.tap.DELAY_SDK_DIALOG_CLOSE
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.domain.scanCard.chains.*
 import com.tangem.tap.domain.scanCard.utils.ScanCardExceptionConverter
 import com.tangem.tap.preferencesStorage
 import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.store
+import com.tangem.utils.extensions.DELAY_SDK_DIALOG_CLOSE
 import kotlinx.coroutines.delay
 
 internal object UseCaseScanProcessor {

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

@@ -11,7 +11,6 @@ import com.tangem.domain.common.TapWorkarounds.canSkipBackup
 import com.tangem.domain.common.util.twinsIsTwinned
 import com.tangem.domain.core.chain.Chain
 import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.tap.DELAY_SDK_DIALOG_CLOSE
 import com.tangem.tap.common.extensions.addContext
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.extensions.setContext
@@ -21,6 +20,7 @@ import com.tangem.tap.domain.TapWalletManager
 import com.tangem.tap.features.onboarding.OnboardingHelper
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsAction
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsStep
+import com.tangem.utils.extensions.DELAY_SDK_DIALOG_CLOSE
 import kotlinx.coroutines.delay
 import org.rekotlin.Store
 

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

@@ -8,13 +8,8 @@ import com.tangem.domain.card.repository.ScanCardRepository
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.tap.domain.TangemSdkManager
 import com.tangem.tap.domain.scanCard.utils.ScanCardExceptionConverter
-import com.tangem.tap.domain.tokens.UserTokensRepository
 
 internal class DefaultScanCardRepository(
-    // FIXME: The repository should not depend on another repository.
-    //  But now we need to provide loadBlockchainsToDerive() to ScanProductTask and it's hard to move this method from
-    //  UserTokensRepository.
-    private val userTokensRepository: UserTokensRepository,
     private val tangemSdkManager: TangemSdkManager,
 ) : ScanCardRepository {
 
@@ -27,7 +22,6 @@ internal class DefaultScanCardRepository(
         when (
             val result = tangemSdkManager.scanProduct(
                 cardId = cardId,
-                userTokensRepository = userTokensRepository,
                 allowsRequestAccessCodeFromRepository = allowRequestAccessCodeFromStorage,
             )
         ) {

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

@@ -303,7 +303,7 @@ private class CreateWalletTangemWallet(
 
     private fun getBlockchains(cardId: String, card: CardDTO): List<Blockchain> {
         return when {
-            DemoHelper.isDemoCardId(cardId) -> DemoHelper.config.demoBlockchains
+            DemoHelper.isDemoCardId(cardId) -> DemoHelper.config.demoBlockchains.toList()
             card.isTestCard -> listOf(Blockchain.BitcoinTestnet, Blockchain.EthereumTestnet)
             else -> listOf(Blockchain.Bitcoin, Blockchain.Ethereum)
         }

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

@@ -0,0 +1,159 @@
+package com.tangem.tap.domain.tasks.product
+
+import com.tangem.blockchain.blockchains.cardano.CardanoUtils
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.derivation.DerivationStyle
+import com.tangem.crypto.hdWallet.DerivationPath
+import com.tangem.datasource.local.token.UserTokensStore
+import com.tangem.domain.common.DerivationStyleProvider
+import com.tangem.domain.common.TapWorkarounds.useOldStyleDerivation
+import com.tangem.domain.common.extensions.fromNetworkId
+import com.tangem.domain.models.scan.CardDTO
+import com.tangem.domain.userwallets.UserWalletIdBuilder
+import com.tangem.domain.wallets.models.UserWalletId
+import com.tangem.features.wallet.featuretoggles.WalletFeatureToggles
+import com.tangem.tap.domain.tokens.UserTokensStorageService
+import com.tangem.tap.features.demo.DemoHelper
+import com.tangem.tap.features.wallet.models.Currency
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import kotlinx.coroutines.withContext
+
+internal data class BlockchainToDerive(
+    val blockchain: Blockchain,
+    val derivationPath: DerivationPath?,
+)
+
+// FIXME: May be move to DI, currently unnecessary
+internal class DerivationsFinder(
+    private val legacyTokensStore: UserTokensStorageService,
+    private val newTokensStore: UserTokensStore,
+    private val walletFeatureToggles: WalletFeatureToggles,
+    private val dispatchers: CoroutineDispatcherProvider,
+) {
+
+    suspend fun findBlockchainsToDerive(
+        card: CardDTO,
+        derivationStyleProvider: DerivationStyleProvider,
+    ): Set<BlockchainToDerive> {
+        if (!card.settings.isHDWalletAllowed || card.wallets.isEmpty()) return emptySet()
+        val userWalletId = UserWalletIdBuilder.card(card).build() ?: return emptySet()
+        val derivationStyle = derivationStyleProvider.getDerivationStyle()
+
+        var blockchains = withContext(dispatchers.io) {
+            if (walletFeatureToggles.isRedesignedScreenEnabled) {
+                getBlockchainsNew(userWalletId)
+            } else {
+                getBlockchainsLegacy(userWalletId)
+            }
+        }
+
+        if (blockchains.isEmpty()) {
+            blockchains = if (DemoHelper.isDemoCardId(card.cardId)) {
+                getDemoBlockchains(derivationStyle)
+            } else {
+                getDefaultBlockchains(derivationStyle)
+            }
+        }
+
+        // we should generate second key for cardano
+        // because cardano address generation for wallet2 requires keys from 2 derivations
+        // https://developers.cardano.org/docs/get-started/cardano-serialization-lib/generating-keys/
+        blockchains.addSecondCardanoDerivationIfPresent()
+
+        if (card.settings.isHDWalletAllowed) {
+            blockchains.addEthereumBlockchains(derivationStyle)
+        }
+
+        // pay attention to this
+        if (!card.useOldStyleDerivation) {
+            blockchains.removeUnnecessaryBlockchains()
+        }
+
+        return blockchains
+    }
+
+    private suspend fun getBlockchainsNew(userWalletId: UserWalletId): MutableSet<BlockchainToDerive> {
+        val responseTokens = newTokensStore.getSyncOrNull(userWalletId)
+            ?.tokens
+            ?: return hashSetOf()
+
+        return responseTokens.asSequence()
+            .filter { it.contractAddress == null }
+            .mapNotNull { coin ->
+                val blockchain = Blockchain.fromNetworkId(coin.networkId) ?: return@mapNotNull null
+                val derivationPath = coin.derivationPath?.let(::DerivationPath)
+
+                BlockchainToDerive(blockchain, derivationPath)
+            }
+            .toMutableSet()
+    }
+
+    private fun getBlockchainsLegacy(userWalletId: UserWalletId): MutableSet<BlockchainToDerive> {
+        val currencies = legacyTokensStore.getUserTokens(userWalletId.stringValue)
+            ?.takeIf { it.isNotEmpty() }
+            ?: return hashSetOf()
+
+        return currencies.asSequence()
+            .filterIsInstance<Currency.Blockchain>()
+            .map { coin ->
+                val blockchain = coin.blockchain
+                val derivationPath = coin.derivationPath?.let(::DerivationPath)
+
+                BlockchainToDerive(blockchain, derivationPath)
+            }
+            .toMutableSet()
+    }
+
+    // TODO: Move to user wallet config
+    private fun getDemoBlockchains(derivationStyle: DerivationStyle?): MutableSet<BlockchainToDerive> {
+        return DemoHelper.config.demoBlockchains.mapToBlockchainsWithDerivations(derivationStyle)
+    }
+
+    // TODO: Move to user wallet config
+    private fun getDefaultBlockchains(derivationStyle: DerivationStyle?): MutableSet<BlockchainToDerive> {
+        val defaultBlockchains = setOf(Blockchain.Bitcoin, Blockchain.Ethereum)
+
+        return defaultBlockchains.mapToBlockchainsWithDerivations(derivationStyle)
+    }
+}
+
+private fun MutableSet<BlockchainToDerive>.addEthereumBlockchains(derivationStyle: DerivationStyle?) {
+    val ethereumBlockchains = setOf(Blockchain.Ethereum, Blockchain.EthereumTestnet)
+        .mapToBlockchainsWithDerivations(derivationStyle)
+
+    addAll(ethereumBlockchains)
+}
+
+private fun MutableSet<BlockchainToDerive>.removeUnnecessaryBlockchains() {
+    val unnecessaryBlockchains = listOf(
+        Blockchain.BSC, Blockchain.BSCTestnet,
+        Blockchain.Polygon, Blockchain.PolygonTestnet,
+        Blockchain.RSK,
+        Blockchain.Fantom, Blockchain.FantomTestnet,
+        Blockchain.Avalanche, Blockchain.AvalancheTestnet,
+    )
+
+    removeAll { it.blockchain in unnecessaryBlockchains }
+}
+
+private fun MutableSet<BlockchainToDerive>.addSecondCardanoDerivationIfPresent() {
+    val cardanoDerivation = this
+        .firstOrNull { it.blockchain == Blockchain.Cardano }
+        ?.derivationPath
+        ?: return
+
+    val secondCardanoBlockchain = BlockchainToDerive(
+        blockchain = Blockchain.Cardano,
+        derivationPath = CardanoUtils.extendedDerivationPath(cardanoDerivation),
+    )
+
+    add(secondCardanoBlockchain)
+}
+
+private fun Set<Blockchain>.mapToBlockchainsWithDerivations(
+    derivationStyle: DerivationStyle?,
+): MutableSet<BlockchainToDerive> {
+    return mapTo(hashSetOf()) { blockchain ->
+        BlockchainToDerive(blockchain, blockchain.derivationPath(derivationStyle))
+    }
+}

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

@@ -1,7 +1,5 @@
 package com.tangem.tap.domain.tasks.product
 
-import com.tangem.blockchain.blockchains.cardano.CardanoUtils
-import com.tangem.blockchain.common.Blockchain
 import com.tangem.common.CompletionResult
 import com.tangem.common.card.Card
 import com.tangem.common.card.FirmwareVersion
@@ -15,13 +13,11 @@ import com.tangem.common.tlv.Tlv
 import com.tangem.common.tlv.TlvDecoder
 import com.tangem.crypto.CryptoUtils
 import com.tangem.crypto.hdWallet.DerivationPath
-import com.tangem.domain.common.BlockchainNetwork
 import com.tangem.domain.common.DerivationStyleProvider
 import com.tangem.domain.common.TapWorkarounds.isExcluded
 import com.tangem.domain.common.TapWorkarounds.isNotSupportedInThatRelease
 import com.tangem.domain.common.TapWorkarounds.isStart2Coin
 import com.tangem.domain.common.TapWorkarounds.isTangemTwins
-import com.tangem.domain.common.TapWorkarounds.useOldStyleDerivation
 import com.tangem.domain.common.TwinsHelper
 import com.tangem.domain.common.configs.CardConfig
 import com.tangem.domain.common.util.derivationStyleProvider
@@ -35,16 +31,14 @@ import com.tangem.operations.derivation.DeriveMultipleWalletPublicKeysTask
 import com.tangem.operations.files.ReadFilesTask
 import com.tangem.operations.issuerAndUserData.ReadIssuerDataCommand
 import com.tangem.tap.domain.TapSdkError
-import com.tangem.tap.domain.tokens.UserTokensRepository
 import com.tangem.tap.preferencesStorage
 import com.tangem.tap.scope
 import kotlinx.coroutines.launch
 import kotlin.collections.set
 
-class ScanProductTask(
-    val card: Card? = null,
-    private val userTokensRepository: UserTokensRepository?,
-    private val additionalBlockchainsToDerive: Collection<Blockchain>? = null,
+internal class ScanProductTask(
+    private val card: Card?,
+    private val derivationsFinder: DerivationsFinder?,
     override val allowsRequestAccessCodeFromRepository: Boolean = false,
 ) : CardSessionRunnable<ScanResponse> {
 
@@ -63,14 +57,14 @@ class ScanProductTask(
 
         val commandProcessor = when {
             cardDto.isTangemTwins -> ScanTwinProcessor()
-            else -> ScanWalletProcessor(userTokensRepository, additionalBlockchainsToDerive)
+            else -> ScanWalletProcessor(derivationsFinder)
         }
         commandProcessor.proceed(cardDto, session) { processorResult ->
             when (processorResult) {
                 is CompletionResult.Success -> ScanTask().run(session) { scanTaskResult ->
                     when (scanTaskResult) {
                         is CompletionResult.Success -> {
-                            // it need because processorResult.data.card doesn't contains attestation result
+                            // it needed because processorResult.data.card doesn't contains attestation result
                             // and CardWallet.derivedKeys
                             val processorScanResponseWithNewCard = processorResult.data.copy(
                                 card = CardDTO(scanTaskResult.data),
@@ -99,8 +93,7 @@ class ScanProductTask(
 }
 
 private class ScanWalletProcessor(
-    private val userTokensRepository: UserTokensRepository?,
-    private val additionalBlockchainsToDerive: Collection<Blockchain>? = null,
+    private val derivationsFinder: DerivationsFinder?,
 ) : ProductCommandProcessor<ScanResponse> {
 
     var primaryCard: PrimaryCard? = null
@@ -244,131 +237,28 @@ private class ScanWalletProcessor(
         }
     }
 
-    private suspend fun getBlockchainsToDerive(
-        card: CardDTO,
-        derivationStyleProvider: DerivationStyleProvider,
-    ): List<BlockchainNetwork> {
-        val userTokensRepository = userTokensRepository ?: return emptyList()
-        val blockchainsToDerive = userTokensRepository.loadBlockchainsToDerive(
-            card,
-            derivationStyleProvider.getDerivationStyle(),
-        )
-            .toMutableList()
-            .ifEmpty { getDefaultBlockchains(derivationStyleProvider) }
-
-        if (card.settings.isHDWalletAllowed) {
-            blockchainsToDerive += getEthereumBlockchains(derivationStyleProvider)
-        }
-
-        additionalBlockchainsToDerive?.let {
-            blockchainsToDerive += getAdditionalBlockchainToDerive(derivationStyleProvider, it)
-        }
-
-        // we should generate second key for cardano
-        // because cardano address generation for wallet2 requires keys from 2 derivations
-        // https://developers.cardano.org/docs/get-started/cardano-serialization-lib/generating-keys/
-        val secondCardanoNetwork = blockchainsToDerive
-            .find { it.blockchain == Blockchain.Cardano }
-            ?.let { getCardanoSecondNetwork(it) }
-        secondCardanoNetwork?.let { blockchainsToDerive.add(it) }
-
-        // pay attention to this
-        if (!card.useOldStyleDerivation) {
-            removeUnnecessaryBlockchains(blockchainsToDerive, derivationStyleProvider)
-        }
-
-        return blockchainsToDerive.distinct()
-    }
-
     private fun getWalletProductType(card: CardDTO): ProductType {
         if (card.batchId == CardDTO.RING_BATCH_ID) {
             return ProductType.Ring
         }
-        return if (card.firmwareVersion >= FirmwareVersion.Ed25519Slip0010Available) {
+        return if (card.firmwareVersion >= FirmwareVersion.Ed25519Slip0010Available &&
+            card.settings.isKeysImportAllowed
+        ) {
             ProductType.Wallet2
         } else {
             ProductType.Wallet
         }
     }
 
-    private fun getDefaultBlockchains(
-        derivationStyleProvider: DerivationStyleProvider,
-    ): MutableList<BlockchainNetwork> {
-        return mutableListOf(
-            BlockchainNetwork(
-                blockchain = Blockchain.Bitcoin,
-                derivationStyleProvider = derivationStyleProvider,
-            ),
-            BlockchainNetwork(
-                blockchain = Blockchain.Ethereum,
-                derivationStyleProvider = derivationStyleProvider,
-            ),
-        )
-    }
-
-    private fun getEthereumBlockchains(derivationStyleProvider: DerivationStyleProvider): List<BlockchainNetwork> {
-        return listOf(
-            BlockchainNetwork(
-                blockchain = Blockchain.Ethereum,
-                derivationStyleProvider = derivationStyleProvider,
-            ),
-            BlockchainNetwork(
-                blockchain = Blockchain.EthereumTestnet,
-                derivationStyleProvider = derivationStyleProvider,
-            ),
-        )
-    }
-
-    private fun getAdditionalBlockchainToDerive(
-        derivationStyleProvider: DerivationStyleProvider,
-        collection: Collection<Blockchain>,
-    ): List<BlockchainNetwork> {
-        return collection.map {
-            BlockchainNetwork(
-                blockchain = it,
-                derivationStyleProvider = derivationStyleProvider,
-            )
-        }
-    }
-
-    private fun getCardanoSecondNetwork(cardanoBlockchainNetwork: BlockchainNetwork): BlockchainNetwork? {
-        val cardanoStandardDerivation = cardanoBlockchainNetwork.derivationPath?.let { DerivationPath(it) }
-            ?: return null
-        val cardanoPatchedDerivation = CardanoUtils.extendedDerivationPath(cardanoStandardDerivation)
-        return BlockchainNetwork(
-            blockchain = Blockchain.Cardano,
-            derivationPath = cardanoPatchedDerivation.rawPath,
-            tokens = emptyList(),
-        )
-    }
-
-    private fun removeUnnecessaryBlockchains(
-        blockchainsToDerive: MutableList<BlockchainNetwork>,
-        derivationStyleProvider: DerivationStyleProvider,
-    ) {
-        blockchainsToDerive.removeAll(
-            listOf(
-                Blockchain.BSC, Blockchain.BSCTestnet,
-                Blockchain.Polygon, Blockchain.PolygonTestnet,
-                Blockchain.RSK,
-                Blockchain.Fantom, Blockchain.FantomTestnet,
-                Blockchain.Avalanche, Blockchain.AvalancheTestnet,
-            ).map {
-                BlockchainNetwork(
-                    blockchain = it,
-                    derivationStyleProvider = derivationStyleProvider,
-                )
-            },
-        )
-    }
-
     private suspend fun collectDerivations(
         card: CardDTO,
         config: CardConfig,
         derivationStyleProvider: DerivationStyleProvider,
     ): Map<ByteArrayKey, List<DerivationPath>> {
-        val blockchains = getBlockchainsToDerive(card, derivationStyleProvider)
         val derivations = mutableMapOf<ByteArrayKey, List<DerivationPath>>()
+        val blockchains = derivationsFinder
+            ?.findBlockchainsToDerive(card, derivationStyleProvider)
+            ?: return derivations
 
         blockchains.forEach { blockchain ->
             val curve = config.primaryCurve(blockchain.blockchain)
@@ -376,7 +266,7 @@ private class ScanWalletProcessor(
             if (wallet.chainCode == null) return@forEach
 
             val key = wallet.publicKey.toMapKey()
-            val path = blockchain.derivationPath?.let { DerivationPath(it) }
+            val path = blockchain.derivationPath
             if (path != null) {
                 val addedDerivations = derivations[key]
                 if (addedDerivations != null) {
@@ -386,6 +276,7 @@ private class ScanWalletProcessor(
                 }
             }
         }
+
         return derivations
     }
 }

app/src/main/java/com/tangem/tap/domain/tokens/LoadAvailableCoinsService.kt

@@ -1,105 +0,0 @@
-package com.tangem.tap.domain.tokens
-
-import com.squareup.moshi.JsonAdapter
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.common.services.Result
-import com.tangem.datasource.api.common.MoshiConverter
-import com.tangem.datasource.api.tangemTech.TangemTechApi
-import com.tangem.datasource.api.tangemTech.models.CoinsResponse
-import com.tangem.datasource.asset.AssetReader
-import com.tangem.domain.common.extensions.toNetworkId
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.coroutines.withContext
-
-class LoadAvailableCoinsService(
-    private val tangemTechApi: TangemTechApi,
-    private val dispatchers: CoroutineDispatcherProvider,
-    private val assetReader: AssetReader,
-) {
-    private val currenciesAdapter: JsonAdapter<CurrenciesFromJson> =
-        MoshiConverter.networkMoshi.adapter(CurrenciesFromJson::class.java)
-
-    suspend fun getSupportedTokens(
-        isTestNet: Boolean,
-        supportedBlockchains: List<Blockchain>,
-        page: Int,
-        searchInput: String?,
-    ): Result<LoadedCoins> {
-        if (isTestNet) {
-            return Result.Success(
-                LoadedCoins(
-                    currencies = getTestnetCoins().filter(searchInput),
-                    moreAvailable = false,
-                ),
-            )
-        }
-
-        val offset = page * LOAD_PER_PAGE
-        return when (val result = loadCoins(supportedBlockchains, offset, searchInput)) {
-            is Result.Success -> {
-                val data = result.data
-
-                Result.Success(
-                    LoadedCoins(
-                        currencies = data.coins.map {
-                            Currency.fromCoinResponse(currency = it, imageHost = data.imageHost)
-                        },
-                        moreAvailable = data.total > offset + LOAD_PER_PAGE,
-                    ),
-                )
-            }
-            is Result.Failure -> {
-                Result.Failure(result.error)
-            }
-        }
-    }
-
-    private suspend fun loadCoins(
-        supportedBlockchains: List<Blockchain>,
-        offset: Int,
-        searchInput: String?,
-    ): Result<CoinsResponse> {
-        return withContext(dispatchers.io) {
-            runCatching {
-                tangemTechApi.getCoins(
-                    networkIds = supportedBlockchains.joinToString(
-                        separator = ",",
-                        transform = Blockchain::toNetworkId,
-                    ),
-                    active = true,
-                    searchText = searchInput,
-                    offset = offset,
-                    limit = LOAD_PER_PAGE,
-                )
-            }.fold(
-                onSuccess = { Result.Success(it) },
-                onFailure = { Result.Failure(it) },
-            )
-        }
-    }
-
-    private fun getTestnetCoins(): List<Currency> {
-        val json = assetReader.readJson(FILE_NAME_TESTNET_COINS)
-        return currenciesAdapter.fromJson(json)!!.coins
-            .map { Currency.fromJsonObject(it) }
-    }
-
-    private fun List<Currency>.filter(searchInput: String?): List<Currency> {
-        if (searchInput.isNullOrBlank()) return this
-
-        return filter { currency ->
-            currency.symbol.contains(searchInput, ignoreCase = true) ||
-                currency.name.contains(searchInput, ignoreCase = true)
-        }
-    }
-
-    private companion object {
-        const val LOAD_PER_PAGE = 100
-        const val FILE_NAME_TESTNET_COINS = "testnet_tokens"
-    }
-}
-
-data class LoadedCoins(
-    val currencies: List<Currency>,
-    val moreAvailable: Boolean,
-)

app/src/main/java/com/tangem/tap/domain/tokens/UserTokensRepository.kt

@@ -1,13 +1,12 @@
 package com.tangem.tap.domain.tokens
 
-import android.content.Context
 import com.tangem.blockchain.common.derivation.DerivationStyle
 import com.tangem.common.core.TangemSdkError
+import com.tangem.datasource.api.common.response.getOrThrow
 import com.tangem.datasource.api.tangemTech.TangemTechApi
 import com.tangem.datasource.api.tangemTech.TangemTechService
 import com.tangem.datasource.api.tangemTech.models.UserTokensResponse
 import com.tangem.datasource.connection.NetworkConnectionManager
-import com.tangem.datasource.files.AndroidFileReader
 import com.tangem.domain.common.BlockchainNetwork
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.userwallets.UserWalletIdBuilder
@@ -108,7 +107,8 @@ class UserTokensRepository(
         return runCatching { tangemTechApi.getUserTokens(userWalletId) }
             .fold(
                 onSuccess = { response ->
-                    response.tokens
+                    response.getOrThrow()
+                        .tokens
                         .mapNotNull(Currency.Companion::fromTokenResponse)
                         .also { storageService.saveUserTokens(userWalletId, it.toUserTokensResponse()) }
                         .distinct()
@@ -131,12 +131,12 @@ class UserTokensRepository(
 
         // TODO("After adding DI") get dependencies by DI
         fun init(
-            context: Context,
             tangemTechService: TangemTechService,
             networkConnectionManager: NetworkConnectionManager,
+            storageService: UserTokensStorageService,
         ): UserTokensRepository {
             return UserTokensRepository(
-                storageService = UserTokensStorageService(fileReader = AndroidFileReader(context)),
+                storageService = storageService,
                 tangemTechApi = tangemTechService.api,
                 dispatchers = AppCoroutineDispatcherProvider(),
                 networkConnectionManager = networkConnectionManager,

app/src/main/java/com/tangem/tap/domain/tokens/UserTokensStorageService.kt

@@ -1,9 +1,11 @@
 package com.tangem.tap.domain.tokens
 
+import android.content.Context
 import com.squareup.moshi.JsonAdapter
 import com.tangem.Log
 import com.tangem.datasource.api.common.MoshiConverter
 import com.tangem.datasource.api.tangemTech.models.UserTokensResponse
+import com.tangem.datasource.files.AndroidFileReader
 import com.tangem.datasource.files.FileReader
 import com.tangem.tap.features.wallet.models.Currency
 
@@ -30,5 +32,7 @@ class UserTokensStorageService(private val fileReader: FileReader) {
     companion object {
         private const val FILE_NAME_PREFIX_USER_TOKENS = "user_tokens"
         private fun getFileNameForUserTokens(userId: String): String = "${FILE_NAME_PREFIX_USER_TOKENS}_$userId"
+
+        fun init(context: Context) = UserTokensStorageService(AndroidFileReader(context))
     }
 }

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

@@ -23,7 +23,7 @@ class FinalizeTwinTask(
                     PreflightReadTask(PreflightReadMode.FullCardRead).run(session) { readResult ->
                         when (readResult) {
                             is CompletionResult.Success ->
-                                ScanProductTask(readResult.data, null)
+                                ScanProductTask(readResult.data, derivationsFinder = null)
                                     .run(session, callback)
                             is CompletionResult.Failure ->
                                 callback(CompletionResult.Failure(readResult.error))

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

@@ -3,25 +3,28 @@ package com.tangem.tap.domain.userWalletList.di
 import android.content.Context
 import com.squareup.moshi.Moshi
 import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
+import com.tangem.common.Provider
+import com.tangem.common.authentication.AuthenticatedStorage
 import com.tangem.common.json.TangemSdkAdapter
 import com.tangem.common.services.secure.SecureStorage
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.sdk.storage.AndroidSecureStorage
 import com.tangem.sdk.storage.createEncryptedSharedPreferences
-import com.tangem.tap.domain.TangemSdkManager
 import com.tangem.tap.domain.userWalletList.implementation.BiometricUserWalletsListManager
 import com.tangem.tap.domain.userWalletList.implementation.RuntimeUserWalletsListManager
+import com.tangem.tap.domain.userWalletList.repository.DelegatedKeystoreManager
+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
 import com.tangem.tap.domain.userWalletList.utils.json.*
+import com.tangem.tap.tangemSdkManager
 
 private const val USER_WALLETS_STORAGE_NAME = "user_wallets_storage"
 
 fun UserWalletsListManager.Companion.provideBiometricImplementation(
-    context: Context,
-    tangemSdkManager: TangemSdkManager,
+    applicationContext: Context,
 ): UserWalletsListManager {
     val moshi = Moshi.Builder()
         .add(WalletDerivedKeysMapAdapter())
@@ -38,15 +41,25 @@ fun UserWalletsListManager.Companion.provideBiometricImplementation(
 
     val secureStorage = AndroidSecureStorage(
         preferences = SecureStorage.createEncryptedSharedPreferences(
-            context = context,
+            context = applicationContext,
             storageName = USER_WALLETS_STORAGE_NAME,
         ),
     )
 
+    val authenticatedStorage = AuthenticatedStorage(
+        secureStorage = UserWalletsKeysStoreDecorator(
+            featureStorage = secureStorage,
+            cardSdkStorageProvider = Provider { tangemSdkManager.secureStorage },
+        ),
+        keystoreManager = DelegatedKeystoreManager(
+            keystoreManagerProvider = Provider { tangemSdkManager.keystoreManager },
+        ),
+    )
+
     val keysRepository = BiometricUserWalletsKeysRepository(
         moshi = moshi,
         secureStorage = secureStorage,
-        biometricManager = tangemSdkManager.biometricManager,
+        authenticatedStorage = authenticatedStorage,
     )
     val publicInformationRepository = DefaultUserWalletsPublicInformationRepository(
         moshi = moshi,

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

@@ -1,7 +1,6 @@
 package com.tangem.tap.domain.userWalletList.implementation
 
 import com.tangem.common.*
-import com.tangem.common.extensions.guard
 import com.tangem.domain.wallets.legacy.UserWalletsListError
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.models.UserWallet
@@ -16,6 +15,7 @@ import com.tangem.tap.domain.userWalletList.utils.toUserWallets
 import com.tangem.tap.domain.userWalletList.utils.updateWith
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.*
+import timber.log.Timber
 
 @OptIn(ExperimentalCoroutinesApi::class)
 internal class BiometricUserWalletsListManager(
@@ -56,20 +56,27 @@ internal class BiometricUserWalletsListManager(
     override val walletsCount: Int
         get() = state.value.userWallets.size
 
-    override suspend fun unlock(): CompletionResult<UserWallet> {
+    override suspend fun unlock(throwIfNotAllWalletsUnlocked: Boolean): CompletionResult<UserWallet> {
         return unlockWithBiometryInternal()
             .mapFailure { error ->
                 if (error is UserWalletsListError) {
                     error
                 } else {
-                    UserWalletsListError.UnableToUnlockUserWallets(cause = error)
+                    UserWalletsListError.UnableToUnlockUserWallets(error)
                 }
             }
             .map {
-                selectedUserWalletSync.guard {
-                    throw UserWalletsListError.UnableToUnlockUserWallets(
-                        cause = IllegalStateException("No user wallet selected"),
-                    )
+                if (throwIfNotAllWalletsUnlocked && state.value.userWallets.any(UserWallet::isLocked)) {
+                    Timber.e("Not all user wallets have been unlocked")
+                    throw UserWalletsListError.NotAllUserWalletsUnlocked
+                }
+
+                val selectedUserWallet = selectedUserWalletSync
+                if (selectedUserWallet == null || selectedUserWallet.isLocked) {
+                    Timber.e("Unable to find selected user wallet")
+                    throw UserWalletsListError.NoUserWalletSelected
+                } else {
+                    selectedUserWallet
                 }
             }
     }
@@ -141,7 +148,7 @@ internal class BiometricUserWalletsListManager(
 
         return sensitiveInformationRepository.delete(idsToRemove)
             .flatMap { publicInformationRepository.delete(idsToRemove) }
-            .flatMap { keysRepository.delete(idsToRemove) }
+            .map { keysRepository.delete(idsToRemove) }
             .map {
                 state.update { prevState ->
                     val newUserWallets = prevState.userWallets.filter { it.walletId !in idsToRemove }
@@ -158,7 +165,7 @@ internal class BiometricUserWalletsListManager(
     override suspend fun clear(): CompletionResult<Unit> {
         return sensitiveInformationRepository.clear()
             .flatMap { publicInformationRepository.clear() }
-            .flatMap { keysRepository.clear() }
+            .map { keysRepository.clear() }
             .map {
                 selectedUserWalletRepository.set(null)
                 lock()
@@ -308,7 +315,7 @@ internal class BiometricUserWalletsListManager(
 
     private fun findSelectedUserWallet(userWallets: List<UserWallet> = state.value.userWallets): UserWallet? {
         return userWallets.firstOrNull {
-            it.walletId == state.value.selectedUserWalletId && !it.isLocked
+            it.walletId == state.value.selectedUserWalletId
         }
     }
 

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

@@ -0,0 +1,18 @@
+package com.tangem.tap.domain.userWalletList.repository
+
+import com.tangem.common.Provider
+import com.tangem.common.authentication.KeystoreManager
+import javax.crypto.SecretKey
+
+internal class DelegatedKeystoreManager(
+    private val keystoreManagerProvider: Provider<KeystoreManager>,
+) : KeystoreManager {
+
+    override suspend fun authenticateAndGetKey(keyAlias: String): SecretKey? {
+        return keystoreManagerProvider().authenticateAndGetKey(keyAlias)
+    }
+
+    override suspend fun storeKey(keyAlias: String, key: SecretKey) {
+        keystoreManagerProvider().storeKey(keyAlias, key)
+    }
+}

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

@@ -23,15 +23,13 @@ internal interface UserWalletsKeysRepository {
     /**
      * Delete encryption keys for user wallets. Biometric authentication not required
      * @param userWalletsIds List of [UserWalletId] whose encryption keys will be deleted
-     * @return [CompletionResult] of operation
      * */
-    suspend fun delete(userWalletsIds: List<UserWalletId>): CompletionResult<Unit>
+    suspend fun delete(userWalletsIds: List<UserWalletId>)
 
     /**
      * Clear all encryption keys for user wallets. Biometric authentication not required
-     * @return [CompletionResult] of operation
      * */
-    suspend fun clear(): CompletionResult<Unit>
+    suspend fun clear()
 
     /**
      * Determine if the user has saved user wallets

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

@@ -0,0 +1,32 @@
+package com.tangem.tap.domain.userWalletList.repository
+
+import com.tangem.common.Provider
+import com.tangem.common.services.secure.SecureStorage
+
+/**
+ * A decorator for [SecureStorage] that facilitates data migration between two storages.
+ *
+ * @property featureStorage The primary storage, which will eventually contain all user data.
+ * @property cardSdkStorageProvider The SDK's storage where user data might have been previously stored.
+ */
+internal class UserWalletsKeysStoreDecorator(
+    private val featureStorage: SecureStorage,
+    private val cardSdkStorageProvider: Provider<SecureStorage>,
+) : SecureStorage by featureStorage {
+
+    override fun delete(account: String) {
+        featureStorage.delete(account)
+        cardSdkStorageProvider().delete(account)
+    }
+
+    override fun get(account: String): ByteArray? {
+        var data = featureStorage.get(account)
+
+        if (data == null) {
+            data = cardSdkStorageProvider().get(account) ?: return null
+            featureStorage.store(data, account)
+        }
+
+        return data
+    }
+}

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

@@ -4,8 +4,7 @@ import com.squareup.moshi.JsonAdapter
 import com.squareup.moshi.Moshi
 import com.squareup.moshi.Types
 import com.tangem.common.*
-import com.tangem.common.biometric.BiometricManager
-import com.tangem.common.biometric.BiometricStorage
+import com.tangem.common.authentication.AuthenticatedStorage
 import com.tangem.common.core.TangemSdkError
 import com.tangem.common.services.secure.SecureStorage
 import com.tangem.domain.wallets.legacy.UserWalletsListError
@@ -18,13 +17,10 @@ import kotlinx.coroutines.withContext
 
 internal class BiometricUserWalletsKeysRepository(
     moshi: Moshi,
-    biometricManager: BiometricManager,
+    private val authenticatedStorage: AuthenticatedStorage,
     private val secureStorage: SecureStorage,
 ) : UserWalletsKeysRepository {
-    private val biometricStorage = BiometricStorage(
-        biometricManager = biometricManager,
-        secureStorage = secureStorage,
-    )
+
     private val encryptionKeyAdapter: JsonAdapter<UserWalletEncryptionKey> = moshi.adapter(
         UserWalletEncryptionKey::class.java,
     )
@@ -37,13 +33,13 @@ internal class BiometricUserWalletsKeysRepository(
             getAllInternal()
                 .mapFailure { error ->
                     when (error) {
-                        is TangemSdkError.BiometricsAuthenticationLockout ->
+                        is TangemSdkError.AuthenticationLockout ->
                             UserWalletsListError.BiometricsAuthenticationLockout(isPermanent = false)
-                        is TangemSdkError.BiometricsAuthenticationPermanentLockout ->
+                        is TangemSdkError.AuthenticationPermanentLockout ->
                             UserWalletsListError.BiometricsAuthenticationLockout(isPermanent = true)
-                        is TangemSdkError.BiometricCryptographyKeyInvalidated ->
-                            UserWalletsListError.EncryptionKeyInvalidated
-                        is TangemSdkError.BiometricsUnavailable ->
+                        is TangemSdkError.KeystoreInvalidated ->
+                            UserWalletsListError.AllKeysInvalidated
+                        is TangemSdkError.AuthenticationUnavailable ->
                             UserWalletsListError.BiometricsAuthenticationDisabled
                         else -> error
                     }
@@ -57,26 +53,24 @@ internal class BiometricUserWalletsKeysRepository(
         }
     }
 
-    override suspend fun delete(userWalletsIds: List<UserWalletId>): CompletionResult<Unit> {
+    override suspend fun delete(userWalletsIds: List<UserWalletId>) {
         return withContext(Dispatchers.IO) {
-            userWalletsIds.map { userWalletId ->
+            userWalletsIds.forEach { userWalletId ->
                 deleteEncryptionKey(userWalletId)
             }
-                .fold()
-                .map { deleteUserWalletsIds(userWalletsIds) }
+
+            deleteUserWalletsIds(userWalletsIds)
         }
     }
 
-    override suspend fun clear(): CompletionResult<Unit> {
+    override suspend fun clear() {
         return withContext(Dispatchers.IO) {
             getUserWalletsIds()
-                .map { userWalletId ->
+                .forEach { userWalletId ->
                     deleteEncryptionKey(userWalletId)
                 }
-                .fold()
-                .map {
-                    clearUserWalletsIds()
-                }
+
+            clearUserWalletsIds()
         }
     }
 
@@ -89,35 +83,20 @@ internal class BiometricUserWalletsKeysRepository(
     private suspend fun getAllInternal(): CompletionResult<List<UserWalletEncryptionKey>> {
         return getUserWalletsIds()
             .map { userWalletId ->
-                // It is possible to request multiple user wallet keys from biometric storage because
-                // the biometric cryptography key has an expiration time.
-                // If this operation runs more than that expiration time, then the user will have to re-authorize
-                // to receive all user wallets encryption keys
                 getEncryptionKey(userWalletId)
-                    .flatMapOnFailure { error ->
-                        when (error) {
-                            is TangemSdkError.InvalidBiometricCryptographyKey,
-                            is TangemSdkError.BiometricCryptographyOperationFailed,
-                            -> {
-                                // These errors can be skipped as the user has the option to re-save their wallets
-                                // in case they occur
-                                CompletionResult.Success(data = null)
-                            }
-                            else -> CompletionResult.Failure(error)
-                        }
-                    }
                     .doOnFailure { error ->
                         when (error) {
-                            is TangemSdkError.UserCanceledBiometricsAuthentication -> {
+                            is TangemSdkError.UserCanceledAuthentication -> {
                                 // If the user cancels biometric authentication, then cancel operation with error
                                 return CompletionResult.Failure(error)
                             }
-                            is TangemSdkError.BiometricCryptographyKeyInvalidated -> {
+                            is TangemSdkError.KeystoreInvalidated -> {
                                 // If the biometric cryptography key was invalidated,
                                 // then delete all user wallets encryption keys and cancel operation with error
                                 getUserWalletsIds().forEach { userWalletId ->
                                     deleteEncryptionKey(userWalletId)
                                 }
+
                                 return CompletionResult.Failure(error)
                             }
                         }
@@ -129,20 +108,22 @@ internal class BiometricUserWalletsKeysRepository(
     }
 
     private suspend fun getEncryptionKey(userWalletId: UserWalletId): CompletionResult<UserWalletEncryptionKey?> {
-        return biometricStorage.get(StorageKey.UserWalletEncryptionKey(userWalletId).name)
+        return catching { authenticatedStorage.get(StorageKey.UserWalletEncryptionKey(userWalletId).name) }
             .map { it.decodeToKey() }
     }
 
     private suspend fun storeEncryptionKey(encryptionKey: UserWalletEncryptionKey): CompletionResult<Unit> {
-        return biometricStorage.store(
-            key = StorageKey.UserWalletEncryptionKey(encryptionKey.walletId).name,
-            data = encryptionKey.encode(),
-        )
+        return catching {
+            authenticatedStorage.store(
+                key = StorageKey.UserWalletEncryptionKey(encryptionKey.walletId).name,
+                data = encryptionKey.encode(),
+            )
+        }
             .map { storeUserWalletId(encryptionKey.walletId) }
     }
 
-    private suspend fun deleteEncryptionKey(userWalletId: UserWalletId): CompletionResult<Unit> {
-        return biometricStorage.delete(StorageKey.UserWalletEncryptionKey(userWalletId).name)
+    private fun deleteEncryptionKey(userWalletId: UserWalletId) {
+        return authenticatedStorage.delete(StorageKey.UserWalletEncryptionKey(userWalletId).name)
     }
 
     private suspend fun getUserWalletsIds(): List<UserWalletId> {

app/src/main/java/com/tangem/tap/domain/walletStores/repository/implementation/DefaultWalletManagersRepository.kt

@@ -1,18 +1,17 @@
 package com.tangem.tap.domain.walletStores.repository.implementation
 
 import com.tangem.blockchain.common.*
-import com.tangem.blockchain.common.derivation.DerivationStyle
 import com.tangem.common.CompletionResult
 import com.tangem.common.catching
 import com.tangem.common.doOnSuccess
 import com.tangem.common.mapFailure
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.domain.common.BlockchainNetwork
+import com.tangem.domain.common.DerivationStyleProvider
 import com.tangem.domain.common.TapWorkarounds.isTestCard
-import com.tangem.domain.common.TapWorkarounds.useOldStyleDerivation
 import com.tangem.domain.common.extensions.makeWalletManagerForApp
 import com.tangem.domain.common.util.cardTypesResolver
-import com.tangem.domain.models.scan.CardDTO
+import com.tangem.domain.common.util.derivationStyleProvider
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.wallets.legacy.WalletManagersRepository
 import com.tangem.domain.wallets.models.UserWallet
@@ -70,7 +69,7 @@ internal class DefaultWalletManagersRepository(
             }
         val derivationParams = getDerivationParams(
             derivationPath = blockchainNetwork?.derivationPath,
-            card = scanResponse.card,
+            derivationStyleProvider = scanResponse.derivationStyleProvider,
         )
 
         val walletManager = blockchain?.let {
@@ -209,17 +208,16 @@ internal class DefaultWalletManagersRepository(
             }
     }
 
-    private fun getDerivationParams(derivationPath: String?, card: CardDTO): DerivationParams? {
-        return derivationPath?.let {
-            DerivationParams.Custom(
-                path = DerivationPath(it),
-            )
-        } ?: if (!card.settings.isHDWalletAllowed) {
-            null
-        } else if (card.useOldStyleDerivation) {
-            DerivationParams.Default(DerivationStyle.LEGACY)
+    private fun getDerivationParams(
+        derivationPath: String?,
+        derivationStyleProvider: DerivationStyleProvider,
+    ): DerivationParams? {
+        val derivationStyle = derivationStyleProvider.getDerivationStyle() ?: return null
+
+        return if (derivationPath == null) {
+            DerivationParams.Default(derivationStyle)
         } else {
-            DerivationParams.Default(DerivationStyle.NEW)
+            DerivationParams.Custom(DerivationPath(derivationPath))
         }
     }
 }

app/src/main/java/com/tangem/tap/domain/walletconnect/WalletConnectSdkHelper.kt

@@ -16,7 +16,6 @@ import com.tangem.common.extensions.hexToBytes
 import com.tangem.common.extensions.toDecompressedPublicKey
 import com.tangem.common.extensions.toHexString
 import com.tangem.core.analytics.Analytics
-import com.tangem.domain.common.BlockchainNetwork
 import com.tangem.domain.common.extensions.fromNetworkId
 import com.tangem.operations.sign.SignHashCommand
 import com.tangem.tap.common.analytics.events.AnalyticsParam
@@ -31,12 +30,14 @@ import com.tangem.tap.domain.walletconnect2.domain.WcEthereumTransaction
 import com.tangem.tap.domain.walletconnect2.domain.models.EthTransactionData
 import com.tangem.tap.domain.walletconnect2.domain.models.binance.WcBinanceTradeOrder
 import com.tangem.tap.domain.walletconnect2.domain.models.binance.WcBinanceTransferOrder
+import com.tangem.tap.features.demo.isDemoCard
 import com.tangem.tap.features.details.redux.walletconnect.*
 import com.tangem.tap.features.details.ui.walletconnect.dialogs.PersonalSignDialogData
 import com.tangem.tap.features.details.ui.walletconnect.dialogs.TransactionRequestDialogData
 import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.store
 import com.tangem.tap.tangemSdkManager
+import com.tangem.tap.userWalletsListManager
 import com.trustwallet.walletconnect.models.ethereum.WCEthereumSignMessage.WCSignType.*
 import timber.log.Timber
 import java.math.BigDecimal
@@ -49,7 +50,7 @@ class WalletConnectSdkHelper {
         val blockchain = Blockchain.fromNetworkId(data.networkId) ?: return null
         val walletManager = getWalletManager(blockchain, data.rawDerivationPath) ?: return null
 
-        walletManager.safeUpdate()
+        walletManager.safeUpdate(isDemoCard())
         val wallet = walletManager.wallet
         val balance = wallet.amounts[AmountType.Coin]?.value ?: return null
 
@@ -108,13 +109,20 @@ class WalletConnectSdkHelper {
         )
     }
 
-    private fun getWalletManager(blockchain: Blockchain, derivationPath: String?): WalletManager? {
-        val blockchainNetwork = BlockchainNetwork(
+    fun isDemoCard(): Boolean {
+        val userWallet = userWalletsListManager.selectedUserWalletSync ?: return false
+        return userWallet.scanResponse.isDemoCard()
+    }
+
+    private suspend fun getWalletManager(blockchain: Blockchain, derivationPath: String?): WalletManager? {
+        val userWallet = userWalletsListManager.selectedUserWalletSync ?: return null
+        val walletManagerFacade = store.state.daggerGraphState
+            .get(DaggerGraphState::walletManagersFacade)
+        return walletManagerFacade.getOrCreateWalletManager(
+            userWalletId = userWallet.walletId,
             blockchain = blockchain,
             derivationPath = derivationPath,
-            tokens = emptyList(),
         )
-        return store.state.walletState.getWalletManager(blockchainNetwork)
     }
 
     suspend fun completeTransaction(data: WcTransactionData, cardId: String?): String? {

app/src/main/java/com/tangem/tap/domain/walletconnect2/app/TangemWcBlockchainHelper.kt

@@ -1,23 +1,28 @@
 package com.tangem.tap.domain.walletconnect2.app
 
-import com.tangem.blockchain.common.*
-import com.tangem.domain.common.extensions.*
-import com.tangem.tap.domain.walletconnect2.domain.*
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.domain.common.extensions.fromNetworkId
+import com.tangem.domain.common.extensions.toNetworkId
+import com.tangem.tap.domain.walletconnect2.domain.WcBlockchainHelper
 
 class TangemWcBlockchainHelper : WcBlockchainHelper {
     override fun chainIdToNetworkIdOrNull(chainId: String): String? {
-        val parsed = chainId.split(CHAIN_SEPARATOR)
-        if (parsed.size != 2) return null
-        when {
-            parsed.first() == EVM_NAMESPACE -> {
-                val chainIdInt = parsed[1].toIntOrNull() ?: return null
-                return Blockchain.fromChainId(chainIdInt)?.toNetworkId()
+        val parsedId = chainId.parseId() ?: return null
+        val blockchain = parsedId.chainIdToBlockchain()
+
+        return blockchain?.toNetworkId()
+    }
+
+    override fun chainIdToMissingNetworkNameOrNull(chainId: String): String? {
+        val parsedId = chainId.parseId() ?: return null
+        val blockchain = parsedId.chainIdToBlockchain()
+
+        return blockchain?.fullName
+            ?: if (parsedId.first == EVM_NAMESPACE) {
+                chainId
+            } else {
+                parsedId.first.replaceFirstChar(Char::titlecase)
             }
-            else -> {
-                val blockchain = Blockchain.fromNetworkId(parsed.first())
-                return if (supportedNonEvmBlockchains.contains(blockchain)) blockchain?.toNetworkId() else null
-            }
-        }
     }
 
     override fun networkIdToChainIdOrNull(networkId: String): String? {
@@ -57,6 +62,26 @@ private fun Blockchain.getCaip2Namespace(): String? {
     }
 }
 
+private fun String.parseId(): Pair<String, String>? {
+    val parsed = this.split(CHAIN_SEPARATOR)
+    if (parsed.size != 2) return null
+
+    return parsed[0] to parsed[1]
+}
+
+private fun Pair<String, String>.chainIdToBlockchain(): Blockchain? {
+    return when (first) {
+        EVM_NAMESPACE -> {
+            second.toIntOrNull()
+                ?.let(Blockchain::fromChainId)
+        }
+        else -> {
+            Blockchain.fromNetworkId(networkId = first)
+                .takeIf(supportedNonEvmBlockchains::contains)
+        }
+    }
+}
+
 private val supportedNonEvmBlockchains = emptySet<Blockchain>() // TODO: add supported networks
 
 private const val EVM_NAMESPACE = "eip155"

app/src/main/java/com/tangem/tap/domain/walletconnect2/domain/WalletConnectInteractor.kt

@@ -75,9 +75,11 @@ class WalletConnectInteractor(
                     is WalletConnectEvents.SessionApprovalError -> {
                         val error = when (wcEvent.error) {
                             is WalletConnectError.ApprovalErrorMissingNetworks -> {
-                                val missingNetworks = wcEvent.error.missingChains
-                                    .map { blockchainHelper.chainIdToNetworkIdOrNull(it) }
-                                WalletConnectError.ApprovalErrorAddNetwork(missingNetworks.filterNotNull())
+                                val missingNetworks = wcEvent.error.missingChains.mapNotNull {
+                                    blockchainHelper.chainIdToMissingNetworkNameOrNull(it)
+                                }
+
+                                WalletConnectError.ApprovalErrorAddNetwork(missingNetworks)
                             }
                             else -> wcEvent.error
                         }

app/src/main/java/com/tangem/tap/domain/walletconnect2/domain/WcBlockchainHelper.kt

@@ -3,6 +3,8 @@ package com.tangem.tap.domain.walletconnect2.domain
 interface WcBlockchainHelper {
     fun chainIdToNetworkIdOrNull(chainId: String): String?
 
+    fun chainIdToMissingNetworkNameOrNull(chainId: String): String?
+
     fun networkIdToChainIdOrNull(networkId: String): String?
 
     fun getNamespaceFromFullChainIdOrNull(chainId: String): String?

app/src/main/java/com/tangem/tap/features/BaseFragment.kt

@@ -30,12 +30,6 @@ abstract class BaseFragment(layoutId: Int) : Fragment(layoutId), FragmentOnBackP
         configureTransitions()
     }
 
-    protected open fun configureTransitions() {
-        val inflater = TransitionInflater.from(requireContext())
-        enterTransition = inflater.inflateTransition(R.transition.slide_right)
-        exitTransition = inflater.inflateTransition(R.transition.fade)
-    }
-
     override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
         mainView = super.onCreateView(inflater, container, savedInstanceState)!!
         return mainView
@@ -56,6 +50,16 @@ abstract class BaseFragment(layoutId: Int) : Fragment(layoutId), FragmentOnBackP
 
     protected open fun loadToolbarMenu(): MenuProvider? = null
 
+    protected open fun configureTransitions() {
+        configureDefaultTransactions()
+    }
+
+    protected fun configureDefaultTransactions() {
+        val inflater = TransitionInflater.from(requireContext())
+        enterTransition = inflater.inflateTransition(R.transition.fade)
+        exitTransition = inflater.inflateTransition(R.transition.fade)
+    }
+
     fun showRetrySnackbar(message: String, action: VoidCallback) {
         val snackbar = Snackbar.make(mainView, message, Snackbar.LENGTH_INDEFINITE)
         snackbar.setAction(getString(R.string.common_retry)) {

app/src/main/java/com/tangem/tap/features/customtoken/api/featuretoggles/CustomTokenFeatureToggles.kt

@@ -7,8 +7,5 @@ package com.tangem.tap.features.customtoken.api.featuretoggles
  */
 interface CustomTokenFeatureToggles {
 
-    /** Availability of redesigned screen (internal feature) */
-    val isRedesignedScreenEnabled: Boolean
-
     val isNewCardScanningEnabled: Boolean
 }

app/src/main/java/com/tangem/tap/features/customtoken/impl/di/CustomTokenInteractorModule.kt

@@ -1,6 +1,7 @@
 package com.tangem.tap.features.customtoken.impl.di
 
 import com.tangem.datasource.api.tangemTech.TangemTechApi
+import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
 import com.tangem.tap.features.customtoken.impl.data.DefaultCustomTokenRepository
 import com.tangem.tap.features.customtoken.impl.domain.CustomTokenInteractor
 import com.tangem.tap.features.customtoken.impl.domain.DefaultCustomTokenInteractor
@@ -24,6 +25,7 @@ internal object CustomTokenInteractorModule {
     fun provideCustomTokenInteractor(
         tangemTechApi: TangemTechApi,
         appCoroutineDispatcherProvider: AppCoroutineDispatcherProvider,
+        getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
         reduxStateHolder: AppStateHolder,
     ): CustomTokenInteractor {
         return DefaultCustomTokenInteractor(
@@ -32,7 +34,7 @@ internal object CustomTokenInteractorModule {
                 dispatchers = appCoroutineDispatcherProvider,
                 reduxStateHolder = reduxStateHolder,
             ),
-            reduxStateHolder = reduxStateHolder,
+            getSelectedWalletSyncUseCase = getSelectedWalletSyncUseCase,
         )
     }
 }

app/src/main/java/com/tangem/tap/features/customtoken/impl/domain/DefaultCustomTokenInteractor.kt

@@ -9,12 +9,18 @@ import com.tangem.common.extensions.guard
 import com.tangem.common.extensions.toMapKey
 import com.tangem.common.flatMap
 import com.tangem.crypto.hdWallet.DerivationPath
+import com.tangem.data.tokens.utils.CryptoCurrencyFactory
 import com.tangem.domain.common.configs.CardConfig
 import com.tangem.domain.common.extensions.toNetworkId
 import com.tangem.domain.common.util.derivationStyleProvider
 import com.tangem.domain.common.util.hasDerivation
 import com.tangem.domain.features.addCustomToken.CustomCurrency
 import com.tangem.domain.models.scan.ScanResponse
+import com.tangem.domain.tokens.AddCryptoCurrenciesUseCase
+import com.tangem.domain.tokens.model.CryptoCurrency
+import com.tangem.domain.wallets.models.UserWallet
+import com.tangem.domain.wallets.models.UserWalletId
+import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
 import com.tangem.operations.derivation.ExtendedPublicKeysMap
 import com.tangem.tap.*
 import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
@@ -24,23 +30,32 @@ import com.tangem.tap.domain.TapError
 import com.tangem.tap.features.customtoken.impl.domain.models.FoundToken
 import com.tangem.tap.features.tokens.legacy.redux.TokensMiddleware
 import com.tangem.tap.features.wallet.models.Currency
-import com.tangem.tap.proxy.AppStateHolder
+import com.tangem.tap.proxy.redux.DaggerGraphState
+import com.tangem.utils.extensions.DELAY_SDK_DIALOG_CLOSE
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import timber.log.Timber
 
 /**
  * Default implementation of custom token interactor
  *
  * @property featureRepository feature repository
- * @property reduxStateHolder  redux state holder
  *
 [REDACTED_AUTHOR]
  */
 class DefaultCustomTokenInteractor(
     private val featureRepository: CustomTokenRepository,
-    private val reduxStateHolder: AppStateHolder,
+    private val getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
 ) : CustomTokenInteractor {
 
+    // TODO: Move to DI
+    private val addCryptoCurrenciesUseCase by lazy(LazyThreadSafetyMode.NONE) {
+        val currenciesRepository = store.state.daggerGraphState.get(DaggerGraphState::currenciesRepository)
+        val networksRepository = store.state.daggerGraphState.get(DaggerGraphState::networksRepository)
+
+        AddCryptoCurrenciesUseCase(currenciesRepository, networksRepository)
+    }
+
     override suspend fun findToken(address: String, blockchain: Blockchain): FoundToken {
         return featureRepository.findToken(
             address = address,
@@ -49,28 +64,30 @@ class DefaultCustomTokenInteractor(
     }
 
     override suspend fun saveToken(customCurrency: CustomCurrency) {
-        val scanResponse = reduxStateHolder.scanResponse ?: return
+        val userWallet = getSelectedWalletSyncUseCase().fold(ifLeft = { return }, ifRight = { it })
 
         val currency = Currency.fromCustomCurrency(customCurrency)
-        val isNeedToDerive = isNeedToDerive(scanResponse, currency)
+        val isNeedToDerive = isNeedToDerive(userWallet, currency)
         if (isNeedToDerive) {
-            deriveMissingBlockchains(scanResponse = scanResponse, currencyList = listOf(currency)) {
-                submitAdd(scanResponse = it, currency = currency)
+            deriveMissingBlockchains(userWallet = userWallet, currencyList = listOf(currency)) {
+                submitAdd(userWallet = userWallet.copy(scanResponse = it), currency = currency)
             }
         } else {
-            submitAdd(scanResponse, currency)
+            submitAdd(userWallet, currency)
         }
     }
 
-    private fun isNeedToDerive(scanResponse: ScanResponse, currency: Currency): Boolean {
+    private fun isNeedToDerive(userWallet: UserWallet, currency: Currency): Boolean {
+        val scanResponse = userWallet.scanResponse
         return currency.derivationPath?.let { !scanResponse.hasDerivation(currency.blockchain, it) } ?: false
     }
 
     private suspend fun deriveMissingBlockchains(
-        scanResponse: ScanResponse,
+        userWallet: UserWallet,
         currencyList: List<Currency>,
         onSuccess: suspend (ScanResponse) -> Unit,
     ) {
+        val scanResponse = userWallet.scanResponse
         val config = CardConfig.createConfig(scanResponse.card)
         val derivationDataList = currencyList.mapNotNull { currency ->
             val curve = config.primaryCurve(currency.blockchain)
@@ -153,7 +170,42 @@ class DefaultCustomTokenInteractor(
         return TokensMiddleware.DerivationData(derivations = mapKeyOfWalletPublicKey to toDerive)
     }
 
-    private suspend fun submitAdd(scanResponse: ScanResponse, currency: Currency) {
+    private suspend fun submitAdd(userWallet: UserWallet, currency: Currency) {
+        val scanResponse = userWallet.scanResponse
+        val walletFeatureToggles = store.state.daggerGraphState.get(DaggerGraphState::walletFeatureToggles)
+
+        if (walletFeatureToggles.isRedesignedScreenEnabled) {
+            val cryptoCurrencyFactory = CryptoCurrencyFactory()
+
+            submitNewAdd(
+                userWalletId = userWallet.walletId,
+                updatedScanResponse = scanResponse,
+                currencyList = listOfNotNull(
+                    when (currency) {
+                        is Currency.Blockchain -> {
+                            cryptoCurrencyFactory.createCoin(
+                                blockchain = currency.blockchain,
+                                extraDerivationPath = currency.derivationPath,
+                                derivationStyleProvider = scanResponse.derivationStyleProvider,
+                            )
+                        }
+                        is Currency.Token -> {
+                            cryptoCurrencyFactory.createToken(
+                                sdkToken = currency.token,
+                                blockchain = currency.blockchain,
+                                extraDerivationPath = currency.derivationPath,
+                                derivationStyleProvider = scanResponse.derivationStyleProvider,
+                            )
+                        }
+                    },
+                ),
+            )
+        } else {
+            submitLegacyAdd(scanResponse = scanResponse, currency = currency)
+        }
+    }
+
+    private suspend fun submitLegacyAdd(scanResponse: ScanResponse, currency: Currency) {
         val selectedUserWallet = userWalletsListManager.selectedUserWalletSync.guard {
             Timber.e("Unable to add currencies, no user wallet selected")
             return
@@ -170,4 +222,19 @@ class DefaultCustomTokenInteractor(
                 )
             }
     }
+
+    private fun submitNewAdd(
+        userWalletId: UserWalletId,
+        updatedScanResponse: ScanResponse,
+        currencyList: List<CryptoCurrency>,
+    ) {
+        scope.launch {
+            userWalletsListManager.update(
+                userWalletId = userWalletId,
+                update = { it.copy(scanResponse = updatedScanResponse) },
+            )
+
+            addCryptoCurrenciesUseCase(userWalletId, currencyList)
+        }
+    }
 }

app/src/main/java/com/tangem/tap/features/customtoken/impl/featuretoggles/DefaultCustomTokenFeatureToggles.kt

@@ -14,9 +14,6 @@ internal class DefaultCustomTokenFeatureToggles(
     private val featureTogglesManager: FeatureTogglesManager,
 ) : CustomTokenFeatureToggles {
 
-    override val isRedesignedScreenEnabled: Boolean
-        get() = featureTogglesManager.isFeatureEnabled(name = "REDESIGNED_CUSTOM_TOKEN_SCREEN_ENABLED")
-
     override val isNewCardScanningEnabled: Boolean
         get() = featureTogglesManager.isFeatureEnabled(name = "NEW_CARD_SCANNING_ENABLED")
 }

app/src/main/java/com/tangem/tap/features/customtoken/impl/presentation/AddCustomTokenFragment.kt

@@ -1,21 +1,18 @@
 package com.tangem.tap.features.customtoken.impl.presentation
 
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
 import androidx.compose.foundation.layout.systemBarsPadding
+import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.ComposeView
 import androidx.compose.ui.platform.LocalLifecycleOwner
-import androidx.fragment.app.Fragment
 import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.transition.TransitionInflater
+import com.tangem.core.ui.components.SystemBarsEffect
 import com.tangem.core.ui.res.TangemTheme
+import com.tangem.core.ui.screen.ComposeFragment
+import com.tangem.core.ui.theme.AppThemeModeHolder
 import com.tangem.tap.features.customtoken.impl.presentation.ui.AddCustomTokenScreen
 import com.tangem.tap.features.customtoken.impl.presentation.viewmodels.AddCustomTokenViewModel
-import com.tangem.wallet.R
 import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
 
 /**
  * Add custom token screen
@@ -23,29 +20,23 @@ import dagger.hilt.android.AndroidEntryPoint
 [REDACTED_AUTHOR]
  */
 @AndroidEntryPoint
-internal class AddCustomTokenFragment : Fragment() {
+internal class AddCustomTokenFragment : ComposeFragment() {
 
-    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
-        with(TransitionInflater.from(requireContext())) {
-            enterTransition = inflateTransition(R.transition.fade)
-            exitTransition = inflateTransition(R.transition.fade)
+    @Inject
+    override lateinit var appThemeModeHolder: AppThemeModeHolder
+
+    @Composable
+    override fun ScreenContent(modifier: Modifier) {
+        val viewModel = hiltViewModel<AddCustomTokenViewModel>().apply {
+            LocalLifecycleOwner.current.lifecycle.addObserver(this)
         }
-
-        return ComposeView(inflater.context).apply {
-            setContent {
-                isTransitionGroup = true
-
-                val viewModel = hiltViewModel<AddCustomTokenViewModel>().apply {
-                    LocalLifecycleOwner.current.lifecycle.addObserver(this)
-                }
-
-                TangemTheme {
-                    AddCustomTokenScreen(
-                        modifier = Modifier.systemBarsPadding(),
-                        stateHolder = viewModel.uiState,
-                    )
-                }
-            }
+        val statusBarColor = TangemTheme.colors.background.secondary
+        SystemBarsEffect {
+            setSystemBarsColor(color = statusBarColor)
         }
+        AddCustomTokenScreen(
+            modifier = Modifier.systemBarsPadding(),
+            stateHolder = viewModel.uiState,
+        )
     }
 }

app/src/main/java/com/tangem/tap/features/customtoken/impl/presentation/ui/AddCustomTokenPreviewData.kt

@@ -55,7 +55,7 @@ internal object AddCustomTokenPreviewData {
                 value = "",
                 onValueChange = {},
                 keyboardOptions = KeyboardOptions(imeAction = ImeAction.Next),
-                label = TextReference.Res(R.string.custom_token_token_symbol_input_title),
+                label = TextReference.Res(R.string.custom_token_token_symbol_input_title_old),
                 placeholder = TextReference.Res(id = R.string.custom_token_token_symbol_input_placeholder),
                 isEnabled = false,
             ),

app/src/main/java/com/tangem/tap/features/customtoken/impl/presentation/ui/AddCustomTokenScreen.kt

@@ -25,10 +25,20 @@ internal fun AddCustomTokenScreen(stateHolder: AddCustomTokenStateHolder, modifi
 
 @Preview(showSystemUi = true)
 @Composable
-private fun Preview_AddCustomTokenScreen(
+private fun Preview_AddCustomTokenScreen_Light(
     @PreviewParameter(AddCustomTokenScreenProvider::class) stateHolder: AddCustomTokenStateHolder,
 ) {
-    TangemTheme {
+    TangemTheme(isDark = false) {
+        AddCustomTokenScreen(stateHolder)
+    }
+}
+
+@Preview(showSystemUi = true)
+@Composable
+private fun Preview_AddCustomTokenScreen_Dark(
+    @PreviewParameter(AddCustomTokenScreenProvider::class) stateHolder: AddCustomTokenStateHolder,
+) {
+    TangemTheme(isDark = true) {
         AddCustomTokenScreen(stateHolder)
     }
 }

app/src/main/java/com/tangem/tap/features/customtoken/impl/presentation/ui/AddCustomTokenTestContent.kt

@@ -91,7 +91,7 @@ internal fun AddCustomTokenTestContent(state: AddCustomTokenStateHolder.TestCont
         floatingActionButtonPosition = FabPosition.Center,
         sheetBackgroundColor = TangemTheme.colors.background.secondary,
         sheetPeekHeight = TangemTheme.dimens.size0,
-        backgroundColor = TangemTheme.colors.background.secondary,
+        backgroundColor = TangemTheme.colors.background.primary,
     ) {
         Column(
             modifier = Modifier

app/src/main/java/com/tangem/tap/features/customtoken/impl/presentation/ui/components/AddCustomTokenForm.kt

@@ -94,7 +94,7 @@ private fun TextField(model: AddCustomTokenInputField, isError: Boolean) {
             label = {
                 Text(
                     text = model.label.resolveReference(),
-                    style = TangemTheme.typography.caption,
+                    style = TangemTheme.typography.caption2,
                     color = TangemTextFieldsDefault.defaultTextFieldColors.labelColor(
                         enabled = isEnabled,
                         error = isError,
@@ -178,7 +178,7 @@ private fun SelectorField(model: AddCustomTokenSelectorField) {
                                 text = subtitle,
                                 color = TangemTheme.colors.text.secondary,
                                 maxLines = 1,
-                                style = TangemTheme.typography.caption,
+                                style = TangemTheme.typography.caption2,
                             )
                         }
                     }

app/src/main/java/com/tangem/tap/features/customtoken/impl/presentation/ui/components/AddCustomTokenToolbar.kt

@@ -1,11 +1,9 @@
 package com.tangem.tap.features.customtoken.impl.presentation.ui.components
 
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.width
-import androidx.compose.material.Icon
-import androidx.compose.material.IconButton
-import androidx.compose.material.Text
-import androidx.compose.material.TopAppBar
+import androidx.compose.material.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.painterResource
@@ -25,7 +23,15 @@ import com.tangem.tap.features.details.ui.cardsettings.resolveReference
  */
 @Composable
 internal fun AddCustomTokenToolbar(title: TextReference, onBackButtonClick: () -> Unit) {
-    TopAppBar(backgroundColor = TangemTheme.colors.background.secondary) {
+    val toolbarElevation = if (isSystemInDarkTheme()) {
+        TangemTheme.dimens.elevation0
+    } else {
+        AppBarDefaults.TopAppBarElevation
+    }
+    TopAppBar(
+        backgroundColor = TangemTheme.colors.background.primary,
+        elevation = toolbarElevation,
+    ) {
         IconButton(onClick = onBackButtonClick) {
             Icon(
                 painter = painterResource(id = R.drawable.ic_back_24),

app/src/main/java/com/tangem/tap/features/customtoken/impl/presentation/ui/components/AddCustomTokenWarnings.kt

@@ -72,8 +72,16 @@ private fun AddCustomTokenWarning(warning: AddCustomTokenWarning) {
 
 @Preview
 @Composable
-private fun Preview_AddCustomTokenWarnings() {
+private fun Preview_AddCustomTokenWarnings_Light() {
     TangemTheme {
         AddCustomTokenWarnings(warnings = AddCustomTokenPreviewData.createWarnings())
     }
+}
+
+@Preview
+@Composable
+private fun Preview_AddCustomTokenWarnings_Dark() {
+    TangemTheme(isDark = true) {
+        AddCustomTokenWarnings(warnings = AddCustomTokenPreviewData.createWarnings())
+    }
 }

app/src/main/java/com/tangem/tap/features/customtoken/impl/presentation/viewmodels/AddCustomTokenViewModel.kt

@@ -22,6 +22,10 @@ import com.tangem.domain.common.extensions.*
 import com.tangem.domain.common.util.cardTypesResolver
 import com.tangem.domain.common.util.derivationStyleProvider
 import com.tangem.domain.features.addCustomToken.CustomCurrency
+import com.tangem.domain.tokens.GetCryptoCurrenciesUseCase
+import com.tangem.domain.tokens.model.CryptoCurrency
+import com.tangem.domain.wallets.usecase.GetSelectedWalletSyncUseCase
+import com.tangem.features.wallet.featuretoggles.WalletFeatureToggles
 import com.tangem.tap.domain.model.WalletDataModel
 import com.tangem.tap.features.customtoken.impl.domain.CustomTokenInteractor
 import com.tangem.tap.features.customtoken.impl.domain.models.FoundToken
@@ -35,7 +39,6 @@ import com.tangem.tap.features.customtoken.impl.presentation.validators.ContactA
 import com.tangem.tap.features.customtoken.impl.presentation.validators.ContractAddressValidatorResult
 import com.tangem.tap.features.details.ui.cardsettings.TextReference
 import com.tangem.tap.features.wallet.models.Currency
-import com.tangem.tap.proxy.AppStateHolder
 import com.tangem.tap.store
 import com.tangem.utils.coroutines.AppCoroutineDispatcherProvider
 import com.tangem.utils.coroutines.runCatching
@@ -51,22 +54,24 @@ import javax.inject.Inject
 /**
  * ViewModel for add custom token screen
  *
- * @param analyticsEventHandler analytics event handler
- * @param featureRouter         feature router
- * @property featureInteractor  feature interactor
- * @property dispatchers        coroutine dispatchers provider
- * @property reduxStateHolder   redux state holder
+ * @param analyticsEventHandler           analytics event handler
+ * @param featureRouter                   feature router
+ * @property featureInteractor            feature interactor
+ * @property getSelectedWalletSyncUseCase use case that returns selected wallet
+ * @property dispatchers                  coroutine dispatchers provider
  *
 [REDACTED_AUTHOR]
  */
-@Suppress("LargeClass")
+@Suppress("LargeClass", "LongParameterList")
 @HiltViewModel
 internal class AddCustomTokenViewModel @Inject constructor(
     analyticsEventHandler: AnalyticsEventHandler,
     featureRouter: CustomTokenRouter,
+    getCurrenciesUseCase: GetCryptoCurrenciesUseCase,
     private val featureInteractor: CustomTokenInteractor,
     private val dispatchers: AppCoroutineDispatcherProvider,
-    private val reduxStateHolder: AppStateHolder,
+    private val getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
+    private val walletFeatureToggles: WalletFeatureToggles,
 ) : ViewModel(), DefaultLifecycleObserver {
 
     private val analyticsSender = AddCustomTokenAnalyticsSender(analyticsEventHandler)
@@ -74,12 +79,30 @@ internal class AddCustomTokenViewModel @Inject constructor(
     private val testActionsHandler = TestActionsHandler()
     private val formStateBuilder = FormStateBuilder()
 
+    private var currentCryptoCurrencies: List<CryptoCurrency> = emptyList()
+
     /** Screen state */
     var uiState by mutableStateOf(getInitialUiState())
         private set
 
     private var foundToken: FoundToken? = null
 
+    init {
+        if (walletFeatureToggles.isRedesignedScreenEnabled) {
+            viewModelScope.launch(dispatchers.main) {
+                currentCryptoCurrencies = getSelectedWalletSyncUseCase().fold(
+                    ifLeft = { emptyList() },
+                    ifRight = { selectedWallet ->
+                        getCurrenciesUseCase(selectedWallet.walletId).fold(
+                            ifLeft = { emptyList() },
+                            ifRight = { it },
+                        )
+                    },
+                )
+            }
+        }
+    }
+
     override fun onCreate(owner: LifecycleOwner) {
         analyticsSender.sendWhenScreenOpened()
     }
@@ -208,7 +231,10 @@ internal class AddCustomTokenViewModel @Inject constructor(
 
         private fun getNetworkSelectorItems(): List<SelectorItem.Title> {
             val defaultNetwork = createNetworkSelectorItem(blockchain = Blockchain.Unknown)
-            val scanResponse = reduxStateHolder.scanResponse
+            val scanResponse = getSelectedWalletSyncUseCase().fold(
+                ifLeft = { null },
+                ifRight = { it.scanResponse },
+            )
             val derivationStyle = scanResponse?.derivationStyleProvider?.getDerivationStyle()
             return listOf(defaultNetwork) + Blockchain.values()
                 .filter { blockchain ->
@@ -244,7 +270,7 @@ internal class AddCustomTokenViewModel @Inject constructor(
                 value = "",
                 onValueChange = actionsHandler::onTokenSymbolValueChange,
                 keyboardOptions = KeyboardOptions(imeAction = ImeAction.Next),
-                label = TextReference.Res(R.string.custom_token_token_symbol_input_title),
+                label = TextReference.Res(R.string.custom_token_token_symbol_input_title_old),
                 placeholder = TextReference.Res(id = R.string.custom_token_token_symbol_input_placeholder),
                 isEnabled = false,
             )
@@ -262,17 +288,20 @@ internal class AddCustomTokenViewModel @Inject constructor(
         }
 
         private fun createDerivationPathsSelectorField(): AddCustomTokenSelectorField.DerivationPath? {
-            val scanResponse = reduxStateHolder.scanResponse
-            if (scanResponse?.card?.settings?.isHDWalletAllowed == false) return null
+            return getSelectedWalletSyncUseCase().fold(
+                ifLeft = { null },
+                ifRight = {
+                    if (!it.scanResponse.card.settings.isHDWalletAllowed) return null
 
-            val selectorItems =
-                getDerivationPathsSelectorItems(scanResponse?.derivationStyleProvider)
-            return AddCustomTokenSelectorField.DerivationPath(
-                label = TextReference.Res(R.string.custom_token_derivation_path_input_title),
-                selectedItem = requireNotNull(selectorItems.firstOrNull()),
-                items = selectorItems,
-                onMenuItemClick = actionsHandler::onDerivationPathSelectorItemClick,
-                isEnabled = true,
+                    val selectorItems = getDerivationPathsSelectorItems(it.scanResponse.derivationStyleProvider)
+                    AddCustomTokenSelectorField.DerivationPath(
+                        label = TextReference.Res(R.string.custom_token_derivation_path_input_title),
+                        selectedItem = requireNotNull(selectorItems.firstOrNull()),
+                        items = selectorItems,
+                        onMenuItemClick = actionsHandler::onDerivationPathSelectorItemClick,
+                        isEnabled = true,
+                    )
+                },
             )
         }
 
@@ -315,14 +344,19 @@ internal class AddCustomTokenViewModel @Inject constructor(
         }
 
         private fun createDerivationPathInputField(): AddCustomTokenInputField.DerivationPath? {
-            if (reduxStateHolder.scanResponse?.card?.settings?.isHDWalletAllowed == false) return null
+            return getSelectedWalletSyncUseCase().fold(
+                ifLeft = { null },
+                ifRight = {
+                    if (!it.scanResponse.card.settings.isHDWalletAllowed) return null
 
-            return AddCustomTokenInputField.DerivationPath(
-                value = "",
-                onValueChange = actionsHandler::onDerivationPathValueChange,
-                keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
-                label = TextReference.Res(R.string.custom_token_custom_derivation),
-                placeholder = TextReference.Str(value = DERIVATION_PATH_PLACEHOLDER),
+                    AddCustomTokenInputField.DerivationPath(
+                        value = "",
+                        onValueChange = actionsHandler::onDerivationPathValueChange,
+                        keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
+                        label = TextReference.Res(R.string.custom_token_custom_derivation),
+                        placeholder = TextReference.Str(value = DERIVATION_PATH_PLACEHOLDER),
+                    )
+                },
             )
         }
     }
@@ -440,11 +474,15 @@ internal class AddCustomTokenViewModel @Inject constructor(
         val isSupportedToken = if (!isNetworkSelected()) {
             true
         } else {
-            val scanResponse = reduxStateHolder.scanResponse
-            scanResponse?.card?.canHandleToken(
-                blockchain = networkSelectorValue,
-                cardTypesResolver = scanResponse.cardTypesResolver,
-            ) ?: false
+            getSelectedWalletSyncUseCase().fold(
+                ifLeft = { false },
+                ifRight = {
+                    it.scanResponse.card.canHandleToken(
+                        blockchain = networkSelectorValue,
+                        cardTypesResolver = it.scanResponse.cardTypesResolver,
+                    )
+                },
+            )
         }
 
         return buildSet {
@@ -478,13 +516,16 @@ internal class AddCustomTokenViewModel @Inject constructor(
                     address = uiState.form.contractAddressInputField.value,
                     blockchain = networkSelectorValue,
                 )
-                val scanResponse = reduxStateHolder.scanResponse
-                val isSupportedToken = scanResponse?.card
-                    ?.canHandleToken(
-                        blockchain = networkSelectorValue,
-                        cardTypesResolver = scanResponse.cardTypesResolver,
-                    )
-                    ?: false
+
+                val isSupportedToken = getSelectedWalletSyncUseCase().fold(
+                    ifLeft = { false },
+                    ifRight = {
+                        it.scanResponse.card.canHandleToken(
+                            blockchain = networkSelectorValue,
+                            cardTypesResolver = it.scanResponse.cardTypesResolver,
+                        )
+                    },
+                )
 
                 uiState.copySealed(
                     floatingButton = uiState.floatingButton.copy(
@@ -546,6 +587,33 @@ internal class AddCustomTokenViewModel @Inject constructor(
     }
 
     private fun isTokenAlreadyAdded(): Boolean {
+        return if (walletFeatureToggles.isRedesignedScreenEnabled) {
+            isTokenAlreadyAddedNew()
+        } else {
+            isTokenAlreadyAddedOld()
+        }
+    }
+
+    private fun isTokenAlreadyAddedNew(): Boolean {
+        return currentCryptoCurrencies
+            .filterIsInstance<CryptoCurrency.Token>()
+            .any { token ->
+                val contractAddress = uiState.form.contractAddressInputField.value
+                val networkSelectorValue = uiState.form.networkSelectorField.selectedItem.blockchain
+                val networkId = Blockchain.fromNetworkId(networkSelectorValue.toNetworkId())?.id
+
+                val savedTokenId = if (token.isCustom) null else token.id.value
+
+                val sameId = foundToken?.id == savedTokenId
+                val sameAddress = contractAddress == token.contractAddress
+                val sameBlockchain = networkId == token.network.id.value
+                val isSameDerivationPath = getDerivationPath()?.rawPath == token.network.derivationPath.value
+
+                sameId && sameAddress && sameBlockchain && isSameDerivationPath
+            }
+    }
+
+    private fun isTokenAlreadyAddedOld(): Boolean {
         return store.state.walletState.walletsStores
             .map { walletStore -> walletStore.walletsData.map(WalletDataModel::currency) }
             .flatten()
@@ -563,6 +631,23 @@ internal class AddCustomTokenViewModel @Inject constructor(
     }
 
     private fun isBlockchainAlreadyAdded(): Boolean {
+        return if (walletFeatureToggles.isRedesignedScreenEnabled) {
+            isBlockchainAlreadyAddedNew()
+        } else {
+            isBlockchainAlreadyAddedOld()
+        }
+    }
+
+    private fun isBlockchainAlreadyAddedNew(): Boolean {
+        return currentCryptoCurrencies
+            .filterIsInstance<CryptoCurrency.Coin>()
+            .any { coin ->
+                coin.network.id.value == uiState.form.networkSelectorField.selectedItem.blockchain.id &&
+                    coin.network.derivationPath.value == getDerivationPath()?.rawPath
+            }
+    }
+
+    private fun isBlockchainAlreadyAddedOld(): Boolean {
         return store.state.walletState.walletsStores
             .map { walletStore -> walletStore.walletsData.map(WalletDataModel::currency) }
             .flatten()
@@ -641,8 +726,12 @@ internal class AddCustomTokenViewModel @Inject constructor(
     private fun getDerivationPathForBlockchain(blockchain: Blockchain?): DerivationPath? {
         if (blockchain == null) return null
 
-        val derivationStyle = reduxStateHolder.scanResponse?.derivationStyleProvider?.getDerivationStyle()
-            ?: DerivationStyle.V1
+        val derivationStyle = getSelectedWalletSyncUseCase().fold(
+            ifLeft = { null },
+            ifRight = {
+                it.scanResponse.derivationStyleProvider.getDerivationStyle()
+            },
+        )
 
         val derivationNetwork = if (blockchain == Blockchain.Unknown) {
             uiState.form.networkSelectorField.selectedItem.blockchain
@@ -653,12 +742,15 @@ internal class AddCustomTokenViewModel @Inject constructor(
     }
 
     private fun isUnsupportedBlockchain(blockchain: Blockchain): Boolean {
-        val scanResponse = reduxStateHolder.scanResponse
-        val canHandleToken = scanResponse?.card?.canHandleBlockchain(
-            blockchain = blockchain,
-            cardTypesResolver = scanResponse.cardTypesResolver,
-        ) ?: false
-        return !canHandleToken
+        return getSelectedWalletSyncUseCase().fold(
+            ifLeft = { false },
+            ifRight = {
+                !it.scanResponse.card.canHandleBlockchain(
+                    blockchain = blockchain,
+                    cardTypesResolver = it.scanResponse.cardTypesResolver,
+                )
+            },
+        )
     }
 
     private inner class ActionsHandler(private val featureRouter: CustomTokenRouter) {
@@ -827,7 +919,6 @@ internal class AddCustomTokenViewModel @Inject constructor(
         }
 
         fun onResetButtonClick() {
-            val scanResponse = reduxStateHolder.scanResponse
             with(uiState.form) {
                 uiState = uiState.copySealed(
                     form = uiState.form.copy(

app/src/main/java/com/tangem/tap/features/customtoken/legacy/AddCustomTokenFragment.kt

@@ -1,79 +0,0 @@
-package com.tangem.tap.features.customtoken.legacy
-
-import android.os.Bundle
-import android.view.View
-import android.view.WindowManager
-import androidx.appcompat.widget.Toolbar
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.ComposeView
-import com.tangem.core.analytics.Analytics
-import com.tangem.core.ui.res.TangemTheme
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenState
-import com.tangem.domain.redux.domainStore
-import com.tangem.tap.common.analytics.events.ManageTokens
-import com.tangem.tap.features.BaseStoreFragment
-import com.tangem.tap.features.FragmentOnBackPressedHandler
-import com.tangem.tap.features.addBackPressHandler
-import com.tangem.tap.features.customtoken.legacy.compose.AddCustomTokenScreen
-import com.tangem.tap.features.customtoken.legacy.compose.ClosePopupTrigger
-import com.tangem.wallet.R
-import org.rekotlin.StoreSubscriber
-
-/**
-[REDACTED_AUTHOR]
- */
-class AddCustomTokenFragment : BaseStoreFragment(R.layout.view_compose_fragment), StoreSubscriber<AddCustomTokenState> {
-
-    private var state: MutableState<AddCustomTokenState> = mutableStateOf(domainStore.state.addCustomTokensState)
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        Analytics.send(ManageTokens.CustomToken.ScreenOpened)
-    }
-
-    override fun subscribeToStore() {
-        domainStore.subscribe(this) { state ->
-            state.skipRepeats { oldState, newState ->
-                oldState.addCustomTokensState == newState.addCustomTokensState
-            }.select { it.addCustomTokensState }
-        }
-    }
-
-    override fun newState(state: AddCustomTokenState) {
-        if (activity == null || view == null) return
-
-        this.state.value = state
-    }
-
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        super.onViewCreated(view, savedInstanceState)
-
-        requireActivity().window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE)
-        view.findViewById<Toolbar>(R.id.toolbar)?.setTitle(R.string.add_custom_token_title)
-
-        val closePopupTrigger = initClosingPopupTriggerEvent()
-        view.findViewById<ComposeView>(R.id.view_compose)?.setContent {
-            TangemTheme {
-                Box(
-                    modifier = Modifier
-                        .fillMaxSize(),
-                ) {
-                    AddCustomTokenScreen(state, closePopupTrigger)
-                }
-            }
-        }
-    }
-
-    private fun initClosingPopupTriggerEvent(): ClosePopupTrigger = ClosePopupTrigger().apply {
-        onCloseComplete = ::handleOnBackPressed
-        addBackPressHandler(
-            object : FragmentOnBackPressedHandler {
-                override fun handleOnBackPressed() = close()
-            },
-        )
-    }
-}

app/src/main/java/com/tangem/tap/features/customtoken/legacy/compose/AddCustomTokenScreen.kt

@@ -1,208 +0,0 @@
-package com.tangem.tap.features.customtoken.legacy.compose
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.material.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.colorResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import com.tangem.core.ui.components.PrimaryButtonIconStart
-import com.tangem.core.ui.components.keyboardAsState
-import com.tangem.core.ui.res.TangemTheme
-import com.tangem.domain.AddCustomTokenError
-import com.tangem.domain.common.form.DataField
-import com.tangem.domain.common.form.FieldId
-import com.tangem.domain.features.addCustomToken.CustomTokenFieldId.*
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenAction
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenState
-import com.tangem.domain.features.addCustomToken.redux.ScreenState
-import com.tangem.domain.features.addCustomToken.redux.ViewStates
-import com.tangem.domain.redux.domainStore
-import com.tangem.tap.common.compose.AddCustomTokenWarning
-import com.tangem.tap.domain.moduleMessage.ModuleMessageConverter
-import com.tangem.tap.features.customtoken.legacy.compose.test.TestCase
-import com.tangem.tap.features.customtoken.legacy.compose.test.TestCasesList
-import com.tangem.wallet.R
-import kotlinx.coroutines.launch
-
-@OptIn(ExperimentalMaterialApi::class)
-@Composable
-fun AddCustomTokenScreen(state: MutableState<AddCustomTokenState>, closePopupTrigger: ClosePopupTrigger) {
-    val selectedTestCase = remember { mutableStateOf(TestCase.ContractAddress) }
-
-    val bottomSheetScaffoldState = rememberBottomSheetScaffoldState(
-        bottomSheetState = BottomSheetState(BottomSheetValue.Collapsed),
-    )
-    val coroutineScope = rememberCoroutineScope()
-    val toggleBottomSheet = { coroutineScope.launch { bottomSheetScaffoldState.toggle() } }
-
-    BottomSheetScaffold(
-        scaffoldState = bottomSheetScaffoldState,
-        sheetContent = {
-            Surface(color = colorResource(id = R.color.lightGray5)) {
-                selectedTestCase.value.content(toggleBottomSheet)
-            }
-        },
-        sheetPeekHeight = 0.dp,
-    ) {
-        Column {
-            TestCasesList(
-                onItemClick = {
-                    selectedTestCase.value = it
-                    toggleBottomSheet()
-                },
-            )
-            ScreenContent(state, closePopupTrigger)
-        }
-    }
-
-    ComposeDialogManager()
-    LaunchedEffect(key1 = Unit, block = { domainStore.dispatch(AddCustomTokenAction.OnCreate) })
-    DisposableEffect(key1 = Unit, effect = { onDispose { domainStore.dispatch(AddCustomTokenAction.OnDestroy) } })
-}
-
-@OptIn(ExperimentalMaterialApi::class)
-private suspend fun BottomSheetScaffoldState.toggle() {
-    if (bottomSheetState.isCollapsed) {
-        bottomSheetState.expand()
-    } else {
-        bottomSheetState.collapse()
-    }
-}
-
-@Composable
-private fun ScreenContent(state: MutableState<AddCustomTokenState>, closePopupTrigger: ClosePopupTrigger) {
-    val scaffoldState = rememberScaffoldState()
-
-    Scaffold(
-        scaffoldState = scaffoldState,
-        backgroundColor = colorResource(id = R.color.backgroundLightGray),
-        floatingActionButton = {
-            HangingOverKeyboardView(keyboardState = keyboardAsState()) {
-                AddButton(state)
-            }
-        },
-        floatingActionButtonPosition = FabPosition.Center,
-    ) { paddings ->
-        Box(
-            modifier = Modifier
-                .padding(paddings)
-                .fillMaxSize(),
-        ) {
-            LazyColumn(
-                contentPadding = PaddingValues(bottom = 90.dp),
-            ) {
-                item {
-                    Surface(
-                        modifier = Modifier.padding(16.dp),
-                        shape = MaterialTheme.shapes.small,
-                        elevation = 4.dp,
-                    ) {
-                        Column(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(16.dp),
-                        ) {
-                            FormFields(state, closePopupTrigger)
-                        }
-                    }
-                }
-                item { Warnings(state.value.warnings.toList()) }
-            }
-        }
-    }
-}
-
-@Composable
-private fun FormFields(state: MutableState<AddCustomTokenState>, closePopupTrigger: ClosePopupTrigger) {
-    val context = LocalContext.current
-    val errorConverter = remember { ModuleMessageConverter(context) }
-
-    val stateValue = state.value
-    stateValue.form.fieldList.forEach { field ->
-        val data = ScreenFieldData.fromState(field, stateValue, errorConverter)
-        when (field.id) {
-            ContractAddress -> TokenContractAddressView(data)
-            Network -> TokenNetworkView(data, stateValue, closePopupTrigger)
-            Name -> TokenNameView(data)
-            Symbol -> TokenSymbolView(data)
-            Decimals -> TokenDecimalsView(data)
-            DerivationPath -> TokenDerivationPathView(data, stateValue, closePopupTrigger)
-        }
-    }
-}
-
-@Composable
-fun Warnings(warnings: List<AddCustomTokenError.Warning>) {
-    if (warnings.isEmpty()) return
-
-    val context = LocalContext.current
-    val warningConverter = remember { ModuleMessageConverter(context) }
-
-    Column {
-        warnings.forEachIndexed { index, item ->
-            val modifier = when (index) {
-                0 -> Modifier.padding(vertical = 0.dp)
-                warnings.lastIndex -> Modifier.padding(top = 8.dp, bottom = 16.dp)
-                else -> Modifier.padding(top = 8.dp, bottom = 0.dp)
-            }
-            AddCustomTokenWarning(
-                modifier = modifier
-                    .padding(horizontal = TangemTheme.dimens.spacing16)
-                    .fillMaxWidth(),
-                warning = item,
-                converter = warningConverter,
-            )
-        }
-    }
-}
-
-@Composable
-private fun AddButton(state: MutableState<AddCustomTokenState>) {
-    PrimaryButtonIconStart(
-        modifier = Modifier
-            .padding(horizontal = TangemTheme.dimens.spacing16)
-            .fillMaxWidth(),
-        text = stringResource(id = R.string.common_add),
-        iconResId = R.drawable.ic_plus_24,
-        enabled = state.value.screenState.addButton.isEnabled,
-        onClick = { domainStore.dispatch(AddCustomTokenAction.OnAddCustomTokenClicked) },
-    )
-}
-
-data class ScreenFieldData(
-    val field: DataField<*>,
-    val error: AddCustomTokenError?,
-    val errorConverter: ModuleMessageConverter,
-    val viewState: ViewStates.TokenField,
-) {
-    companion object {
-        fun fromState(
-            field: DataField<*>,
-            state: AddCustomTokenState,
-            errorConverter: ModuleMessageConverter,
-        ): ScreenFieldData {
-            return ScreenFieldData(
-                field = field,
-                error = state.getError(field.id),
-                errorConverter = errorConverter,
-                viewState = selectField(field.id, state.screenState),
-            )
-        }
-
-        private fun selectField(id: FieldId, screenState: ScreenState): ViewStates.TokenField {
-            return when (id) {
-                ContractAddress -> screenState.contractAddressField
-                Network -> screenState.network
-                Name -> screenState.name
-                Symbol -> screenState.symbol
-                Decimals -> screenState.decimals
-                DerivationPath -> screenState.derivationPath
-                else -> throw UnsupportedOperationException()
-            }
-        }
-    }
-}

app/src/main/java/com/tangem/tap/features/customtoken/legacy/compose/BlockchainSpinner.kt

@@ -1,33 +0,0 @@
-package com.tangem.tap.features.customtoken.legacy.compose
-
-import androidx.annotation.StringRes
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.domain.common.form.Field
-
-@Composable
-fun BlockchainSpinner(
-    @StringRes title: Int,
-    itemList: List<Blockchain>,
-    selectedItem: Field.Data<Blockchain>,
-    isEnabled: Boolean = true,
-    textFieldConverter: (Blockchain) -> String,
-    dropdownItemView: @Composable ((Blockchain) -> Unit)? = null,
-    closePopupTrigger: ClosePopupTrigger = ClosePopupTrigger(),
-    onItemSelect: (Blockchain) -> Unit,
-) {
-    OutlinedSpinner(
-        modifier = Modifier.fillMaxWidth(),
-        label = stringResource(id = title),
-        itemList = itemList,
-        selectedItem = selectedItem,
-        textFieldConverter = textFieldConverter,
-        dropdownItemView = dropdownItemView,
-        isEnabled = isEnabled,
-        onItemSelected = onItemSelect,
-        closePopupTrigger = closePopupTrigger,
-    )
-}

app/src/main/java/com/tangem/tap/features/customtoken/legacy/compose/ComposeDialogManager.kt

@@ -1,157 +0,0 @@
-package com.tangem.tap.features.customtoken.legacy.compose
-
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.material.AlertDialog
-import androidx.compose.material.Button
-import androidx.compose.material.LocalTextStyle
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Surface
-import androidx.compose.material.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.window.Dialog
-import androidx.compose.ui.window.DialogProperties
-import com.tangem.core.ui.components.SpacerH16
-import com.tangem.core.ui.res.TangemTheme
-import com.tangem.datasource.api.tangemTech.models.CoinsResponse
-import com.tangem.domain.DomainDialog
-import com.tangem.domain.redux.domainStore
-import com.tangem.domain.redux.global.DomainGlobalAction
-import com.tangem.domain.redux.global.DomainGlobalState
-import com.tangem.tap.domain.moduleMessage.ModuleMessageConverter
-import com.tangem.wallet.R
-import org.rekotlin.StoreSubscriber
-
-@Composable
-internal fun ComposeDialogManager() {
-    val dialogSate = remember { mutableStateOf<DomainDialog?>(null) }
-    val subscriber = remember {
-        object : StoreSubscriber<DomainGlobalState> {
-            override fun newState(state: DomainGlobalState) {
-                dialogSate.value = state.dialog
-            }
-        }
-    }
-
-    ShowTheDialog(dialogSate)
-
-    LaunchedEffect(
-        key1 = Unit,
-        block = {
-            domainStore.subscribe(subscriber) { state ->
-                state.skipRepeats { oldState, newState ->
-                    oldState.globalState == newState.globalState
-                }.select { it.globalState }
-            }
-        },
-    )
-    DisposableEffect(
-        key1 = Unit,
-        effect = {
-            onDispose { domainStore.unsubscribe(subscriber) }
-        },
-    )
-}
-
-@Composable
-private fun ShowTheDialog(dialogState: MutableState<DomainDialog?>) {
-    if (dialogState.value == null) return
-
-    val context = LocalContext.current
-    val errorConverter = remember { ModuleMessageConverter(context) }
-    val onDismissRequest = { domainStore.dispatch(DomainGlobalAction.ShowDialog(null)) }
-
-    when (val dialog = dialogState.value) {
-        is DomainDialog.DialogError -> ErrorDialog(
-            title = stringResource(id = R.string.common_error),
-            body = errorConverter.convert(dialog.error).message,
-            onDismissRequest,
-        )
-        is DomainDialog.SelectTokenDialog -> SelectTokenNetworkDialog(dialog, onDismissRequest)
-        else -> {}
-    }
-}
-
-/**
- * Dialog with single item selection
- */
-@Composable
-fun SimpleDialog(
-    title: String,
-    items: List<CoinsResponse.Coin.Network>,
-    onSelect: (CoinsResponse.Coin.Network) -> Unit,
-    onDismissRequest: () -> Unit,
-    itemContent: @Composable (CoinsResponse.Coin.Network) -> Unit,
-) {
-    Dialog(
-        properties = DialogProperties(dismissOnBackPress = false, dismissOnClickOutside = false),
-        onDismissRequest = { },
-    ) {
-        Surface(modifier = Modifier.fillMaxWidth(), shape = MaterialTheme.shapes.medium) {
-            Column(modifier = Modifier.padding(TangemTheme.dimens.spacing22)) {
-                DialogTitle(title = title)
-                LazyColumn {
-                    items(items = items, key = CoinsResponse.Coin.Network::networkId) { item ->
-                        Row(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .height(56.dp)
-                                .clickable {
-                                    onSelect(item)
-                                    onDismissRequest()
-                                },
-                            verticalAlignment = Alignment.CenterVertically,
-                        ) { itemContent(item) }
-                    }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun DialogTitle(title: String) {
-    Text(
-        text = title,
-        style = LocalTextStyle.provides(
-            TextStyle(
-                fontWeight = FontWeight.Bold,
-                fontSize = 20.sp,
-            ),
-        ).value,
-    )
-    SpacerH16()
-}
-
-@Composable
-fun ErrorDialog(title: String, body: String, onDismissRequest: () -> Unit) {
-    AlertDialog(
-        title = { DialogTitle(title) },
-        text = { Text(body) },
-        onDismissRequest = onDismissRequest,
-        confirmButton = {
-            Button(onClick = onDismissRequest) {
-                Text(text = stringResource(id = R.string.common_ok))
-            }
-        },
-    )
-}

app/src/main/java/com/tangem/tap/features/customtoken/legacy/compose/FormFieldViews.kt

@@ -1,149 +0,0 @@
-package com.tangem.tap.features.customtoken.legacy.compose
-
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.input.KeyboardType
-import com.tangem.core.ui.components.SpacerH8
-import com.tangem.domain.common.form.Field
-import com.tangem.domain.features.addCustomToken.TokenBlockchainField
-import com.tangem.domain.features.addCustomToken.TokenDerivationPathField
-import com.tangem.domain.features.addCustomToken.TokenField
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenAction.OnTokenContractAddressChanged
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenAction.OnTokenDecimalsChanged
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenAction.OnTokenDerivationPathChanged
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenAction.OnTokenNameChanged
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenAction.OnTokenNetworkChanged
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenAction.OnTokenSymbolChanged
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenState
-import com.tangem.domain.redux.domainStore
-import com.tangem.tap.common.compose.OutlinedTextFieldWidget
-import com.tangem.tap.common.compose.TitleSubtitle
-import com.tangem.wallet.R
-
-/**
-[REDACTED_AUTHOR]
- */
-@Composable
-fun TokenContractAddressView(screenFieldData: ScreenFieldData) {
-    if (!screenFieldData.viewState.isVisible) return
-
-    val tokenField = screenFieldData.field as TokenField
-
-    OutlinedTextFieldWidget(
-        fieldData = tokenField.data,
-        labelId = R.string.custom_token_contract_address_input_title,
-        placeholder = "0x0000000000000000000000000000000000000000",
-        isEnabled = screenFieldData.viewState.isEnabled,
-        isLoading = screenFieldData.viewState.isLoading,
-        error = screenFieldData.error,
-        errorConverter = screenFieldData.errorConverter,
-//        trailingIcon = { PasteClearButton(showFirst = tokenField.data.value.isEmpty()) }
-    ) {
-        domainStore.dispatch(OnTokenContractAddressChanged(Field.Data(it, true)))
-    }
-    SpacerH8()
-}
-
-@Composable
-fun TokenNameView(screenFieldData: ScreenFieldData) {
-    if (!screenFieldData.viewState.isVisible) return
-
-    val tokenField = screenFieldData.field as TokenField
-
-    OutlinedTextFieldWidget(
-        fieldData = tokenField.data,
-        labelId = R.string.custom_token_name_input_title,
-        placeholderId = R.string.custom_token_name_input_placeholder,
-        isEnabled = screenFieldData.viewState.isEnabled,
-        error = screenFieldData.error,
-        errorConverter = screenFieldData.errorConverter,
-    ) {
-        domainStore.dispatch(OnTokenNameChanged(Field.Data(it, true)))
-    }
-    SpacerH8()
-}
-
-@Composable
-fun TokenNetworkView(
-    screenFieldData: ScreenFieldData,
-    state: AddCustomTokenState,
-    closePopupTrigger: ClosePopupTrigger,
-) {
-    if (!screenFieldData.viewState.isVisible) return
-
-    val notSelected = stringResource(id = R.string.custom_token_network_input_not_selected)
-    val networkField = screenFieldData.field as TokenBlockchainField
-
-    BlockchainSpinner(
-        title = R.string.custom_token_network_input_title,
-        itemList = networkField.itemList,
-        selectedItem = networkField.data,
-        isEnabled = screenFieldData.viewState.isEnabled,
-        textFieldConverter = { state.blockchainToName(it) ?: notSelected },
-        closePopupTrigger = closePopupTrigger,
-    ) { domainStore.dispatch(OnTokenNetworkChanged(Field.Data(it, true))) }
-    SpacerH8()
-}
-
-@Composable
-fun TokenSymbolView(screenFieldData: ScreenFieldData) {
-    if (!screenFieldData.viewState.isVisible) return
-
-    val tokenField = screenFieldData.field as TokenField
-
-    OutlinedTextFieldWidget(
-        fieldData = tokenField.data,
-        labelId = R.string.custom_token_token_symbol_input_title,
-        placeholderId = R.string.custom_token_token_symbol_input_placeholder,
-        isEnabled = screenFieldData.viewState.isEnabled,
-        error = screenFieldData.error,
-        errorConverter = screenFieldData.errorConverter,
-    ) { domainStore.dispatch(OnTokenSymbolChanged(Field.Data(it, true))) }
-    SpacerH8()
-}
-
-@Composable
-fun TokenDecimalsView(screenFieldData: ScreenFieldData) {
-    if (!screenFieldData.viewState.isVisible) return
-
-    val tokenField = screenFieldData.field as TokenField
-
-    OutlinedTextFieldWidget(
-        fieldData = tokenField.data,
-        labelId = R.string.custom_token_decimals_input_title,
-        placeholder = "8",
-        isEnabled = screenFieldData.viewState.isEnabled,
-        error = screenFieldData.error,
-        errorConverter = screenFieldData.errorConverter,
-        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-    ) { domainStore.dispatch(OnTokenDecimalsChanged(Field.Data(it, true))) }
-    SpacerH8()
-}
-
-@Composable
-fun TokenDerivationPathView(
-    screenFieldData: ScreenFieldData,
-    state: AddCustomTokenState,
-    closePopupTrigger: ClosePopupTrigger,
-) {
-    if (!screenFieldData.viewState.isVisible) return
-
-    val notSelected = stringResource(id = R.string.custom_token_derivation_path_default)
-    val networkField = screenFieldData.field as TokenDerivationPathField
-
-    BlockchainSpinner(
-        title = R.string.custom_token_derivation_path_input_title,
-        itemList = networkField.itemList,
-        selectedItem = networkField.data,
-        isEnabled = screenFieldData.viewState.isEnabled,
-        textFieldConverter = { state.blockchainToName(it) ?: notSelected },
-        dropdownItemView = { blockchain ->
-            val derivationPathName = state.blockchainToName(blockchain, true) ?: notSelected
-            val blockchainName = state.blockchainToName(blockchain) ?: notSelected
-            TitleSubtitle(derivationPathName, blockchainName)
-        },
-        closePopupTrigger = closePopupTrigger,
-    ) { domainStore.dispatch(OnTokenDerivationPathChanged(Field.Data(it, true))) }
-    SpacerH8()
-}

app/src/main/java/com/tangem/tap/features/customtoken/legacy/compose/HangingOverKeyboardView.kt

@@ -1,32 +0,0 @@
-package com.tangem.tap.features.customtoken.legacy.compose
-
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.BoxScope
-import androidx.compose.foundation.layout.padding
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.State
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import com.tangem.core.ui.components.Keyboard
-
-/**
-[REDACTED_AUTHOR]
- */
-@Composable
-fun HangingOverKeyboardView(
-    modifier: Modifier = Modifier,
-    keyboardState: State<Keyboard>,
-    spaceBetweenKeyboard: Dp = 0.dp,
-    content: @Composable (BoxScope.() -> Unit),
-) {
-    val padding = remember(keyboardState) {
-        when (val state = keyboardState.value) {
-            is Keyboard.Closed -> 0.dp
-            is Keyboard.Opened -> state.height + spaceBetweenKeyboard
-        }
-    }
-
-    Box(modifier.padding(bottom = padding)) { content() }
-}

app/src/main/java/com/tangem/tap/features/customtoken/legacy/compose/OutlinedSpinner.kt

@@ -1,103 +0,0 @@
-package com.tangem.tap.features.customtoken.legacy.compose
-
-import android.os.Handler
-import android.os.Looper
-import androidx.compose.material.*
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.key
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.core.os.postDelayed
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.common.extensions.VoidCallback
-import com.tangem.domain.common.form.Field
-import com.tangem.tap.common.compose.TangemTextFieldsDefault
-import com.tangem.tap.common.extensions.ValueCallback
-
-/**
-[REDACTED_AUTHOR]
- */
-@Suppress("MagicNumber")
-@OptIn(ExperimentalMaterialApi::class)
-@Composable
-internal fun <T> OutlinedSpinner(
-    label: String,
-    itemList: List<T>,
-    selectedItem: Field.Data<T>,
-    onItemSelected: ValueCallback<T>,
-    modifier: Modifier = Modifier,
-    textFieldConverter: (T) -> String = { it.toString() },
-    dropdownItemView: @Composable ((T) -> Unit)? = null,
-    isEnabled: Boolean = true,
-    onClose: VoidCallback = {},
-    closePopupTrigger: ClosePopupTrigger = ClosePopupTrigger(),
-) {
-    val rIsExpanded = remember { mutableStateOf(false) }
-    val stateSelectedItem = remember { mutableStateOf(selectedItem.value) }
-    if (!selectedItem.isUserInput) {
-        stateSelectedItem.value = selectedItem.value
-    }
-
-    val onDropDownItemSelectedInternal: (T) -> Unit = {
-        stateSelectedItem.value = it
-        rIsExpanded.value = false
-        onItemSelected(it)
-    }
-    val onDismissRequest = {
-        rIsExpanded.value = false
-        onClose()
-    }
-
-    closePopupTrigger.close = {
-        onDismissRequest()
-        Handler(Looper.getMainLooper()).postDelayed(100) {
-            closePopupTrigger.onCloseComplete()
-        }
-    }
-
-    ExposedDropdownMenuBox(
-        expanded = rIsExpanded.value,
-        onExpandedChange = { rIsExpanded.value = !rIsExpanded.value },
-    ) {
-        OutlinedTextField(
-            modifier = modifier,
-            readOnly = true,
-            enabled = isEnabled,
-            value = textFieldConverter(stateSelectedItem.value),
-            onValueChange = {},
-            label = { Text(label) },
-            trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = rIsExpanded.value) },
-            colors = TangemTextFieldsDefault.defaultTextFieldColors,
-        )
-
-        if (isEnabled) {
-            ExposedDropdownMenu(expanded = rIsExpanded.value, onDismissRequest = onDismissRequest) {
-                itemList.forEach { item ->
-                    key(item) {
-                        DropdownMenuItem(onClick = { onDropDownItemSelectedInternal(item) }) {
-                            if (dropdownItemView == null) Text(textFieldConverter(item)) else dropdownItemView(item)
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-class ClosePopupTrigger {
-    var close: () -> Unit = {}
-    var onCloseComplete: () -> Unit = {}
-}
-
-@Preview
-@Composable
-private fun TestSpinnerPreview() {
-    OutlinedSpinner(
-        label = "Blockchain name",
-        itemList = listOf(Blockchain.values()),
-        selectedItem = Field.Data(Blockchain.Avalanche, false),
-        onItemSelected = {},
-    )
-}

app/src/main/java/com/tangem/tap/features/customtoken/legacy/compose/SelectTokenNetworkDialog.kt

@@ -1,20 +0,0 @@
-package com.tangem.tap.features.customtoken.legacy.compose
-
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.res.stringResource
-import com.tangem.domain.DomainDialog
-import com.tangem.tap.common.compose.TitleSubtitle
-import com.tangem.wallet.R
-
-/**
-[REDACTED_AUTHOR]
- */
-@Composable
-fun SelectTokenNetworkDialog(dialog: DomainDialog.SelectTokenDialog, onDismissRequest: () -> Unit) {
-    SimpleDialog(
-        title = stringResource(id = R.string.custom_token_network_input_title),
-        items = dialog.items,
-        onSelect = dialog.onSelect,
-        onDismissRequest = onDismissRequest,
-    ) { network -> TitleSubtitle(dialog.networkIdConverter(network.networkId), network.contractAddress ?: "") }
-}

app/src/main/java/com/tangem/tap/features/customtoken/legacy/compose/test/ContractAddressTests.kt

@@ -1,120 +0,0 @@
-package com.tangem.tap.features.customtoken.legacy.compose.test
-
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.material.Button
-import androidx.compose.material.Divider
-import androidx.compose.material.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.common.extensions.VoidCallback
-import com.tangem.domain.common.form.Field
-import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenAction
-import com.tangem.domain.redux.domainStore
-
-/**
-[REDACTED_AUTHOR]
- */
-@Composable
-fun ContractAddressTests(onItemClick: VoidCallback) {
-    val casesInfo = listOf(
-        "USDC on ETH" to "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
-        "BUSD on ETH" to "0x4fabb145d64652a948d72533023f6e7a623c7c53",
-        "ETH on AVALANCHE" to "0xf20d962a6c8f70c731bd838a3a388d7d48fa6e15",
-        "USDC on ETH (invalid - cut address)" to "0xa0b86991c6218b36c1d1",
-        "Custom EVM" to "0x1111111111111111112111111111111111111113",
-        "Supported by several networks" to "0xa1faa113cbe53436df28ff0aee54275c13b40975",
-        "Invalid" to "!@#_  _-%%^&&*((){P P2iOWsdfFQLA",
-    )
-    CasesListContent(casesInfo, onItemClick)
-}
-
-@Composable
-fun SolanaAddressTests(onItemClick: VoidCallback) {
-    val casesInfo = listOf(
-        "USDT (full)" to "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
-        "USDT (valid - 2/3 of address)" to "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8Ben",
-        "USDT (invalid - 1/3 of address)" to "Es9vMFrzaCERmJ",
-        "ETH (full)" to "2FPyTwcZLUg1MDrwsyoP4D6s1tM7hAkHYRjkNb5w6Pxk",
-    )
-    CasesListContent(casesInfo, onItemClick)
-}
-
-@Composable
-private fun CasesListContent(casesList: List<Pair<String, String>>, onItemClick: VoidCallback) {
-    LazyColumn(
-        content = {
-            item {
-                Row {
-                    ResetContractAddressButton(onItemClick)
-                    Text("", modifier = Modifier.weight(1f))
-                    ResetAllFieldsButton(onItemClick)
-                }
-                Divider()
-            }
-            items(casesList.size) {
-                val (info, address) = casesList[it]
-                ContractAddressButton(info, address, onItemClick)
-            }
-        },
-    )
-}
-
-@Composable
-fun ResetAllFieldsButton(onItemClick: VoidCallback) {
-    ActionButton(
-        name = "Reset",
-        onClick = {
-            onItemClick()
-            domainStore.dispatch(AddCustomTokenAction.OnTokenContractAddressChanged(Field.Data("", false)))
-            domainStore.dispatch(AddCustomTokenAction.OnTokenNetworkChanged(Field.Data(Blockchain.Unknown, false)))
-            domainStore.dispatch(AddCustomTokenAction.OnTokenNameChanged(Field.Data("", false)))
-            domainStore.dispatch(AddCustomTokenAction.OnTokenSymbolChanged(Field.Data("", false)))
-            domainStore.dispatch(AddCustomTokenAction.OnTokenDecimalsChanged(Field.Data("", false)))
-            domainStore.dispatch(
-                AddCustomTokenAction.OnTokenDerivationPathChanged(
-                    Field.Data(
-                        Blockchain.Unknown,
-                        false,
-                    ),
-                ),
-            )
-        },
-    )
-}
-
-@Composable
-fun ResetContractAddressButton(onItemClick: VoidCallback) {
-    ActionButton(
-        name = "Set empty address",
-        onClick = {
-            onItemClick()
-            domainStore.dispatch(AddCustomTokenAction.OnTokenContractAddressChanged(Field.Data("", false)))
-        },
-    )
-}
-
-@Composable
-private fun ContractAddressButton(name: String, address: String, onItemClick: VoidCallback) {
-    ActionButton(
-        modifier = Modifier.fillMaxWidth(),
-        name = name,
-        onClick = {
-            onItemClick()
-            domainStore.dispatch(AddCustomTokenAction.OnTokenContractAddressChanged(Field.Data(address, false)))
-        },
-    )
-}
-
-@Composable
-fun ActionButton(name: String, onClick: () -> Unit, modifier: Modifier = Modifier) {
-    Button(
-        modifier = modifier.padding(horizontal = 8.dp),
-        onClick = onClick,
-    ) { Text(name, fontSize = 12.sp) }
-}

app/src/main/java/com/tangem/tap/features/customtoken/legacy/compose/test/TestCasesList.kt

@@ -1,53 +0,0 @@
-package com.tangem.tap.features.customtoken.legacy.compose.test
-
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material.Button
-import androidx.compose.material.Surface
-import androidx.compose.material.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.colorResource
-import androidx.compose.ui.unit.dp
-import com.tangem.common.extensions.VoidCallback
-import com.tangem.wallet.BuildConfig
-import com.tangem.wallet.R
-
-/**
-[REDACTED_AUTHOR]
- */
-@Composable
-fun TestCasesList(onItemClick: (TestCase) -> Unit) {
-    if (!BuildConfig.TEST_ACTION_ENABLED) return
-
-    Surface(color = colorResource(id = R.color.lightGray5)) {
-        Column(Modifier.padding(horizontal = 16.dp)) {
-            listOf(TestCase.ContractAddress, TestCase.SolanaTokens)
-                .map { case -> TestCaseListItem(testCase = case, onItemClick = { onItemClick(case) }) }
-        }
-    }
-}
-
-@Composable
-fun TestCaseListItem(testCase: TestCase, onItemClick: () -> Unit) {
-    Row(
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Text(
-            modifier = Modifier.weight(1f),
-            text = testCase.description,
-        )
-        Button(
-            onClick = onItemClick,
-        ) { Text("Start") }
-    }
-}
-
-enum class TestCase(val description: String, val content: @Composable (VoidCallback) -> Unit) {
-    ContractAddress("Test contract address field", { ContractAddressTests(it) }),
-    Auto("Test contract address field", { ContractAddressTests(it) }),
-    SolanaTokens("Test Solana contract addresses", { SolanaAddressTests(it) }),
-    ;
-}

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

@@ -0,0 +1,10 @@
+package com.tangem.tap.features.details
+
+import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
+
+class DarkThemeFeatureToggle(
+    private val featureTogglesManager: FeatureTogglesManager,
+) {
+    val isDarkThemeEnabled: Boolean
+        get() = featureTogglesManager.isFeatureEnabled(name = "DARK_THEME_ENABLED")
+}

app/src/main/java/com/tangem/tap/features/details/featuretoggles/DefaultDetailsFeatureToggles.kt

@@ -0,0 +1,11 @@
+package com.tangem.tap.features.details.featuretoggles
+
+import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
+
+internal class DefaultDetailsFeatureToggles(
+    private val featureTogglesManager: FeatureTogglesManager,
+) : DetailsFeatureToggles {
+
+    override val isRedesignedAppCurrencySelectorEnabled: Boolean
+        get() = featureTogglesManager.isFeatureEnabled(name = "REDESIGNED_APP_CURRENCY_SELECTOR_ENABLED")
+}

app/src/main/java/com/tangem/tap/features/details/featuretoggles/DetailsFeatureToggles.kt

@@ -0,0 +1,6 @@
+package com.tangem.tap.features.details.featuretoggles
+
+interface DetailsFeatureToggles {
+
+    val isRedesignedAppCurrencySelectorEnabled: Boolean
+}

app/src/main/java/com/tangem/tap/features/details/featuretoggles/DetailsFeatureTogglesModule.kt

@@ -0,0 +1,17 @@
+package com.tangem.tap.features.details.featuretoggles
+
+import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object DetailsFeatureTogglesModule {
+
+    @Provides
+    fun provideDetailsFeatureToggles(featureTogglesManager: FeatureTogglesManager): DetailsFeatureToggles {
+        return DefaultDetailsFeatureToggles(featureTogglesManager)
+    }
+}