Updated on 2026-08-14

2026-03-18 11:14:19 +03:00 · 2026-03-18 11:14:19 +03:00 · 5ed27120af
commit 5ed27120af
parent 863d12763d 43a0fcf9b1
993 changed files with 26588 additions and 31466 deletions
--- a/app/src/main/java/com/tangem/tap/ApplicationEntryPoint.kt
+++ b/app/src/main/java/com/tangem/tap/ApplicationEntryPoint.kt
@ -19,7 +19,7 @@ import com.tangem.core.ui.clipboard.ClipboardManager
 import com.tangem.data.card.TransactionSignerFactory
 import com.tangem.datasource.api.common.config.managers.ApiConfigsManager
 import com.tangem.datasource.connection.NetworkConnectionManager
-import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
+import com.tangem.datasource.local.config.environment.EnvironmentConfig
 import com.tangem.datasource.local.config.issuers.IssuersConfigStorage
 import com.tangem.datasource.local.logs.AppLogsStore
 import com.tangem.datasource.local.preferences.AppPreferencesStore
@ -43,12 +43,12 @@ import com.tangem.domain.wallets.builder.ColdUserWalletBuilder
 import com.tangem.domain.wallets.repository.WalletsRepository
 import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
 import com.tangem.hot.sdk.TangemHotSdk
+import com.tangem.tap.common.analytics.CustomerIoFeatureToggles
 import com.tangem.tap.common.analytics.handlers.BlockchainExceptionHandler
 import com.tangem.tap.common.analytics.handlers.appsflyer.AppsFlyerClient
 import com.tangem.tap.common.log.TangemAppLoggerInitializer
 import com.tangem.tap.domain.scanCard.CardScanningFeatureToggles
 import com.tangem.tap.proxy.AppStateHolder
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.hilt.EntryPoint
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
@ -58,12 +58,12 @@ import dagger.hilt.components.SingletonComponent
@Suppress("TooManyFunctions")
 interface ApplicationEntryPoint {

-    fun getEnvironmentConfigStorage(): EnvironmentConfigStorage
-
    fun getAppStateHolder(): AppStateHolder

    fun getIssuersConfigStorage(): IssuersConfigStorage

+    fun getEnvironmentConfig(): EnvironmentConfig
+
    fun getFeatureTogglesManager(): FeatureTogglesManager

    fun getExcludedBlockchainsManager(): ExcludedBlockchainsManager
@ -120,8 +120,6 @@ interface ApplicationEntryPoint {

    fun getOnboardingRepository(): OnboardingRepository

-    fun getCoroutineDispatcherProvider(): CoroutineDispatcherProvider
-
    fun getExcludedBlockchains(): ExcludedBlockchains

    fun getAppLogsStore(): AppLogsStore
@ -154,4 +152,6 @@ interface ApplicationEntryPoint {
    fun getABTestsManager(): ABTestsManager

    fun getAppsFlyerClientFactory(): AppsFlyerClient.Factory
+
+    fun getCustomerIoFeatureToggles(): CustomerIoFeatureToggles
 }
--- a/app/src/main/java/com/tangem/tap/MainActivity.kt
+++ b/app/src/main/java/com/tangem/tap/MainActivity.kt
@ -44,7 +44,6 @@ import com.tangem.domain.settings.ShouldInitiallyAskPermissionUseCase
 import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.staking.SendUnsubmittedHashesUseCase
 import com.tangem.domain.wallets.usecase.ClearAllHotWalletContextualUnlockUseCase
-import com.tangem.features.tangempay.TangemPayFeatureToggles
 import com.tangem.features.tester.api.TesterMenuLauncher
 import com.tangem.google.GoogleServicesHelper
 import com.tangem.operations.backup.BackupService
@ -161,9 +160,6 @@ class MainActivity : AppCompatActivity(), ActivityResultCallbackHolder {
    @Inject
    internal lateinit var clearAllHotWalletContextualUnlockUseCase: ClearAllHotWalletContextualUnlockUseCase

-    @Inject
-    internal lateinit var tangemPayFeatureToggles: TangemPayFeatureToggles
-
    private val viewModel: MainViewModel by viewModels()

    private lateinit var appThemeModeFlow: SharedFlow<AppThemeMode>
--- a/app/src/main/java/com/tangem/tap/TangemApplication.kt
+++ b/app/src/main/java/com/tangem/tap/TangemApplication.kt
@ -36,7 +36,6 @@ import com.tangem.datasource.api.common.config.managers.ApiConfigsManager
 import com.tangem.datasource.api.common.createNetworkLoggingInterceptor
 import com.tangem.datasource.connection.NetworkConnectionManager
 import com.tangem.datasource.local.config.environment.EnvironmentConfig
-import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
 import com.tangem.datasource.local.config.issuers.IssuersConfigStorage
 import com.tangem.datasource.local.logs.AppLogsStore
 import com.tangem.datasource.local.preferences.AppPreferencesStore
@ -62,34 +61,32 @@ import com.tangem.domain.wallets.repository.WalletsRepository
 import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
 import com.tangem.operations.attestation.api.TangemApiServiceSettings
 import com.tangem.tap.common.analytics.AnalyticsFactory
+import com.tangem.tap.common.analytics.CustomerIoFeatureToggles
 import com.tangem.tap.common.analytics.api.AnalyticsHandlerBuilder
 import com.tangem.tap.common.analytics.handlers.BlockchainExceptionHandler
 import com.tangem.tap.common.analytics.handlers.amplitude.AmplitudeAnalyticsHandler
 import com.tangem.tap.common.analytics.handlers.appsflyer.AppsFlyerAnalyticsHandler
 import com.tangem.tap.common.analytics.handlers.appsflyer.AppsFlyerClient
+import com.tangem.tap.common.analytics.handlers.customerio.CustomerIoAnalyticsHandler
 import com.tangem.tap.common.analytics.handlers.firebase.FirebaseAnalyticsHandler
 import com.tangem.tap.common.images.createCoilImageLoader
 import com.tangem.tap.common.log.TangemAppLoggerInitializer
 import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.common.redux.appReducer
 import com.tangem.tap.domain.scanCard.CardScanningFeatureToggles
-import com.tangem.tap.domain.tasks.product.DerivationsFinder
 import com.tangem.tap.proxy.AppStateHolder
 import com.tangem.tap.proxy.redux.DaggerGraphState
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.wallet.BuildConfig
 import dagger.hilt.EntryPoints
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.MainScope
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
 import org.rekotlin.Store
 import timber.log.Timber

 lateinit var store: Store<AppState>

 val foregroundActivityObserver = ForegroundActivityObserver
-internal lateinit var derivationsFinder: DerivationsFinder

 open class TangemApplication : Application(), ImageLoaderFactory, Configuration.Provider {

@ -100,12 +97,12 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
    private val appStateHolder: AppStateHolder
        get() = entryPoint.getAppStateHolder()

-    private val environmentConfigStorage: EnvironmentConfigStorage
-        get() = entryPoint.getEnvironmentConfigStorage()
-
    private val issuersConfigStorage: IssuersConfigStorage
        get() = entryPoint.getIssuersConfigStorage()

+    private val environmentConfig: EnvironmentConfig
+        get() = entryPoint.getEnvironmentConfig()
+
    private val featureTogglesManager: FeatureTogglesManager
        get() = entryPoint.getFeatureTogglesManager()

@ -190,9 +187,6 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
    private val onboardingRepository: OnboardingRepository
        get() = entryPoint.getOnboardingRepository()

-    private val dispatchers: CoroutineDispatcherProvider
-        get() = entryPoint.getCoroutineDispatcherProvider()
-
    private val excludedBlockchains: ExcludedBlockchains
        get() = entryPoint.getExcludedBlockchains()

@ -246,6 +240,9 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
    private val appsFlyerClientFactory: AppsFlyerClient.Factory
        get() = entryPoint.getAppsFlyerClientFactory()

+    private val customerIoFeatureToggles: CustomerIoFeatureToggles
+        get() = entryPoint.getCustomerIoFeatureToggles()
+
    // endregion

    private val appScope = MainScope()
@ -312,9 +309,7 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
            Timber.i(excludedBlockchainsManager.toString())
        }

-        runBlocking {
-            initWithConfigDependency(environmentConfig = environmentConfigStorage.initialize())
-        }
+        initWithConfigDependency(environmentConfig = environmentConfig)

        abTestsManager.init()

@ -348,15 +343,10 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
            )
        }

-        derivationsFinder = DerivationsFinder(
-            userTokensResponseStore = userTokensResponseStore,
-            dispatchers = dispatchers,
-        )
-
        appStateHolder.mainStore = store

        wcInitializeUseCase.init(
-            projectId = environmentConfigStorage.getConfigSync().walletConnectProjectId,
+            projectId = environmentConfig.walletConnectProjectId,
        )
    }

@ -387,7 +377,6 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
                    shareManager = shareManager,
                    appRouter = appRouter,
                    transactionSignerFactory = transactionSignerFactory,
-                    environmentConfigStorage = environmentConfigStorage,
                    onboardingV2FeatureToggles = onboardingV2FeatureToggles,
                    onboardingRepository = onboardingRepository,
                    excludedBlockchains = excludedBlockchains,
@ -427,6 +416,10 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.
        factory.addHandlerBuilder(FirebaseAnalyticsHandler.Builder())
        factory.addHandlerBuilder(AppsFlyerAnalyticsHandler.Builder(appsFlyerClientFactory))

+        if (customerIoFeatureToggles.isFeatureEnabled) {
+            factory.addHandlerBuilder(CustomerIoAnalyticsHandler.Builder())
+        }
+
        factory.addFilter(oneTimeEventFilter)
        factory.addFilter(AppsFlyerEventFilter())

--- a/app/src/main/java/com/tangem/tap/common/analytics/CustomerIoFeatureToggles.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/CustomerIoFeatureToggles.kt
@ -0,0 +1,12 @@
+package com.tangem.tap.common.analytics
+
+import com.tangem.core.configtoggle.feature.FeatureTogglesManager
+import javax.inject.Inject
+
+class CustomerIoFeatureToggles @Inject constructor(
+    private val featureTogglesManager: FeatureTogglesManager,
+) {
+
+    val isFeatureEnabled: Boolean
+        get() = featureTogglesManager.isFeatureEnabled(name = "CUSTOMER_IO_ENABLED")
+}
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/customerio/CustomerIoAnalyticsClient.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/customerio/CustomerIoAnalyticsClient.kt
@ -0,0 +1,8 @@
+package com.tangem.tap.common.analytics.handlers.customerio
+
+import com.tangem.core.analytics.api.UserIdHolder
+
+/**
+ * Client interface for Customer.io SDK operations.
+ */
+interface CustomerIoAnalyticsClient : UserIdHolder
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/customerio/CustomerIoAnalyticsHandler.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/customerio/CustomerIoAnalyticsHandler.kt
@ -0,0 +1,51 @@
+package com.tangem.tap.common.analytics.handlers.customerio
+
+import com.tangem.core.analytics.api.AnalyticsHandler
+import com.tangem.core.analytics.api.AnalyticsUserIdHandler
+import com.tangem.core.analytics.models.AnalyticsEvent
+import com.tangem.tap.common.analytics.api.AnalyticsHandlerBuilder
+
+/**
+ * Customer.io analytics handler.
+ */
+class CustomerIoAnalyticsHandler(
+    private val client: CustomerIoAnalyticsClient,
+) : AnalyticsHandler, AnalyticsUserIdHandler {
+
+    override fun id(): String = ID
+
+    override fun setUserId(userId: String) {
+        client.setUserId(userId)
+    }
+
+    override fun clearUserId() {
+        client.clearUserId()
+    }
+
+    override fun send(event: AnalyticsEvent) {
+        // No-op: product events are not sent to Customer.io.
+        // Triggers are configured to come from Amplitude directly.
+    }
+
+    companion object {
+        const val ID = "CustomerIO"
+    }
+
+    class Builder : AnalyticsHandlerBuilder {
+        override fun build(data: AnalyticsHandlerBuilder.Data): AnalyticsHandler? {
+            val cdpApiKey = data.config.customerIoCdpApiKey
+            return if (data.logConfig.isCustomerIoLogEnabled) {
+                CustomerIoAnalyticsHandler(client = CustomerIoLogClient())
+            } else if (!cdpApiKey.isNullOrBlank()) {
+                CustomerIoAnalyticsHandler(
+                    client = CustomerIoClient(
+                        application = data.application,
+                        cdpApiKey = cdpApiKey,
+                    ),
+                )
+            } else {
+                null
+            }
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/customerio/CustomerIoClient.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/customerio/CustomerIoClient.kt
@ -0,0 +1,45 @@
+package com.tangem.tap.common.analytics.handlers.customerio
+
+import android.app.Application
+import io.customer.messagingpush.ModuleMessagingPushFCM
+import io.customer.sdk.CustomerIO
+import io.customer.sdk.CustomerIOBuilder
+import io.customer.sdk.data.model.Region
+import timber.log.Timber
+
+/**
+ * Real Customer.io SDK client.
+ *
+ * Initializes the SDK with the given CDP API key and provides:
+ * - User identification (identify / clearIdentify)
+ *
+ * Auto-tracking of application lifecycle events is disabled since it is not needed.
+ * Auto-tracking of screen views is disabled.
+ */
+internal class CustomerIoClient(
+    application: Application,
+    cdpApiKey: String,
+) : CustomerIoAnalyticsClient {
+
+    init {
+        CustomerIOBuilder(
+            applicationContext = application,
+            cdpApiKey = cdpApiKey,
+        )
+            .region(Region.EU)
+            .trackApplicationLifecycleEvents(false)
+            .autoTrackActivityScreens(false)
+            .addCustomerIOModule(ModuleMessagingPushFCM())
+            .build()
+
+        Timber.d("CustomerIO SDK initialized")
+    }
+
+    override fun setUserId(userId: String) {
+        CustomerIO.instance().identify(userId = userId)
+    }
+
+    override fun clearUserId() {
+        CustomerIO.instance().clearIdentify()
+    }
+}
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/customerio/CustomerIoLogClient.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/customerio/CustomerIoLogClient.kt
@ -0,0 +1,23 @@
+package com.tangem.tap.common.analytics.handlers.customerio
+
+import timber.log.Timber
+
+/**
+ * Log client for Customer.io (used in debug mode).
+ *
+ * Logs all operations to Timber instead of sending them to Customer.io.
+ */
+internal class CustomerIoLogClient : CustomerIoAnalyticsClient {
+
+    private var userId: String? = null
+
+    override fun setUserId(userId: String) {
+        this.userId = userId
+        Timber.tag(CustomerIoAnalyticsHandler.ID).d("identify: userId=$userId")
+    }
+
+    override fun clearUserId() {
+        Timber.tag(CustomerIoAnalyticsHandler.ID).d("clearIdentify: previous userId=$userId")
+        this.userId = null
+    }
+}
--- a/app/src/main/java/com/tangem/tap/common/pushes/TangemPushNotificationService.kt
+++ b/app/src/main/java/com/tangem/tap/common/pushes/TangemPushNotificationService.kt
@ -3,11 +3,19 @@ package com.tangem.tap.common.pushes
 import android.annotation.SuppressLint
 import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
+import com.tangem.tap.common.analytics.CustomerIoFeatureToggles
+import dagger.hilt.android.AndroidEntryPoint
+import io.customer.messagingpush.CustomerIOFirebaseMessagingService
 import timber.log.Timber
+import javax.inject.Inject

+@AndroidEntryPoint
@SuppressLint("MissingFirebaseInstanceTokenRefresh")
 internal class TangemPushNotificationService : FirebaseMessagingService() {

+    @Inject
+    lateinit var customerIoFeatureToggles: CustomerIoFeatureToggles
+
    private val pushNotificationDelegate: PushNotificationDelegate by lazy {
        PushNotificationDelegate(applicationContext)
    }
@ -15,11 +23,19 @@ internal class TangemPushNotificationService : FirebaseMessagingService() {
    override fun onNewToken(token: String) {
        super.onNewToken(token)
        Timber.d("New FCM token received: $token")
+
+        if (customerIoFeatureToggles.isFeatureEnabled) {
+            CustomerIOFirebaseMessagingService.onNewToken(applicationContext, token)
+        }
    }

    override fun onMessageReceived(message: RemoteMessage) {
        super.onMessageReceived(message)

+        if (customerIoFeatureToggles.isFeatureEnabled) {
+            CustomerIOFirebaseMessagingService.onMessageReceived(applicationContext, message)
+        }
+
        val notification = message.notification ?: return
        val channelId = notification.channelId ?: TANGEM_CHANNEL_ID

--- a/app/src/main/java/com/tangem/tap/common/redux/AppState.kt
+++ b/app/src/main/java/com/tangem/tap/common/redux/AppState.kt
@ -6,7 +6,6 @@ import com.tangem.tap.common.redux.legacy.LegacyMiddleware
 import com.tangem.tap.features.details.redux.DetailsMiddleware
 import com.tangem.tap.features.details.redux.DetailsState
 import com.tangem.tap.features.onboarding.products.wallet.redux.BackupMiddleware
-import com.tangem.tap.features.wallet.redux.middlewares.TradeCryptoMiddleware
 import com.tangem.tap.proxy.redux.DaggerGraphMiddleware
 import com.tangem.tap.proxy.redux.DaggerGraphState
 import org.rekotlin.Middleware
@ -29,7 +28,6 @@ data class AppState(
                AccessCodeRequestPolicyMiddleware().middleware,
                DaggerGraphMiddleware.daggerGraphMiddleware,
                LegacyMiddleware.legacyMiddleware,
-                TradeCryptoMiddleware.middleware,
            )
        }
    }
--- a/app/src/main/java/com/tangem/tap/data/DefaultOfframpRepository.kt
+++ b/app/src/main/java/com/tangem/tap/data/DefaultOfframpRepository.kt
@ -0,0 +1,29 @@
+package com.tangem.tap.data
+
+import com.tangem.domain.models.currency.CryptoCurrency
+import com.tangem.domain.offramp.repository.OfframpRepository
+import com.tangem.tap.common.apptheme.MutableAppThemeModeHolder
+import com.tangem.tap.network.exchangeServices.SellService
+
+/**
+ * Default implementation of [OfframpRepository]
+ *
+ * @property sellService sell service for getting offramp URL
+ */
+internal class DefaultOfframpRepository(
+    private val sellService: SellService,
+) : OfframpRepository {
+
+    override fun getOfframpUrl(
+        cryptoCurrency: CryptoCurrency,
+        fiatCurrencyCode: String,
+        walletAddress: String,
+    ): String? {
+        return sellService.getUrl(
+            cryptoCurrency = cryptoCurrency,
+            fiatCurrencyName = fiatCurrencyCode,
+            walletAddress = walletAddress,
+            isDarkTheme = MutableAppThemeModeHolder.isDarkThemeActive,
+        )
+    }
+}
--- a/app/src/main/java/com/tangem/tap/data/DefaultTangemPayStorage.kt
+++ b/app/src/main/java/com/tangem/tap/data/DefaultTangemPayStorage.kt
@ -62,23 +62,19 @@ internal class DefaultTangemPayStorage @Inject constructor(
    }

    override suspend fun storeCustomerWalletAddress(userWalletId: UserWalletId, customerWalletAddress: String) {
-        withContext(dispatcherProvider.io) {
-            appPreferencesStore
-                .store(PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId), customerWalletAddress)
-        }
+        appPreferencesStore
+            .store(PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId), customerWalletAddress)
    }

    override suspend fun getCustomerWalletAddress(userWalletId: UserWalletId): String? {
-        return withContext(dispatcherProvider.io) {
-            appPreferencesStore.getSyncOrNull(key = PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId))
-                .takeIf { !it.isNullOrEmpty() }
-        }
+        return appPreferencesStore.getSyncOrNull(
+            key = PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId),
+        )
+            .takeIf { !it.isNullOrEmpty() }
    }

    override suspend fun clearCustomerWalletAddress(userWalletId: UserWalletId) {
-        withContext(dispatcherProvider.io) {
-            appPreferencesStore.store(PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId), "")
-        }
+        appPreferencesStore.store(PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId), "")
    }

    override suspend fun storeAuthTokens(customerWalletAddress: String, tokens: TangemPayAuthTokens) =
@ -92,58 +88,57 @@ internal class DefaultTangemPayStorage @Inject constructor(
        }

    override suspend fun getAuthTokens(customerWalletAddress: String): TangemPayAuthTokens? {
-        val authTokens = secureStorage.get(createAuthTokensKey(customerWalletAddress))
-            ?.decodeToString(throwOnInvalidSequence = true)
-            ?.let(tokensAdapter::fromJson)
+        return withContext(dispatcherProvider.io) {
+            val authTokens = secureStorage.get(createAuthTokensKey(customerWalletAddress))
+                ?.decodeToString(throwOnInvalidSequence = true)
+                ?.let(tokensAdapter::fromJson)

-        return authTokens?.let { tokens ->
-            if (tokens.idempotencyKey == null) {
-                val newAuthTokens = tokens.copy(idempotencyKey = UUID.randomUUID().toString())
-                storeAuthTokens(customerWalletAddress, newAuthTokens)
-                newAuthTokens
-            } else {
-                tokens
+            authTokens?.let { tokens ->
+                if (tokens.idempotencyKey == null) {
+                    val newAuthTokens = tokens.copy(idempotencyKey = UUID.randomUUID().toString())
+                    storeAuthTokens(customerWalletAddress, newAuthTokens)
+                    newAuthTokens
+                } else {
+                    tokens
+                }
            }
        }
    }

    override suspend fun clearAuthTokens(customerWalletAddress: String) {
-        secureStorage.delete(createAuthTokensKey(customerWalletAddress))
+        withContext(dispatcherProvider.io) {
+            secureStorage.delete(createAuthTokensKey(customerWalletAddress))
+        }
    }

    override suspend fun storeOrderId(customerWalletAddress: String, orderId: String) {
-        withContext(dispatcherProvider.io) {
-            appPreferencesStore.store(PreferencesKeys.getTangemPayOrderIdKey(customerWalletAddress), orderId)
-        }
+        appPreferencesStore.store(PreferencesKeys.getTangemPayOrderIdKey(customerWalletAddress), orderId)
    }

    override suspend fun getOrderId(customerWalletAddress: String): String? {
-        return withContext(dispatcherProvider.io) {
-            appPreferencesStore.getSyncOrNull(key = PreferencesKeys.getTangemPayOrderIdKey(customerWalletAddress))
-                .takeIf { !it.isNullOrEmpty() }
-        }
+        return appPreferencesStore.getSyncOrNull(key = PreferencesKeys.getTangemPayOrderIdKey(customerWalletAddress))
+            .takeIf { !it.isNullOrEmpty() }
    }

    override suspend fun getAddToWalletDone(customerWalletAddress: String): Boolean {
-        return withContext(dispatcherProvider.io) {
-            appPreferencesStore.getSyncOrNull(
-                key = PreferencesKeys.getTangemPayAddToWalletKey(customerWalletAddress),
-            ) == true
-        }
+        return appPreferencesStore.getSyncOrNull(
+            key = PreferencesKeys.getTangemPayAddToWalletKey(customerWalletAddress),
+        ) == true
    }

    override suspend fun storeAddToWalletDone(customerWalletAddress: String, isDone: Boolean) {
-        withContext(dispatcherProvider.io) {
-            appPreferencesStore.store(PreferencesKeys.getTangemPayAddToWalletKey(customerWalletAddress), isDone)
-        }
+        appPreferencesStore.store(PreferencesKeys.getTangemPayAddToWalletKey(customerWalletAddress), isDone)
    }

-    override suspend fun clearOrderId(customerWalletAddress: String) = withContext(dispatcherProvider.io) {
+    override suspend fun clearOrderId(customerWalletAddress: String) {
        appPreferencesStore.store(PreferencesKeys.getTangemPayOrderIdKey(customerWalletAddress), "")
    }

    override suspend fun storeCheckCustomerWalletResult(userWalletId: UserWalletId, isPaeraCustomer: Boolean) {
-        appPreferencesStore.store(PreferencesKeys.getTangemPayCheckCustomerByWalletId(userWalletId), isPaeraCustomer)
+        appPreferencesStore.store(
+            PreferencesKeys.getTangemPayCheckCustomerByWalletId(userWalletId),
+            isPaeraCustomer,
+        )
    }

    override suspend fun checkCustomerWalletResult(userWalletId: UserWalletId): Boolean? {
@ -152,7 +147,9 @@ internal class DefaultTangemPayStorage @Inject constructor(

    override suspend fun storeActiveWithdrawOrderId(userWalletId: UserWalletId, orderId: String) {
        appPreferencesStore.editData { mutablePreferences ->
-            val orders = mutablePreferences.getObjectMap<String>(PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY)
+            val orders = mutablePreferences.getObjectMap<String>(
+                PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY,
+            )
                .plus(createWithdrawOrderIdKey(userWalletId) to orderId)
            mutablePreferences.setObjectMap(
                key = PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY,
@ -179,7 +176,9 @@ internal class DefaultTangemPayStorage @Inject constructor(
    }

    override suspend fun getActiveWithdrawOrderId(userWalletId: UserWalletId): String? {
-        val orders = appPreferencesStore.getObjectMapSync<String>(PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY)
+        val orders = appPreferencesStore.getObjectMapSync<String>(
+            PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY,
+        )
        return orders[createWithdrawOrderIdKey(userWalletId)]
    }

@ -191,7 +190,9 @@ internal class DefaultTangemPayStorage @Inject constructor(

    override suspend fun deleteActiveWithdrawOrder(userWalletId: UserWalletId) {
        appPreferencesStore.editData { mutablePreferences ->
-            val orders = mutablePreferences.getObjectMap<String>(PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY)
+            val orders = mutablePreferences.getObjectMap<String>(
+                PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY,
+            )
                .minus(createWithdrawOrderIdKey(userWalletId))
            mutablePreferences.setObjectMap(
                key = PreferencesKeys.TANGEM_PAY_ACTIVE_WITHDRAW_ORDERS_KEY,
@ -221,40 +222,33 @@ internal class DefaultTangemPayStorage @Inject constructor(
    }

    override suspend fun storeHideOnboardingBanner(userWalletId: UserWalletId, hide: Boolean) {
-        withContext(dispatcherProvider.io) {
-            appPreferencesStore.store(PreferencesKeys.getTangemPayHideOnboardingKey(userWalletId), hide)
-        }
+        appPreferencesStore.store(PreferencesKeys.getTangemPayHideOnboardingKey(userWalletId), hide)
    }

    override suspend fun getHideMainOnboardingBanner(userWalletId: UserWalletId): Boolean {
-        return withContext(dispatcherProvider.io) {
-            appPreferencesStore.getSyncOrNull(
-                key = PreferencesKeys.getTangemPayHideOnboardingKey(userWalletId),
-            ) == true
-        }
+        return appPreferencesStore.getSyncOrNull(
+            key = PreferencesKeys.getTangemPayHideOnboardingKey(userWalletId),
+        ) == true
    }

    override suspend fun storeTangemPayEligibility(eligibility: Boolean) {
-        withContext(dispatcherProvider.io) {
-            appPreferencesStore.store(key = PreferencesKeys.TANGEM_PAY_ELIGIBILITY_KEY, value = eligibility)
-        }
+        appPreferencesStore.store(key = PreferencesKeys.TANGEM_PAY_ELIGIBILITY_KEY, value = eligibility)
    }

    override suspend fun getTangemPayEligibility(): Boolean {
-        return withContext(dispatcherProvider.io) {
-            appPreferencesStore.getSyncOrDefault(key = PreferencesKeys.TANGEM_PAY_ELIGIBILITY_KEY, default = false)
-        }
+        return appPreferencesStore.getSyncOrDefault(key = PreferencesKeys.TANGEM_PAY_ELIGIBILITY_KEY, default = false)
    }

-    override suspend fun clearAll(userWalletId: UserWalletId, customerWalletAddress: String) =
+    override suspend fun clearAll(userWalletId: UserWalletId, customerWalletAddress: String) {
        withContext(dispatcherProvider.io) {
            secureStorage.delete(createAuthTokensKey(customerWalletAddress))
-            appPreferencesStore.store(PreferencesKeys.getTangemPayCheckCustomerByWalletId(userWalletId), false)
-            appPreferencesStore.store(PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId), "")
-            appPreferencesStore.store(PreferencesKeys.getTangemPayOrderIdKey(customerWalletAddress), "")
-            appPreferencesStore.store(PreferencesKeys.getTangemPayAddToWalletKey(customerWalletAddress), false)
-            appPreferencesStore.store(PreferencesKeys.getTangemPayHideOnboardingKey(userWalletId), false)
        }
+        appPreferencesStore.store(PreferencesKeys.getTangemPayCheckCustomerByWalletId(userWalletId), false)
+        appPreferencesStore.store(PreferencesKeys.getTangemPayCustomerWalletAddressKey(userWalletId), "")
+        appPreferencesStore.store(PreferencesKeys.getTangemPayOrderIdKey(customerWalletAddress), "")
+        appPreferencesStore.store(PreferencesKeys.getTangemPayAddToWalletKey(customerWalletAddress), false)
+        appPreferencesStore.store(PreferencesKeys.getTangemPayHideOnboardingKey(userWalletId), false)
+    }

    private fun createAuthTokensKey(address: String): String = "${AUTH_TOKENS_DEFAULT_KEY}_$address"

--- a/app/src/main/java/com/tangem/tap/di/ActivityModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/ActivityModule.kt
@ -1,7 +1,7 @@
 package com.tangem.tap.di

 import com.tangem.datasource.api.moonpay.MoonPayApi
-import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
+import com.tangem.datasource.local.config.environment.EnvironmentConfig
 import com.tangem.domain.card.ScanCardUseCase
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.exchange.RampStateManager
@ -69,14 +69,14 @@ internal object ActivityModule {
    @Provides
    @Singleton
    fun provideExchangeService(
-        environmentConfigStorage: EnvironmentConfigStorage,
        getSelectedWalletUseCase: GetSelectedWalletUseCase,
        moonPayApi: MoonPayApi,
+        environmentConfig: EnvironmentConfig,
    ): SellService {
        return MoonPayService(
            api = moonPayApi,
-            apiKeyProvider = Provider { environmentConfigStorage.getConfigSync().moonPayApiKey },
-            secretKeyProvider = Provider { environmentConfigStorage.getConfigSync().moonPayApiSecretKey },
+            apiKey = environmentConfig.moonPayApiKey,
+            secretKey = environmentConfig.moonPayApiSecretKey,
            userWalletProvider = { getSelectedWalletUseCase.sync().getOrNull() },
        )
    }
--- a/app/src/main/java/com/tangem/tap/di/TangemSdkManagerModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/TangemSdkManagerModule.kt
@ -1,6 +1,7 @@
 package com.tangem.tap.di

 import android.content.Context
+import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.analytics.api.AnalyticsExceptionHandler
 import com.tangem.core.decompose.di.GlobalUiMessageSender
 import com.tangem.core.decompose.ui.UiMessageSender
@ -12,6 +13,7 @@ import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
 import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.tap.domain.sdk.impl.DefaultTangemSdkManager
 import com.tangem.tap.domain.sdk.impl.MockTangemSdkManager
+import com.tangem.tap.domain.tasks.product.BlockchainToDeriveFinder
 import com.tangem.tap.domain.tasks.visa.TangemPayGenerateAddressAndSignChallengeTask
 import com.tangem.tap.domain.tasks.visa.VisaCardActivationTask
 import com.tangem.tap.domain.visa.VisaCardScanHandler
@ -40,6 +42,8 @@ internal class TangemSdkManagerModule {
        appFinisher: AppFinisher,
        sendFeedbackEmailUseCase: SendFeedbackEmailUseCase,
        analyticsExceptionHandler: AnalyticsExceptionHandler,
+        blockchainToDeriveFinder: BlockchainToDeriveFinder,
+        analyticsEventHandler: AnalyticsEventHandler,
        dispatchers: CoroutineDispatcherProvider,
    ): TangemSdkManager {
        return if (BuildConfig.MOCK_DATA_SOURCE) {
@ -56,6 +60,8 @@ internal class TangemSdkManagerModule {
                appFinisher = appFinisher,
                sendFeedbackEmailUseCase = sendFeedbackEmailUseCase,
                analyticsExceptionHandler = analyticsExceptionHandler,
+                blockchainToDeriveFinder = blockchainToDeriveFinder,
+                analyticsEventHandler = analyticsEventHandler,
                dispatchers = dispatchers,
            )
        }
--- a/app/src/main/java/com/tangem/tap/di/domain/AccountDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/AccountDomainModule.kt
@ -1,6 +1,5 @@
 package com.tangem.tap.di.domain

-import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
 import com.tangem.domain.account.fetcher.SingleAccountListFetcher
 import com.tangem.domain.account.repository.AccountsCRUDRepository
 import com.tangem.domain.account.status.supplier.SingleAccountStatusListSupplier
@ -97,12 +96,10 @@ internal object AccountDomainModule {
    fun provideIsAccountsModeEnabledUseCase(
        userWalletsListRepository: UserWalletsListRepository,
        accountsCRUDRepository: AccountsCRUDRepository,
-        accountsFeatureToggles: AccountsFeatureToggles,
    ): IsAccountsModeEnabledUseCase {
        return IsAccountsModeEnabledUseCase(
            userWalletsListRepository = userWalletsListRepository,
            crudRepository = accountsCRUDRepository,
-            accountsFeatureToggles = accountsFeatureToggles,
        )
    }

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

+import com.tangem.domain.account.supplier.MultiAccountListSupplier
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.earn.repository.EarnRepository
 import com.tangem.domain.earn.usecase.*
-import com.tangem.domain.networks.multi.MultiNetworkStatusSupplier
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@ -19,15 +19,15 @@ object EarnDomainModule {
    }

    @Provides
-    fun provideManageEarnNetworksUseCase(
+    fun provideGetEarnNetworksUseCase(
        earnRepository: EarnRepository,
+        multiAccountListSupplier: MultiAccountListSupplier,
        userWalletsListRepository: UserWalletsListRepository,
-        multiNetworkStatusSupplier: MultiNetworkStatusSupplier,
    ): GetEarnNetworksUseCase {
        return GetEarnNetworksUseCase(
            earnRepository = earnRepository,
+            multiAccountListSupplier = multiAccountListSupplier,
            userWalletsListRepository = userWalletsListRepository,
-            multiNetworkStatusSupplier = multiNetworkStatusSupplier,
        )
    }

--- a/app/src/main/java/com/tangem/tap/di/domain/ManageTokensDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/ManageTokensDomainModule.kt
@ -3,20 +3,11 @@ package com.tangem.tap.di.domain
 import com.tangem.domain.managetokens.*
 import com.tangem.domain.managetokens.repository.CustomTokensRepository
 import com.tangem.domain.managetokens.repository.ManageTokensRepository
-import com.tangem.domain.networks.multi.MultiNetworkStatusFetcher
-import com.tangem.domain.quotes.multi.MultiQuoteStatusFetcher
-import com.tangem.domain.staking.StakingIdFactory
-import com.tangem.domain.staking.multi.MultiStakingBalanceFetcher
-import com.tangem.domain.tokens.repository.CurrenciesRepository
-import com.tangem.domain.walletmanager.WalletManagersFacade
-import com.tangem.domain.wallets.derivations.DerivationsRepository
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
 import javax.inject.Singleton

@Module
@ -57,40 +48,6 @@ internal object ManageTokensDomainModule {
        return CheckIsCurrencyNotAddedUseCase(customTokensRepository)
    }

-    @Provides
-    @Singleton
-    fun provideRemoveCustomManagedCryptoCurrencyUseCase(
-        customTokensRepository: CustomTokensRepository,
-    ): RemoveCustomManagedCryptoCurrencyUseCase {
-        return RemoveCustomManagedCryptoCurrencyUseCase(customTokensRepository)
-    }
-
-    @Provides
-    @Singleton
-    fun provideSaveManagedTokensUseCase(
-        customTokensRepository: CustomTokensRepository,
-        walletManagersFacade: WalletManagersFacade,
-        currenciesRepository: CurrenciesRepository,
-        derivationsRepository: DerivationsRepository,
-        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
-        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
-        multiStakingBalanceFetcher: MultiStakingBalanceFetcher,
-        stakingIdFactory: StakingIdFactory,
-        dispatchers: CoroutineDispatcherProvider,
-    ): SaveManagedTokensUseCase {
-        return SaveManagedTokensUseCase(
-            customTokensRepository = customTokensRepository,
-            walletManagersFacade = walletManagersFacade,
-            currenciesRepository = currenciesRepository,
-            derivationsRepository = derivationsRepository,
-            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
-            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
-            multiStakingBalanceFetcher = multiStakingBalanceFetcher,
-            stakingIdFactory = stakingIdFactory,
-            parallelUpdatingScope = CoroutineScope(SupervisorJob() + dispatchers.default),
-        )
-    }
-
    @Provides
    @Singleton
    fun provideGetSupportedNetworksUseCase(
--- a/app/src/main/java/com/tangem/tap/di/domain/MarketsDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/MarketsDomainModule.kt
@ -4,22 +4,12 @@ import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.markets.*
 import com.tangem.domain.markets.repositories.MarketsTokenRepository
-import com.tangem.domain.networks.multi.MultiNetworkStatusFetcher
 import com.tangem.domain.promo.PromoRepository
-import com.tangem.domain.quotes.multi.MultiQuoteStatusFetcher
 import com.tangem.domain.quotes.single.SingleQuoteStatusSupplier
-import com.tangem.domain.staking.StakingIdFactory
-import com.tangem.domain.staking.multi.MultiStakingBalanceFetcher
-import com.tangem.domain.tokens.repository.CurrenciesRepository
-import com.tangem.domain.walletmanager.WalletManagersFacade
-import com.tangem.domain.wallets.derivations.DerivationsRepository
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
 import javax.inject.Singleton

@Module
@ -66,32 +56,6 @@ object MarketsDomainModule {
        return GetCurrencyQuotesUseCase(singleQuoteStatusSupplier = singleQuoteStatusSupplier)
    }

-    @Provides
-    @Singleton
-    fun provideSaveMarketTokensUseCase(
-        derivationsRepository: DerivationsRepository,
-        marketsTokenRepository: MarketsTokenRepository,
-        walletManagersFacade: WalletManagersFacade,
-        currenciesRepository: CurrenciesRepository,
-        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
-        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
-        multiStakingBalanceFetcher: MultiStakingBalanceFetcher,
-        stakingIdFactory: StakingIdFactory,
-        dispatchers: CoroutineDispatcherProvider,
-    ): SaveMarketTokensUseCase {
-        return SaveMarketTokensUseCase(
-            derivationsRepository = derivationsRepository,
-            marketsTokenRepository = marketsTokenRepository,
-            walletManagersFacade = walletManagersFacade,
-            currenciesRepository = currenciesRepository,
-            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
-            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
-            multiStakingBalanceFetcher = multiStakingBalanceFetcher,
-            stakingIdFactory = stakingIdFactory,
-            parallelUpdatingScope = CoroutineScope(SupervisorJob() + dispatchers.default),
-        )
-    }
-
    @Provides
    @Singleton
    fun provideGetTokenMarketCryptoCurrency(
--- a/app/src/main/java/com/tangem/tap/di/domain/NFTDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/NFTDomainModule.kt
@ -1,6 +1,5 @@
 package com.tangem.tap.di.domain

-import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
 import com.tangem.domain.account.supplier.SingleAccountListSupplier
 import com.tangem.domain.networks.single.SingleNetworkStatusSupplier
 import com.tangem.domain.nft.*
@ -25,15 +24,11 @@ internal object NFTDomainModule {
    @Provides
    @Singleton
    fun providesGetNFTCollectionsUseCase(
-        currenciesRepository: CurrenciesRepository,
        nftRepository: NFTRepository,
        singleAccountListSupplier: SingleAccountListSupplier,
-        accountsFeatureToggles: AccountsFeatureToggles,
    ): GetNFTCollectionsUseCase = GetNFTCollectionsUseCase(
-        currenciesRepository = currenciesRepository,
        nftRepository = nftRepository,
        singleAccountListSupplier = singleAccountListSupplier,
-        accountsFeatureToggles = accountsFeatureToggles,
    )

    @Provides
--- a/app/src/main/java/com/tangem/tap/di/domain/OnrampDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/OnrampDomainModule.kt
@ -1,9 +1,13 @@
 package com.tangem.tap.di.domain

+import com.tangem.domain.offramp.GetOfframpUrlUseCase
+import com.tangem.domain.offramp.repository.OfframpRepository
 import com.tangem.domain.onramp.*
 import com.tangem.domain.onramp.repositories.*
 import com.tangem.domain.promo.PromoRepository
 import com.tangem.domain.settings.repositories.SettingsRepository
+import com.tangem.tap.data.DefaultOfframpRepository
+import com.tangem.tap.network.exchangeServices.SellService
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@ -275,4 +279,16 @@ internal object OnrampDomainModule {
            promoRepository = promoRepository,
        )
    }
+
+    @Provides
+    @Singleton
+    fun provideOfframpRepository(sellService: SellService): OfframpRepository {
+        return DefaultOfframpRepository(sellService)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOfframpUrlUseCase(offrampRepository: OfframpRepository): GetOfframpUrlUseCase {
+        return GetOfframpUrlUseCase(offrampRepository)
+    }
 }
--- a/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
@ -7,6 +7,7 @@ import com.tangem.domain.networks.multi.MultiNetworkStatusSupplier
 import com.tangem.domain.networks.repository.NetworksRepository
 import com.tangem.domain.networks.single.SingleNetworkStatusFetcher
 import com.tangem.domain.networks.single.SingleNetworkStatusSupplier
+import com.tangem.domain.pay.flow.PaymentAccountStatusFetcher
 import com.tangem.domain.promo.PromoRepository
 import com.tangem.domain.quotes.QuotesRepository
 import com.tangem.domain.quotes.multi.MultiQuoteStatusFetcher
@ -19,7 +20,6 @@ import com.tangem.domain.staking.single.SingleStakingBalanceFetcher
 import com.tangem.domain.staking.single.SingleStakingBalanceSupplier
 import com.tangem.domain.tokens.*
 import com.tangem.domain.tokens.operations.BaseCurrencyStatusOperations
-import com.tangem.domain.tokens.operations.CachedCurrenciesStatusesOperations
 import com.tangem.domain.tokens.repository.CurrenciesRepository
 import com.tangem.domain.tokens.repository.CurrencyChecksRepository
 import com.tangem.domain.tokens.repository.TokenReceiveWarningsViewedRepository
@ -39,28 +39,6 @@ import javax.inject.Singleton
@Suppress("TooManyFunctions", "LargeClass")
 internal object TokensDomainModule {

-    @Provides
-    @Singleton
-    fun provideAddCryptoCurrenciesUseCase(
-        currenciesRepository: CurrenciesRepository,
-        walletManagersFacade: WalletManagersFacade,
-        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
-        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
-        singleStakingBalanceFetcher: SingleStakingBalanceFetcher,
-        multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
-        stakingIdFactory: StakingIdFactory,
-    ): AddCryptoCurrenciesUseCase {
-        return AddCryptoCurrenciesUseCase(
-            currenciesRepository = currenciesRepository,
-            walletManagersFacade = walletManagersFacade,
-            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
-            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
-            singleStakingBalanceFetcher = singleStakingBalanceFetcher,
-            multiWalletCryptoCurrenciesSupplier = multiWalletCryptoCurrenciesSupplier,
-            stakingIdFactory = stakingIdFactory,
-        )
-    }
-
    @Provides
    @Singleton
    fun provideFetchPendingTransactionsUseCase(
@ -75,32 +53,6 @@ internal object TokensDomainModule {
        return DefaultTokensFeatureToggles(featureTogglesManager = featureTogglesManager)
    }

-    @Provides
-    @Singleton
-    fun provideGetTokenListUseCase(
-        currenciesRepository: CurrenciesRepository,
-        currenciesStatusesOperations: BaseCurrencyStatusOperations,
-    ): GetTokenListUseCase {
-        return GetTokenListUseCase(
-            currenciesRepository = currenciesRepository,
-            currenciesStatusesOperations = currenciesStatusesOperations,
-        )
-    }
-
-    @Provides
-    @Singleton
-    fun provideRemoveCurrencyUseCase(
-        currenciesRepository: CurrenciesRepository,
-        walletManagersFacade: WalletManagersFacade,
-        multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
-    ): RemoveCurrencyUseCase {
-        return RemoveCurrencyUseCase(
-            currenciesRepository = currenciesRepository,
-            walletManagersFacade = walletManagersFacade,
-            multiWalletCryptoCurrenciesSupplier = multiWalletCryptoCurrenciesSupplier,
-        )
-    }
-
    @Provides
    @Singleton
    fun provideGetCurrencyUseCase(
@ -113,20 +65,6 @@ internal object TokensDomainModule {
        )
    }

-    @Provides
-    @Singleton
-    fun provideGetAllWalletsCryptoCurrencyStatusesUseCase(
-        currenciesRepository: CurrenciesRepository,
-        currencyStatusOperations: BaseCurrencyStatusOperations,
-        dispatchers: CoroutineDispatcherProvider,
-    ): GetAllWalletsCryptoCurrencyStatusesUseCase {
-        return GetAllWalletsCryptoCurrencyStatusesUseCase(
-            currenciesRepository = currenciesRepository,
-            currencyStatusOperations = currencyStatusOperations,
-            dispatchers = dispatchers,
-        )
-    }
-
    @Provides
    @Singleton
    fun provideGetCurrencyWarningsUseCase(
@ -176,34 +114,6 @@ internal object TokensDomainModule {
        return GetCryptoCurrencyUseCase(currenciesRepository, multiWalletCryptoCurrenciesSupplier)
    }

-    @Provides
-    @Singleton
-    fun provideToggleTokenListGroupingUseCase(
-        dispatchers: CoroutineDispatcherProvider,
-    ): ToggleTokenListGroupingUseCase {
-        return ToggleTokenListGroupingUseCase(dispatchers)
-    }
-
-    @Provides
-    @Singleton
-    fun provideToggleTokenListSortingUseCase(dispatchers: CoroutineDispatcherProvider): ToggleTokenListSortingUseCase {
-        return ToggleTokenListSortingUseCase(dispatchers)
-    }
-
-    @Provides
-    @Singleton
-    fun provideApplyTokenListSortingUseCase(
-        currenciesRepository: CurrenciesRepository,
-        multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
-        dispatchers: CoroutineDispatcherProvider,
-    ): ApplyTokenListSortingUseCase {
-        return ApplyTokenListSortingUseCase(
-            currenciesRepository = currenciesRepository,
-            multiWalletCryptoCurrenciesSupplier = multiWalletCryptoCurrenciesSupplier,
-            dispatchers = dispatchers,
-        )
-    }
-
    @Provides
    @Singleton
    fun provideGetCryptoCurrencyActionsUseCase(
@ -308,14 +218,6 @@ internal object TokensDomainModule {
        )
    }

-    @Provides
-    @Singleton
-    fun provideGetWalletTotalBalanceUseCase(
-        currenciesStatusesOperations: BaseCurrencyStatusOperations,
-    ): GetWalletTotalBalanceUseCase {
-        return GetWalletTotalBalanceUseCase(currenciesStatusesOperations)
-    }
-
    @Provides
    @Singleton
    fun provideRefreshMultiCurrencyWalletQuotesUseCase(
@ -350,7 +252,7 @@ internal object TokensDomainModule {
        multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
        stakingIdFactory: StakingIdFactory,
    ): BaseCurrencyStatusOperations {
-        return CachedCurrenciesStatusesOperations(
+        return BaseCurrencyStatusOperations(
            currenciesRepository = currenciesRepository,
            quotesRepository = quotesRepository,
            singleNetworkStatusSupplier = singleNetworkStatusSupplier,
@ -363,12 +265,6 @@ internal object TokensDomainModule {
        )
    }

-    @Provides
-    @Singleton
-    fun provideGetCryptoCurrenciesUseCase(currenciesRepository: CurrenciesRepository): GetCryptoCurrenciesUseCase {
-        return GetCryptoCurrenciesUseCase(currenciesRepository)
-    }
-
    @Provides
    @Singleton
    fun provideWalletBalanceFetcher(
@ -378,6 +274,7 @@ internal object TokensDomainModule {
        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
        multiStakingBalanceFetcher: MultiStakingBalanceFetcher,
+        paymentAccountStatusFetcher: PaymentAccountStatusFetcher,
        stakingIdFactory: StakingIdFactory,
        dispatchers: CoroutineDispatcherProvider,
    ): WalletBalanceFetcher {
@ -388,6 +285,7 @@ internal object TokensDomainModule {
            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
            multiStakingBalanceFetcher = multiStakingBalanceFetcher,
+            paymentAccountStatusFetcher = paymentAccountStatusFetcher,
            stakingIdFactory = stakingIdFactory,
            dispatchers = dispatchers,
        )
--- a/app/src/main/java/com/tangem/tap/di/domain/WalletsDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/WalletsDomainModule.kt
@ -66,6 +66,12 @@ internal object WalletsDomainModule {
        return GetUserWalletUseCase(userWalletsListRepository = userWalletsListRepository)
    }

+    @Provides
+    @Singleton
+    fun provideGetWalletIconUseCase(walletsRepository: WalletsRepository): GetWalletIconUseCase {
+        return GetWalletIconUseCase(walletsRepository = walletsRepository)
+    }
+
    @Provides
    @Singleton
    fun providesGetSelectedWalletSyncUseCase(
--- a/app/src/main/java/com/tangem/tap/domain/sdk/impl/DefaultTangemSdkManager.kt
+++ b/app/src/main/java/com/tangem/tap/domain/sdk/impl/DefaultTangemSdkManager.kt
@ -18,7 +18,10 @@ import com.tangem.common.extensions.hexToBytes
 import com.tangem.common.services.secure.SecureStorage
 import com.tangem.common.usersCode.UserCodeRepository
 import com.tangem.core.analytics.Analytics
+import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.analytics.api.AnalyticsExceptionHandler
+import com.tangem.core.analytics.models.AnalyticsParam
+import com.tangem.core.analytics.models.Basic
 import com.tangem.core.analytics.models.ExceptionAnalyticsEvent
 import com.tangem.core.decompose.ui.UiMessageSender
 import com.tangem.core.navigation.finisher.AppFinisher
@ -53,11 +56,7 @@ import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.sdk.api.visa.VisaCardActivationResponse
 import com.tangem.sdk.api.visa.VisaCardActivationTaskMode
 import com.tangem.tap.common.analytics.events.TangemSdkErrorEvent
-import com.tangem.tap.derivationsFinder
-import com.tangem.tap.domain.tasks.product.CreateProductWalletTask
-import com.tangem.tap.domain.tasks.product.ResetBackupCardTask
-import com.tangem.tap.domain.tasks.product.ResetToFactorySettingsTask
-import com.tangem.tap.domain.tasks.product.ScanProductTask
+import com.tangem.tap.domain.tasks.product.*
 import com.tangem.tap.domain.tasks.visa.TangemPayGenerateAddressAndSignChallengeTask
 import com.tangem.tap.domain.tasks.visa.TangemPaySignWithdrawalHashTask
 import com.tangem.tap.domain.tasks.visa.VisaCardActivationTask
@ -85,6 +84,8 @@ internal class DefaultTangemSdkManager(
    private val appFinisher: AppFinisher,
    private val sendFeedbackEmailUseCase: SendFeedbackEmailUseCase,
    private val analyticsExceptionHandler: AnalyticsExceptionHandler,
+    private val blockchainToDeriveFinder: BlockchainToDeriveFinder,
+    private val analyticsEventHandler: AnalyticsEventHandler,
    dispatchers: CoroutineDispatcherProvider,
 ) : TangemSdkManager {

@ -173,7 +174,7 @@ internal class DefaultTangemSdkManager(
            runTaskAsyncReturnOnMain(
                runnable = ScanProductTask(
                    card = null,
-                    derivationsFinder = derivationsFinder,
+                    blockchainToDeriveFinder = blockchainToDeriveFinder,
                    allowsRequestAccessCodeFromRepository = allowsRequestAccessCodeFromRepository,
                    visaCardScanHandler = visaCardScanHandler,
                    visaCoroutineScope = this,
@ -473,6 +474,9 @@ internal class DefaultTangemSdkManager(
                        title = resourceReference(R.string.alert_button_request_support),
                        onClick = {
                            coroutineScope.launch {
+                                analyticsEventHandler.send(
+                                    Basic.ButtonSupport(source = AnalyticsParam.ScreensSources.SignIn),
+                                )
                                sendFeedbackEmailUseCase(FeedbackEmailType.BiometricsAuthenticationFailed)
                            }
                        },
--- a/app/src/main/java/com/tangem/tap/domain/tasks/product/BlockchainToDeriveFinder.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tasks/product/BlockchainToDeriveFinder.kt
@ -0,0 +1,74 @@
+package com.tangem.tap.domain.tasks.product
+
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.derivation.DerivationStyle
+import com.tangem.blockchainsdk.utils.fromNetworkId
+import com.tangem.crypto.hdWallet.DerivationPath
+import com.tangem.data.common.account.WalletAccountsFetcher
+import com.tangem.data.wallets.derivations.BlockchainToDerive
+import com.tangem.domain.models.scan.CardDTO
+import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.wallets.builder.UserWalletIdBuilder
+import com.tangem.domain.wallets.derivations.derivationStyleProvider
+import com.tangem.tap.features.demo.DemoHelper
+import javax.inject.Inject
+
+/**
+ * Finder of blockchains to derive.
+ * Returns only saved, default or demo blockchains without any additional logic
+ * (no cardano/ethereum additions or unnecessary blockchain removals).
+ */
+class BlockchainToDeriveFinder @Inject constructor(
+    private val walletAccountsFetcher: WalletAccountsFetcher,
+) {
+
+    suspend fun find(card: CardDTO): Set<BlockchainToDerive> {
+        if (!card.settings.isHDWalletAllowed || card.wallets.isEmpty()) return emptySet()
+        val userWalletId = UserWalletIdBuilder.card(card).build() ?: return emptySet()
+
+        val derivationStyle = card.derivationStyleProvider.getDerivationStyle()
+
+        val blockchains = getBlockchains(userWalletId).ifEmpty {
+            if (DemoHelper.isDemoCardId(card.cardId)) {
+                getDemoBlockchains(derivationStyle, card.cardId)
+            } else {
+                getDefaultBlockchains(derivationStyle)
+            }
+        }
+
+        return blockchains
+    }
+
+    private suspend fun getBlockchains(userWalletId: UserWalletId): Set<BlockchainToDerive> {
+        return walletAccountsFetcher.getSaved(userWalletId)?.accounts.orEmpty()
+            .flatMap { accountDTO ->
+                accountDTO.tokens.orEmpty()
+                    .filter { it.contractAddress == null }
+            }
+            .mapNotNull { coin ->
+                val blockchain = Blockchain.fromNetworkId(coin.networkId) ?: return@mapNotNull null
+                val derivationPath = coin.derivationPath?.let(::DerivationPath) ?: return@mapNotNull null
+
+                BlockchainToDerive(blockchain, derivationPath)
+            }
+            .toSet()
+    }
+
+    private fun getDemoBlockchains(derivationStyle: DerivationStyle?, cardId: String): Set<BlockchainToDerive> {
+        return DemoHelper.config.getDemoBlockchains(cardId).mapToBlockchainsWithDerivations(derivationStyle)
+    }
+
+    private fun getDefaultBlockchains(derivationStyle: DerivationStyle?): Set<BlockchainToDerive> {
+        val defaultBlockchains = setOf(Blockchain.Bitcoin, Blockchain.Ethereum)
+        return defaultBlockchains.mapToBlockchainsWithDerivations(derivationStyle)
+    }
+
+    private fun Set<Blockchain>.mapToBlockchainsWithDerivations(
+        derivationStyle: DerivationStyle?,
+    ): Set<BlockchainToDerive> {
+        return mapNotNullTo(hashSetOf()) { blockchain ->
+            val derivationPath = blockchain.derivationPath(derivationStyle) ?: return@mapNotNullTo null
+            BlockchainToDerive(blockchain, derivationPath)
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/domain/tasks/product/DerivationsFinder.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tasks/product/DerivationsFinder.kt
@ -1,131 +0,0 @@
-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.blockchainsdk.utils.fromNetworkId
-import com.tangem.crypto.hdWallet.DerivationPath
-import com.tangem.datasource.local.token.UserTokensResponseStore
-import com.tangem.domain.wallets.derivations.DerivationStyleProvider
-import com.tangem.domain.card.common.TapWorkarounds.hasOldStyleDerivation
-import com.tangem.domain.models.scan.CardDTO
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.wallets.builder.UserWalletIdBuilder
-import com.tangem.tap.features.demo.DemoHelper
-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 userTokensResponseStore: UserTokensResponseStore,
-    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()
-
-        val blockchains = withContext(dispatchers.io) {
-            getBlockchains(userWalletId)
-        }.ifEmpty {
-            if (DemoHelper.isDemoCardId(card.cardId)) {
-                getDemoBlockchains(derivationStyle, card.cardId)
-            } 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.hasOldStyleDerivation) {
-            blockchains.removeUnnecessaryBlockchains()
-        }
-
-        return blockchains
-    }
-
-    private suspend fun getBlockchains(userWalletId: UserWalletId): MutableSet<BlockchainToDerive> {
-        val responseTokens = userTokensResponseStore.getSyncOrNull(userWalletId = 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()
-    }
-
-    // TODO: Move to user wallet config
-    private fun getDemoBlockchains(derivationStyle: DerivationStyle?, cardId: String): MutableSet<BlockchainToDerive> {
-        return DemoHelper.config.getDemoBlockchains(cardId).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))
-    }
-}
--- a/app/src/main/java/com/tangem/tap/domain/tasks/product/ScanProductTask.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tasks/product/ScanProductTask.kt
@ -13,16 +13,14 @@ 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.wallets.derivations.DerivationStyleProvider
+import com.tangem.data.wallets.derivations.MissedDerivationsFinder
 import com.tangem.domain.card.common.TapWorkarounds.isExcluded
 import com.tangem.domain.card.common.TapWorkarounds.isNotSupportedInThatRelease
 import com.tangem.domain.card.common.TapWorkarounds.isStart2Coin
 import com.tangem.domain.card.common.TapWorkarounds.isTangemTwins
 import com.tangem.domain.card.common.TapWorkarounds.isVisa
 import com.tangem.domain.card.common.TwinsHelper
-import com.tangem.domain.wallets.derivations.derivationStyleProvider
 import com.tangem.domain.card.common.visa.VisaUtilities
-import com.tangem.domain.card.configs.CardConfig
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.CardDTO.Companion.RING_BATCH_IDS
 import com.tangem.domain.models.scan.CardDTO.Companion.RING_BATCH_PREFIX
@ -45,11 +43,10 @@ import com.tangem.tap.scope
 import com.tangem.tap.store
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
-import kotlin.collections.set

 internal class ScanProductTask(
    private val card: Card?,
-    private val derivationsFinder: DerivationsFinder?,
+    private val blockchainToDeriveFinder: BlockchainToDeriveFinder?,
    private val visaCardScanHandler: VisaCardScanHandler?,
    private val visaCoroutineScope: CoroutineScope?,
    private val onboardingV2FeatureToggles: OnboardingV2FeatureToggles?,
@ -81,7 +78,7 @@ internal class ScanProductTask(
            readVisaCard(
                session = session,
                cardDto = cardDto,
-                scanWalletProcessor = ScanWalletProcessor(derivationsFinder),
+                scanWalletProcessor = ScanWalletProcessor(blockchainToDeriveFinder),
                callback = callback,
            )
            return
@ -89,7 +86,7 @@ internal class ScanProductTask(

        val commandProcessor = when {
            cardDto.isTangemTwins -> ScanTwinProcessor()
-            else -> ScanWalletProcessor(derivationsFinder)
+            else -> ScanWalletProcessor(blockchainToDeriveFinder)
        }
        commandProcessor.proceed(cardDto, session) { processorResult ->
            when (processorResult) {
@ -170,7 +167,7 @@ internal class ScanProductTask(
 }

 private class ScanWalletProcessor(
-    private val derivationsFinder: DerivationsFinder?,
+    private val blockchainToDeriveFinder: BlockchainToDeriveFinder?,
 ) : ProductCommandProcessor<ScanResponse> {

    var primaryCard: PrimaryCard? = null
@ -293,7 +290,6 @@ private class ScanWalletProcessor(
        callback: (result: CompletionResult<ScanResponse>) -> Unit,
    ) {
        val productType = getWalletProductType(card)
-        val config = CardConfig.createConfig(card)
        scope.launch {
            val scanResponse = ScanResponse(
                card = card,
@ -301,8 +297,7 @@ private class ScanWalletProcessor(
                walletData = session.environment.walletData,
                primaryCard = primaryCard,
            )
-            val derivations =
-                collectDerivations(card, config, scanResponse.derivationStyleProvider)
+            val derivations = collectDerivations(card, scanResponse)
            if (derivations.isEmpty() || !card.settings.isHDWalletAllowed) {
                callback(CompletionResult.Success(scanResponse))
                return@launch
@ -332,32 +327,13 @@ private class ScanWalletProcessor(

    private suspend fun collectDerivations(
        card: CardDTO,
-        config: CardConfig,
-        derivationStyleProvider: DerivationStyleProvider,
+        scanResponse: ScanResponse,
    ): Map<ByteArrayKey, List<DerivationPath>> {
-        val derivations = mutableMapOf<ByteArrayKey, List<DerivationPath>>()
-        val blockchains = derivationsFinder
-            ?.findBlockchainsToDerive(card, derivationStyleProvider)
-            ?: return derivations
+        val blockchains = blockchainToDeriveFinder
+            ?.find(card)
+            ?: return emptyMap()

-        blockchains.forEach { blockchain ->
-            val curve = config.primaryCurve(blockchain.blockchain)
-            val wallet = card.wallets.firstOrNull { it.curve == curve } ?: return@forEach
-            if (wallet.chainCode == null) return@forEach
-
-            val key = wallet.publicKey.toMapKey()
-            val path = blockchain.derivationPath
-            if (path != null) {
-                val addedDerivations = derivations[key]
-                if (addedDerivations != null) {
-                    derivations[key] = addedDerivations + path
-                } else {
-                    derivations[key] = listOf(path)
-                }
-            }
-        }
-
-        return derivations
+        return MissedDerivationsFinder(scanResponse).findByBlockchainsToDerive(blockchains)
    }
 }

--- a/app/src/main/java/com/tangem/tap/domain/tokens/DefaultTokensFeatureToggles.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tokens/DefaultTokensFeatureToggles.kt
@ -4,5 +4,9 @@ import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 import com.tangem.domain.tokens.TokensFeatureToggles

 internal class DefaultTokensFeatureToggles(
-    @Suppress("UnusedPrivateMember") private val featureTogglesManager: FeatureTogglesManager,
-) : TokensFeatureToggles
+    private val featureTogglesManager: FeatureTogglesManager,
+) : TokensFeatureToggles {
+
+    override val isMultiAddressUtxoEnabled: Boolean
+        get() = featureTogglesManager.isFeatureEnabled("MULTI_ADDRESS_UTXO_ENABLED")
+}
--- a/app/src/main/java/com/tangem/tap/domain/twins/FinalizeTwinTask.kt
+++ b/app/src/main/java/com/tangem/tap/domain/twins/FinalizeTwinTask.kt
@ -28,7 +28,7 @@ class FinalizeTwinTask(
                            is CompletionResult.Success ->
                                ScanProductTask(
                                    card = readResult.data,
-                                    derivationsFinder = null,
+                                    blockchainToDeriveFinder = null,
                                    visaCardScanHandler = null,
                                    visaCoroutineScope = null,
                                    shouldCheckIsAlreadyActivated = false,
--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt
@ -88,7 +88,7 @@ internal class DefaultUserWalletsListRepository(
                        .map { wallets.updateWith(it) }
                }
                .doOnSuccess { loadedWallets ->
-                    userWallets.update { toUpdate ->
+                    userWallets.update { _ ->
                        val selectedUserWalletId = selectedUserWalletRepository.get()
                        selectedUserWallet.value = loadedWallets.firstOrNull { it.walletId == selectedUserWalletId }
                            ?: loadedWallets.firstOrNull()?.also {
@ -240,7 +240,7 @@ internal class DefaultUserWalletsListRepository(
        }
    }

-    @Suppress("CyclomaticComplexMethod")
+    @Suppress("CyclomaticComplexMethod", "LongMethod")
    override suspend fun unlock(
        userWalletId: UserWalletId,
        unlockMethod: UserWalletsListRepository.UnlockMethod,
@ -317,7 +317,13 @@ internal class DefaultUserWalletsListRepository(

                sensitiveInformationRepository.getAll(listOf(encryptionKey))
                    .doOnSuccess { sensitiveInfo ->
-                        updateWallets { it?.updateWith(sensitiveInfo) }
+                        updateWallets { wallets ->
+                            // It is necessary to update derivations because when scanning we obtain the missing keys
+                            wallets?.updateWith(
+                                walletIdToSensitiveInformation = sensitiveInfo,
+                                walletIdToDerivedKeys = mapOf(userWallet.walletId to scanResponse.derivedKeys),
+                            )
+                        }
                        trackSignInEvent(userWallet, Basic.SignedIn.SignInType.Card)
                    }
                    .doOnFailure { error -> raise(UnlockWalletError.UnableToUnlock.RawException(error)) }
--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/utils/Mapper.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/utils/Mapper.kt
@ -1,8 +1,10 @@
 package com.tangem.tap.domain.userWalletList.utils

+import com.tangem.domain.models.scan.KeyWalletPublicKey
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.domain.models.wallet.isMultiCurrency
+import com.tangem.operations.derivation.ExtendedPublicKeysMap
 import com.tangem.tap.domain.userWalletList.model.UserWalletPublicInformation
 import com.tangem.tap.domain.userWalletList.model.UserWalletSensitiveInformation

@ -72,7 +74,10 @@ internal fun List<UserWalletPublicInformation>.toUserWallets(): List<UserWallet>
    return this.map { it.toUserWallet() }
 }

-internal fun UserWallet.updateWith(sensitiveInformation: UserWalletSensitiveInformation): UserWallet {
+internal fun UserWallet.updateWith(
+    sensitiveInformation: UserWalletSensitiveInformation,
+    derivedKeys: Map<KeyWalletPublicKey, ExtendedPublicKeysMap>?,
+): UserWallet {
    return when (this) {
        is UserWallet.Cold -> {
            copy(
@ -80,6 +85,7 @@ internal fun UserWallet.updateWith(sensitiveInformation: UserWalletSensitiveInfo
                    card = scanResponse.card.copy(
                        wallets = requireNotNull(sensitiveInformation.wallets),
                    ),
+                    derivedKeys = derivedKeys ?: scanResponse.derivedKeys,
                    // visaCardActivationStatus = sensitiveInformation.visaCardActivationStatus,
                ),
            )
@ -92,14 +98,20 @@ internal fun UserWallet.updateWith(sensitiveInformation: UserWalletSensitiveInfo

 internal fun List<UserWallet>.updateWith(
    walletIdToSensitiveInformation: Map<UserWalletId, UserWalletSensitiveInformation>,
+    walletIdToDerivedKeys: Map<UserWalletId, Map<KeyWalletPublicKey, ExtendedPublicKeysMap>>? = null,
 ): List<UserWallet> {
    return if (walletIdToSensitiveInformation.isEmpty()) {
        this
    } else {
        this.map { wallet ->
-            walletIdToSensitiveInformation[wallet.walletId]
-                ?.let(wallet::updateWith)
-                ?: wallet
+            val sensitiveInformation = walletIdToSensitiveInformation[wallet.walletId]
+            val derivedKeys = walletIdToDerivedKeys?.get(wallet.walletId)
+
+            if (sensitiveInformation != null) {
+                wallet.updateWith(sensitiveInformation, derivedKeys)
+            } else {
+                wallet
+            }
        }
    }
 }
--- a/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/model/CardSettingsModel.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/model/CardSettingsModel.kt
@ -222,7 +222,7 @@ internal class CardSettingsModel @Inject constructor(
            val card = scanResponse.card

            modelScope.launch {
-                val hasTangemPay = onboardingRepository.checkCustomerWallet(userWalletId).getOrNull() == true
+                val hasTangemPay = onboardingRepository.hasTangemPayInWallet(userWalletId).getOrNull() == true
                store.dispatchNavigationAction {
                    push(
                        route = AppRoute.ResetToFactory(
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/TradeCryptoMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/TradeCryptoMiddleware.kt
@ -1,66 +0,0 @@
-package com.tangem.tap.features.wallet.redux.middlewares
-
-import com.tangem.common.routing.AppRouter
-import com.tangem.core.analytics.Analytics
-import com.tangem.domain.models.network.NetworkAddress
-import com.tangem.domain.tokens.legacy.TradeCryptoAction
-import com.tangem.tap.common.analytics.events.Token
-import com.tangem.tap.common.apptheme.MutableAppThemeModeHolder
-import com.tangem.tap.common.extensions.dispatchNavigationAction
-import com.tangem.tap.common.extensions.dispatchOpenUrl
-import com.tangem.tap.common.extensions.inject
-import com.tangem.tap.common.redux.AppState
-import com.tangem.tap.features.demo.DemoHelper
-import com.tangem.tap.proxy.redux.DaggerGraphState
-import com.tangem.tap.store
-import org.rekotlin.Middleware
-
-@Deprecated("Will be removed soon")
-object TradeCryptoMiddleware {
-
-    val middleware: Middleware<AppState> = { _, appState ->
-        { nextDispatch ->
-            { action ->
-                if (action is TradeCryptoAction) {
-                    handle(appState, action)
-                }
-                nextDispatch(action)
-            }
-        }
-    }
-
-    private fun handle(state: () -> AppState?, action: TradeCryptoAction) {
-        if (DemoHelper.tryHandle(state)) return
-
-        when (action) {
-            is TradeCryptoAction.FinishSelling -> openReceiptUrl(action.transactionId)
-            is TradeCryptoAction.Sell -> proceedSellAction(action)
-        }
-    }
-
-    private fun proceedSellAction(action: TradeCryptoAction.Sell) {
-        val networkAddress = action.cryptoCurrencyStatus.value.networkAddress
-            ?.defaultAddress
-            ?.let(NetworkAddress.Address::value)
-            ?: return
-        val currency = action.cryptoCurrencyStatus.currency
-
-        store.inject(DaggerGraphState::appStateHolder).sellService?.getUrl(
-            cryptoCurrency = currency,
-            fiatCurrencyName = action.appCurrencyCode,
-            walletAddress = networkAddress,
-            isDarkTheme = MutableAppThemeModeHolder.isDarkThemeActive,
-        )?.let { url ->
-            store.dispatchOpenUrl(url)
-            Analytics.send(Token.Withdraw.ScreenOpened())
-        }
-    }
-
-    private fun openReceiptUrl(transactionId: String) {
-        store.dispatchNavigationAction(AppRouter::pop)
-
-        val sellService = store.inject(DaggerGraphState::appStateHolder).sellService
-        sellService?.getSellCryptoReceiptUrl(transactionId = transactionId)
-            ?.let(store::dispatchOpenUrl)
-    }
-}
--- a/app/src/main/java/com/tangem/tap/network/auth/DefaultAuthProvider.kt
+++ b/app/src/main/java/com/tangem/tap/network/auth/DefaultAuthProvider.kt
@ -3,7 +3,7 @@ package com.tangem.tap.network.auth
 import com.tangem.common.extensions.toHexString
 import com.tangem.datasource.api.common.AuthProvider
 import com.tangem.datasource.api.common.config.ApiEnvironment
-import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
+import com.tangem.datasource.local.config.environment.EnvironmentConfig
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.utils.Provider
@ -11,7 +11,7 @@ import com.tangem.utils.ProviderSuspend

 internal class DefaultAuthProvider(
    private val userWalletsListRepository: UserWalletsListRepository,
-    private val environmentConfigStorage: EnvironmentConfigStorage,
+    private val environmentConfig: EnvironmentConfig,
 ) : AuthProvider {

    override suspend fun getCardPublicKey(): String {
@ -47,11 +47,11 @@ internal class DefaultAuthProvider(
                ApiEnvironment.DEV,
                ApiEnvironment.DEV_2,
                ApiEnvironment.DEV_3,
-                -> environmentConfigStorage.getConfigSync().tangemApiKeyDev
+                -> environmentConfig.tangemApiKeyDev
                ApiEnvironment.STAGE_2,
                ApiEnvironment.STAGE,
-                -> environmentConfigStorage.getConfigSync().tangemApiKeyStage
-                ApiEnvironment.PROD -> environmentConfigStorage.getConfigSync().tangemApiKey
+                -> environmentConfig.tangemApiKeyStage
+                ApiEnvironment.PROD -> environmentConfig.tangemApiKey
            } ?: error("No tangem tech api config provided")
        }
    }
@ -60,8 +60,8 @@ internal class DefaultAuthProvider(
        return ProviderSuspend {
            when (apiEnvironment.invoke()) {
                ApiEnvironment.DEV,
-                -> environmentConfigStorage.getConfigSync().gaslessTxApiKeyDev
-                ApiEnvironment.PROD -> environmentConfigStorage.getConfigSync().gaslessTxApiKey
+                -> environmentConfig.gaslessTxApiKeyDev
+                ApiEnvironment.PROD -> environmentConfig.gaslessTxApiKey
                else -> error("No gasless tx api config provided for ${apiEnvironment.invoke()}")
            } ?: error("No gasless tx api config provided")
        }
--- a/app/src/main/java/com/tangem/tap/network/auth/DefaultP2PEthPoolAuthProvider.kt
+++ b/app/src/main/java/com/tangem/tap/network/auth/DefaultP2PEthPoolAuthProvider.kt
@ -1,15 +1,15 @@
 package com.tangem.tap.network.auth

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

 internal class DefaultP2PEthPoolAuthProvider(
-    private val environmentConfigStorage: EnvironmentConfigStorage,
+    private val environmentConfig: EnvironmentConfig,
 ) : P2PEthPoolAuthProvider {

    override fun getApiKey(): String {
-        val keys = environmentConfigStorage.getConfigSync().p2pApiKey
+        val keys = environmentConfig.p2pApiKey
            ?: error("No P2P api keys provided")

        return if (P2PEthPoolStakingConfig.USE_TESTNET) keys.hoodi else keys.mainnet
--- a/app/src/main/java/com/tangem/tap/network/auth/DefaultStakeKitAuthProvider.kt
+++ b/app/src/main/java/com/tangem/tap/network/auth/DefaultStakeKitAuthProvider.kt
@ -1,13 +1,13 @@
 package com.tangem.tap.network.auth

-import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
+import com.tangem.datasource.local.config.environment.EnvironmentConfig
 import com.tangem.lib.auth.StakeKitAuthProvider

 internal class DefaultStakeKitAuthProvider(
-    private val environmentConfigStorage: EnvironmentConfigStorage,
+    private val environmentConfig: EnvironmentConfig,
 ) : StakeKitAuthProvider {

    override fun getApiKey(): String {
-        return environmentConfigStorage.getConfigSync().stakeKitApiKey ?: error("No StakeKit api key provided")
+        return environmentConfig.stakeKitApiKey ?: error("No StakeKit api key provided")
    }
 }
--- a/app/src/main/java/com/tangem/tap/network/auth/di/AuthModule.kt
+++ b/app/src/main/java/com/tangem/tap/network/auth/di/AuthModule.kt
@ -1,7 +1,7 @@
 package com.tangem.tap.network.auth.di

 import com.tangem.datasource.api.common.AuthProvider
-import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
+import com.tangem.datasource.local.config.environment.EnvironmentConfig
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.lib.auth.ExpressAuthProvider
 import com.tangem.lib.auth.P2PEthPoolAuthProvider
@ -22,11 +22,11 @@ internal class AuthModule {
    @Singleton
    fun provideAuthProvider(
        userWalletsListRepository: UserWalletsListRepository,
-        environmentConfigStorage: EnvironmentConfigStorage,
+        environmentConfig: EnvironmentConfig,
    ): AuthProvider {
        return DefaultAuthProvider(
            userWalletsListRepository = userWalletsListRepository,
-            environmentConfigStorage = environmentConfigStorage,
+            environmentConfig = environmentConfig,
        )
    }

@ -38,14 +38,14 @@ internal class AuthModule {

    @Provides
    @Singleton
-    fun provideStakeKitAuthProvider(environmentConfigStorage: EnvironmentConfigStorage): StakeKitAuthProvider {
-        return DefaultStakeKitAuthProvider(environmentConfigStorage)
+    fun provideStakeKitAuthProvider(environmentConfig: EnvironmentConfig): StakeKitAuthProvider {
+        return DefaultStakeKitAuthProvider(environmentConfig)
    }

    @Provides
    @Singleton
-    fun provideP2PEthPoolAuthProvider(environmentConfigStorage: EnvironmentConfigStorage): P2PEthPoolAuthProvider {
-        return DefaultP2PEthPoolAuthProvider(environmentConfigStorage)
+    fun provideP2PEthPoolAuthProvider(environmentConfig: EnvironmentConfig): P2PEthPoolAuthProvider {
+        return DefaultP2PEthPoolAuthProvider(environmentConfig)
    }

    @Provides
--- a/app/src/main/java/com/tangem/tap/network/exchangeServices/SellService.kt
+++ b/app/src/main/java/com/tangem/tap/network/exchangeServices/SellService.kt
@ -21,6 +21,4 @@ interface SellService {
        walletAddress: String,
        isDarkTheme: Boolean,
    ): String?
-
-    fun getSellCryptoReceiptUrl(transactionId: String): String?
 }
--- a/app/src/main/java/com/tangem/tap/network/exchangeServices/moonpay/MoonPayService.kt
+++ b/app/src/main/java/com/tangem/tap/network/exchangeServices/moonpay/MoonPayService.kt
@ -19,7 +19,6 @@ import com.tangem.tap.domain.model.Currency
 import com.tangem.tap.network.exchangeServices.SellService
 import com.tangem.tap.network.exchangeServices.SellServiceInitializationStatus
 import com.tangem.tap.network.exchangeServices.moonpay.models.MoonPayAvailableCurrency
-import com.tangem.utils.Provider
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import timber.log.Timber
@ -28,8 +27,8 @@ import javax.crypto.spec.SecretKeySpec

 class MoonPayService(
    private val api: MoonPayApi,
-    private val apiKeyProvider: Provider<String>,
-    private val secretKeyProvider: Provider<String>,
+    private val apiKey: String,
+    private val secretKey: String,
    private val userWalletProvider: () -> UserWallet?,
 ) : SellService {

@ -47,18 +46,18 @@ class MoonPayService(
            _initializationStatus.value = lceLoading()

            performRequest {
-                val userStatus = when (val result = performRequest { api.getUserStatus(apiKeyProvider()) }) {
+                val userStatus = when (val result = performRequest { api.getUserStatus(apiKey) }) {
                    is Result.Failure -> {
-                        Timber.e("Failed to load user status", result.error)
+                        Timber.e(result.error, "Failed to load user status")
                        _initializationStatus.value = result.error.lceError()
                        return@performRequest
                    }
                    is Result.Success -> result.data
                }

-                val currencies = when (val result = performRequest { api.getCurrencies(apiKeyProvider()) }) {
+                val currencies = when (val result = performRequest { api.getCurrencies(apiKey) }) {
                    is Result.Failure -> {
-                        Timber.e("Failed to load currencies", result.error)
+                        Timber.e(result.error, "Failed to load currencies")
                        _initializationStatus.value = result.error.lceError()
                        return@performRequest
                    }
@ -163,7 +162,7 @@ class MoonPayService(
        val uri = Uri.Builder()
            .scheme(SCHEME)
            .authority(URL_SELL)
-            .appendQueryParameter("apiKey", apiKeyProvider())
+            .appendQueryParameter("apiKey", apiKey)
            .appendQueryParameter("baseCurrencyCode", moonpayCurrency.currencyCode.uppercase())
            .appendQueryParameter("refundWalletAddress", walletAddress)
            .appendQueryParameter("redirectURL", "tangem://redirect_sell?currency_id=${cryptoCurrency.id.value}")
@ -177,17 +176,9 @@ class MoonPayService(
        return uri.build().toString()
    }

-    override fun getSellCryptoReceiptUrl(transactionId: String): String {
-        return Uri.Builder()
-            .scheme(SCHEME)
-            .authority(URL_SELL)
-            .appendPath("transaction_receipt")
-            .appendQueryParameter("transactionId", transactionId).build().toString()
-    }
-
    private fun createSignature(data: String): String {
        val sha256Hmac = Mac.getInstance("HmacSHA256")
-        val secretKey = SecretKeySpec(secretKeyProvider().toByteArray(), "HmacSHA256")
+        val secretKey = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
        sha256Hmac.init(secretKey)
        val sha256encoded = sha256Hmac.doFinal("?$data".toByteArray())
        return Base64.encodeToString(sha256encoded, Base64.NO_WRAP)
--- a/app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphState.kt
+++ b/app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphState.kt
@ -11,7 +11,6 @@ import com.tangem.core.navigation.url.UrlOpener
 import com.tangem.core.ui.clipboard.ClipboardManager
 import com.tangem.data.card.TransactionSignerFactory
 import com.tangem.datasource.connection.NetworkConnectionManager
-import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
 import com.tangem.datasource.local.config.issuers.IssuersConfigStorage
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.datasource.local.token.UserTokensResponseStore
@ -63,7 +62,6 @@ data class DaggerGraphState(
    val shareManager: ShareManager? = null,
    val appRouter: AppRouter? = null,
    val transactionSignerFactory: TransactionSignerFactory? = null,
-    val environmentConfigStorage: EnvironmentConfigStorage? = null,
    val onboardingV2FeatureToggles: OnboardingV2FeatureToggles? = null,
    val onboardingRepository: OnboardingRepository? = null,
    val excludedBlockchains: ExcludedBlockchains? = null,
--- a/app/src/main/java/com/tangem/tap/routing/utils/ChildFactory.kt
+++ b/app/src/main/java/com/tangem/tap/routing/utils/ChildFactory.kt
@ -2,7 +2,6 @@ package com.tangem.tap.routing.utils

 import com.tangem.common.routing.AppRoute
 import com.tangem.core.decompose.context.AppComponentContext
-import com.tangem.domain.models.PortfolioId
 import com.tangem.domain.qrscanning.models.SourceType
 import com.tangem.feature.qrscanning.QrScanningComponent
 import com.tangem.feature.referral.api.ReferralComponent
@ -18,7 +17,6 @@ import com.tangem.features.details.component.DetailsComponent
 import com.tangem.features.disclaimer.api.components.DisclaimerComponent
 import com.tangem.features.feed.entry.components.FeedEntryComponent
 import com.tangem.features.feed.entry.components.FeedEntryRoute
-import com.tangem.features.feed.entry.featuretoggle.FeedFeatureToggle
 import com.tangem.features.home.api.HomeComponent
 import com.tangem.features.hotwallet.*
 import com.tangem.features.kyc.KycComponent
@ -26,7 +24,6 @@ import com.tangem.features.managetokens.component.ChooseManagedTokensComponent
 import com.tangem.features.managetokens.component.ManageTokensComponent
 import com.tangem.features.managetokens.component.ManageTokensMode
 import com.tangem.features.managetokens.component.ManageTokensSource
-import com.tangem.features.markets.details.MarketsTokenDetailsComponent
 import com.tangem.features.markets.tokenlist.MarketsTokenListComponent
 import com.tangem.features.nft.component.NFTComponent
 import com.tangem.features.onboarding.v2.entry.OnboardingEntryComponent
@ -67,7 +64,6 @@ internal class ChildFactory @Inject constructor(
    private val walletHardwareBackupComponentFactory: WalletHardwareBackupComponent.Factory,
    private val disclaimerComponentFactory: DisclaimerComponent.Factory,
    private val manageTokensComponentFactory: ManageTokensComponent.Factory,
-    private val marketsTokenDetailsComponentFactory: MarketsTokenDetailsComponent.Factory,
    private val marketsTokenListComponentFactory: MarketsTokenListComponent.FactoryScreen,
    private val onrampComponentFactory: OnrampComponent.Factory,
    private val onrampSuccessComponentFactory: OnrampSuccessComponent.Factory,
@ -117,7 +113,6 @@ internal class ChildFactory @Inject constructor(
    private val kycComponentFactory: KycComponent.Factory,
    private val yieldSupplyEntryComponentFactory: YieldSupplyEntryComponent.Factory,
    private val feedEntryComponentFactory: FeedEntryComponent.Factory,
-    private val feedFeatureToggle: FeedFeatureToggle,
 ) {

    @Suppress("LongMethod", "CyclomaticComplexMethod")
@ -147,11 +142,7 @@ internal class ChildFactory @Inject constructor(
                    AppRoute.ManageTokens.Source.ACCOUNT -> ManageTokensSource.ACCOUNT
                }

-                val mode = when (val portfolio = route.portfolioId) {
-                    is PortfolioId.Account -> ManageTokensMode.Account(portfolio.accountId)
-                    is PortfolioId.Wallet -> ManageTokensMode.Wallet(portfolio.userWalletId)
-                    null -> ManageTokensMode.None
-                }
+                val mode = route.accountId?.let { ManageTokensMode.Account(it) } ?: ManageTokensMode.None

                createComponentChild(
                    context = context,
@ -193,39 +184,21 @@ internal class ChildFactory @Inject constructor(
                )
            }
            is AppRoute.MarketsTokenDetails -> {
-                if (feedFeatureToggle.isFeedEnabled) {
-                    createComponentChild(
-                        context = context,
-                        params = FeedEntryRoute.MarketTokenDetails(
-                            token = route.token,
-                            appCurrency = route.appCurrency,
-                            shouldShowPortfolio = route.shouldShowPortfolio,
-                            analyticsParams = route.analyticsParams?.let { params ->
-                                FeedEntryRoute.MarketTokenDetails.AnalyticsParams(
-                                    blockchain = params.blockchain,
-                                    source = params.source,
-                                )
-                            },
-                        ),
-                        componentFactory = feedEntryComponentFactory,
-                    )
-                } else {
-                    createComponentChild(
-                        context = context,
-                        params = MarketsTokenDetailsComponent.Params(
-                            token = route.token,
-                            appCurrency = route.appCurrency,
-                            shouldShowPortfolio = route.shouldShowPortfolio,
-                            analyticsParams = route.analyticsParams?.let { params ->
-                                MarketsTokenDetailsComponent.AnalyticsParams(
-                                    blockchain = params.blockchain,
-                                    source = params.source,
-                                )
-                            },
-                        ),
-                        componentFactory = marketsTokenDetailsComponentFactory,
-                    )
-                }
+                createComponentChild(
+                    context = context,
+                    params = FeedEntryRoute.MarketTokenDetails(
+                        token = route.token,
+                        appCurrency = route.appCurrency,
+                        shouldShowPortfolio = route.shouldShowPortfolio,
+                        analyticsParams = route.analyticsParams?.let { params ->
+                            FeedEntryRoute.MarketTokenDetails.AnalyticsParams(
+                                blockchain = params.blockchain,
+                                source = params.source,
+                            )
+                        },
+                    ),
+                    componentFactory = feedEntryComponentFactory,
+                )
            }
            is AppRoute.Onramp -> {
                createComponentChild(
--- a/app/src/main/java/com/tangem/tap/routing/utils/DeepLinkFactory.kt
+++ b/app/src/main/java/com/tangem/tap/routing/utils/DeepLinkFactory.kt
@ -7,7 +7,6 @@ import com.tangem.common.routing.DeepLinkScheme
 import com.tangem.data.card.sdk.CardSdkProvider
 import com.tangem.feature.referral.api.deeplink.ReferralDeepLinkHandler
 import com.tangem.features.feed.entry.deeplink.NewsDetailsDeepLinkHandler
-import com.tangem.features.feed.entry.featuretoggle.FeedFeatureToggle
 import com.tangem.features.markets.deeplink.MarketsDeepLinkHandler
 import com.tangem.features.markets.deeplink.MarketsTokenDetailDeepLinkHandler
 import com.tangem.features.onramp.deeplink.BuyDeepLinkHandler
@ -53,7 +52,6 @@ internal class DeepLinkFactory @Inject constructor(
    private val promoDeepLink: PromoDeeplinkHandler.Factory,
    private val onboardVisaDeepLink: OnboardVisaDeepLinkHandler.Factory,
    private val newsDetailsDeepLink: NewsDetailsDeepLinkHandler.Factory,
-    private val feedFeatureToggle: FeedFeatureToggle,
 ) {
    private val permittedAppRoute = MutableStateFlow(false)

@ -127,7 +125,7 @@ internal class DeepLinkFactory @Inject constructor(
                    onboardVisaDeepLink.create(deeplinkUri)
                    return
                }
-                deeplinkUri.path?.startsWith("/news") == true && feedFeatureToggle.isFeedEnabled -> {
+                deeplinkUri.path?.startsWith("/news") == true -> {
                    newsDetailsDeepLink.create(coroutineScope, deeplinkUri)
                    return
                }