Updated on 2026-08-14

.idea/inspectionProfiles/Project_Default.xml

@@ -4,8 +4,36 @@
     <inspection_tool class="CanBeParameter" enabled="true" level="ERROR" enabled_by_default="true" />
     <inspection_tool class="CanBePrimaryConstructorProperty" enabled="true" level="ERROR" enabled_by_default="true" />
     <inspection_tool class="ComplexRedundantLet" enabled="true" level="ERROR" enabled_by_default="true" />
+    <inspection_tool class="ComposePreviewDimensionRespectsLimit" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+      <option name="previewFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="ComposePreviewMustBeTopLevelFunction" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+      <option name="previewFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="ComposePreviewNeedsComposableAnnotation" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+      <option name="previewFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="ComposePreviewNotSupportedInUnitTestFiles" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+      <option name="previewFile" value="true" />
+    </inspection_tool>
     <inspection_tool class="ConstantConditionIf" enabled="true" level="ERROR" enabled_by_default="true" />
     <inspection_tool class="ExplicitThis" enabled="false" level="ERROR" enabled_by_default="false" />
+    <inspection_tool class="GlancePreviewDimensionRespectsLimit" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="GlancePreviewMustBeTopLevelFunction" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="GlancePreviewNeedsComposableAnnotation" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
+    <inspection_tool class="GlancePreviewNotSupportedInUnitTestFiles" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+    </inspection_tool>
     <inspection_tool class="KotlinDoubleNegation" enabled="true" level="ERROR" enabled_by_default="true" />
     <inspection_tool class="KotlinRedundantOverride" enabled="true" level="ERROR" enabled_by_default="true" />
     <inspection_tool class="KotlinUnusedImport" enabled="true" level="ERROR" enabled_by_default="true" />
@@ -19,6 +47,10 @@
       <option name="composableFile" value="true" />
       <option name="previewFile" value="true" />
     </inspection_tool>
+    <inspection_tool class="PreviewDeviceShouldUseNewSpec" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="composableFile" value="true" />
+      <option name="previewFile" value="true" />
+    </inspection_tool>
     <inspection_tool class="PreviewDimensionRespectsLimit" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="composableFile" value="true" />
       <option name="previewFile" value="true" />

app/build.gradle.kts

@@ -74,13 +74,15 @@ dependencies {
     implementation(projects.domain.walletConnect)
     implementation(projects.domain.markets)
     implementation(projects.domain.manageTokens)
+    implementation(projects.domain.onramp)
 
     implementation(projects.common)
     implementation(projects.common.routing)
+    implementation(projects.common.google)
     implementation(projects.core.analytics)
     implementation(projects.core.analytics.models)
     implementation(projects.core.navigation)
-    implementation(projects.core.featuretoggles)
+    implementation(projects.core.configToggles)
     implementation(projects.core.res)
     implementation(projects.core.ui)
     implementation(projects.core.datasource)
@@ -112,6 +114,7 @@ dependencies {
     implementation(projects.data.walletConnect)
     implementation(projects.data.markets)
     implementation(projects.data.manageTokens)
+    implementation(projects.data.onramp)
 
     /** Features */
     implementation(projects.features.onboarding)
@@ -220,14 +223,13 @@ dependencies {
     implementation(deps.lottie)
     implementation(deps.compose.accompanist.appCompatTheme)
     implementation(deps.compose.accompanist.systemUiController)
-    implementation(deps.compose.accompanist.webView)
     implementation(deps.xmlShimmer)
     implementation(deps.viewBindingDelegate)
     implementation(deps.armadillo)
     implementation(deps.mviCore.watcher)
     implementation(deps.kotlin.serialization)
-    implementation(deps.walletConnectCore)
-    implementation(deps.walletConnectWeb3)
+    implementation(deps.reownCore)
+    implementation(deps.reownWeb3)
     implementation(deps.prettyLogger)
 
     /** Testing libraries */

app/src/main/AndroidManifest.xml

@@ -2,6 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
+    <uses-permission android:name="android.permission.HIDE_OVERLAY_WINDOWS" />
     <uses-permission android:name="android.permission.VIBRATE" />
     <uses-permission android:name="android.permission.NFC" />
     <uses-permission android:name="android.permission.INTERNET" />
@@ -14,7 +15,7 @@
         android:name="android.permission.READ_EXTERNAL_STORAGE"
         android:maxSdkVersion="32" />
     <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
-    <uses-permission android:name="com.google.android.gms.permission.AD_ID"/>
+    <uses-permission android:name="com.google.android.gms.permission.AD_ID" />
 
     <uses-feature android:name="android.hardware.camera" />
     <uses-feature android:name="android.hardware.camera.autofocus" />
@@ -35,10 +36,10 @@
         android:fullBackupContent="false"
         android:hardwareAccelerated="true"
         android:icon="@mipmap/ic_launcher"
-        android:resizeableActivity="@bool/resizeable_activity"
         android:label="@string/tangem_app_name"
         android:largeHeap="@bool/largeHeap"
         android:networkSecurityConfig="@xml/network_security_config"
+        android:resizeableActivity="@bool/resizeable_activity"
         android:roundIcon="@mipmap/ic_launcher"
         android:supportsRtl="true"
         tools:ignore="GoogleAppIndexingWarning"
@@ -52,7 +53,7 @@
             android:name="com.tangem.tap.MainActivity"
             android:configChanges="uiMode"
             android:exported="true"
-            android:launchMode="singleTop"
+            android:launchMode="singleTask"
             android:screenOrientation="portrait"
             android:theme="@style/SplashTheme"
             android:windowSoftInputMode="adjustResize">
@@ -118,6 +119,17 @@
                     android:scheme="tangem" />
             </intent-filter>
 
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data
+                    android:host="onramp-success"
+                    android:scheme="tangem" />
+            </intent-filter>
+
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
 

app/src/main/assets/testnet_tokens.json

@@ -749,6 +749,16 @@
                 }
             ]
         },
+        {
+            "id": "chiliz",
+            "name": "Chiliz",
+            "symbol": "CHZ",
+            "networks": [
+                {
+                    "networkId": "chiliz/test"
+                }
+            ]
+        },
         {
             "id": "casper-network",
             "name": "Casper",

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

@@ -3,9 +3,11 @@ package com.tangem.tap
 import com.tangem.TangemSdkLogger
 import com.tangem.blockchainsdk.BlockchainSDKFactory
 import com.tangem.blockchainsdk.signer.TransactionSignerFactory
+import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.common.routing.AppRouter
 import com.tangem.core.analytics.filter.OneTimeEventFilter
-import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
+import com.tangem.core.configtoggle.blockchain.ExcludedBlockchainsManager
+import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 import com.tangem.core.navigation.share.ShareManager
 import com.tangem.core.navigation.url.UrlOpener
 import com.tangem.datasource.connection.NetworkConnectionManager
@@ -22,6 +24,7 @@ import com.tangem.domain.feedback.GetCardInfoUseCase
 import com.tangem.domain.feedback.SendFeedbackEmailUseCase
 import com.tangem.domain.onboarding.SaveTwinsOnboardingShownUseCase
 import com.tangem.domain.onboarding.WasTwinsOnboardingShownUseCase
+import com.tangem.domain.onboarding.repository.OnboardingRepository
 import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.settings.usercountry.GetUserCountryUseCase
 import com.tangem.domain.walletmanager.WalletManagersFacade
@@ -34,6 +37,7 @@ import com.tangem.tap.common.log.TangemAppLoggerInitializer
 import com.tangem.tap.domain.scanCard.CardScanningFeatureToggles
 import com.tangem.tap.features.home.featuretoggles.HomeFeatureToggles
 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
@@ -52,6 +56,8 @@ interface ApplicationEntryPoint {
 
     fun getFeatureTogglesManager(): FeatureTogglesManager
 
+    fun getExcludedBlockchainsManager(): ExcludedBlockchainsManager
+
     fun getNetworkConnectionManager(): NetworkConnectionManager
 
     fun getCardScanningFeatureToggles(): CardScanningFeatureToggles
@@ -113,4 +119,10 @@ interface ApplicationEntryPoint {
     fun getOnrampFeatureToggles(): OnrampFeatureToggles
 
     fun getOnboardingV2FeatureToggles(): OnboardingV2FeatureToggles
+
+    fun getOnboardingRepository(): OnboardingRepository
+
+    fun getCoroutineDispatcherProvider(): CoroutineDispatcherProvider
+
+    fun getExcludedBlockchains(): ExcludedBlockchains
 }

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

@@ -18,8 +18,7 @@ class ForegroundActivityObserver : ActivityResultCaller {
 
     val foregroundActivity: AppCompatActivity?
         get() = activities.entries
-            .filterNot { it.value.isDestroyed }
-            .firstOrNull()
+            .firstOrNull { it.value?.isDestroyed == false }
             ?.value
 
     internal val callbacks: ActivityLifecycleCallbacks

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

@@ -6,6 +6,7 @@ import android.content.pm.ActivityInfo
 import android.content.res.Configuration
 import android.os.Build
 import android.os.Bundle
+import android.view.MotionEvent
 import android.view.View
 import android.view.WindowManager
 import androidx.activity.SystemBarStyle
@@ -44,6 +45,8 @@ import com.tangem.domain.apptheme.model.AppThemeMode
 import com.tangem.domain.card.ScanCardUseCase
 import com.tangem.domain.card.repository.CardRepository
 import com.tangem.domain.card.repository.CardSdkConfigRepository
+import com.tangem.domain.settings.SetGooglePayAvailabilityUseCase
+import com.tangem.domain.settings.SetGoogleServicesAvailabilityUseCase
 import com.tangem.domain.settings.ShouldInitiallyAskPermissionUseCase
 import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.staking.SendUnsubmittedHashesUseCase
@@ -52,13 +55,16 @@ import com.tangem.domain.tokens.GetPolkadotCheckHasResetUseCase
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.feature.qrscanning.QrScanningRouter
 import com.tangem.feature.wallet.presentation.wallet.analytics.WalletScreenAnalyticsEvent
+import com.tangem.features.onboarding.v2.OnboardingV2FeatureToggles
 import com.tangem.features.pushnotifications.api.navigation.PushNotificationsRouter
 import com.tangem.features.pushnotifications.api.utils.PUSH_PERMISSION
 import com.tangem.features.send.api.navigation.SendRouter
 import com.tangem.features.staking.api.navigation.StakingRouter
 import com.tangem.features.tokendetails.navigation.TokenDetailsRouter
 import com.tangem.features.wallet.navigation.WalletRouter
+import com.tangem.google.GoogleServicesHelper
 import com.tangem.operations.backup.BackupService
+import com.tangem.sdk.api.BackupServiceHolder
 import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.sdk.extensions.init
 import com.tangem.tap.common.ActivityResultCallbackHolder
@@ -72,6 +78,7 @@ import com.tangem.tap.common.redux.NotificationsHandler
 import com.tangem.tap.domain.walletconnect2.domain.WalletConnectInteractor
 import com.tangem.tap.features.intentHandler.IntentProcessor
 import com.tangem.tap.features.intentHandler.handlers.BackgroundScanIntentHandler
+import com.tangem.tap.features.intentHandler.handlers.OnPushClickedIntentHandler
 import com.tangem.tap.features.intentHandler.handlers.WalletConnectLinkIntentHandler
 import com.tangem.tap.features.main.MainViewModel
 import com.tangem.tap.features.main.model.Toast
@@ -80,6 +87,7 @@ import com.tangem.tap.proxy.AppStateHolder
 import com.tangem.tap.proxy.redux.DaggerGraphAction
 import com.tangem.tap.routing.RoutingComponent
 import com.tangem.tap.routing.configurator.AppRouterConfig
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.coroutines.FeatureCoroutineExceptionHandler
 import com.tangem.wallet.R
 import com.tangem.wallet.databinding.ActivityMainBinding
@@ -186,6 +194,21 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
     @Inject
     lateinit var shouldInitiallyAskPermissionUseCase: ShouldInitiallyAskPermissionUseCase
 
+    @Inject
+    lateinit var backupServiceHolder: BackupServiceHolder
+
+    @Inject
+    lateinit var onboardingV2FeatureToggles: OnboardingV2FeatureToggles
+
+    @Inject
+    lateinit var setGoogleServicesAvailabilityUseCase: SetGoogleServicesAvailabilityUseCase
+
+    @Inject
+    lateinit var setGooglePayAvailabilityUseCase: SetGooglePayAvailabilityUseCase
+
+    @Inject
+    lateinit var dispatchers: CoroutineDispatcherProvider
+
     internal val viewModel: MainViewModel by viewModels()
 
     private lateinit var appThemeModeFlow: SharedFlow<AppThemeMode>
@@ -223,6 +246,10 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
             window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
         }
 
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            window.setHideOverlayWindows(true)
+        }
+
         splashScreen.setKeepOnScreenCondition { viewModel.isSplashScreenShown }
 
         installActivityDependencies()
@@ -235,6 +262,7 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
         observeStateUpdates()
         observePolkadotAccountHealthCheck()
         sendStakingUnsubmittedHashes()
+        checkGoogleServicesAvailability()
 
         if (intent != null) {
             deepLinksRegistry.launch(intent)
@@ -295,7 +323,14 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
         cardSdkOwner.register(activity = this)
         tangemSdkManager = injectedTangemSdkManager
         appStateHolder.tangemSdkManager = tangemSdkManager
-        backupService = BackupService.init(cardSdkConfigRepository.sdk, this)
+
+        if (onboardingV2FeatureToggles.isOnboardingV2Enabled) {
+            backupServiceHolder.createAndSetService(cardSdkConfigRepository.sdk, this)
+            backupService = backupServiceHolder.backupService.get()!! // will be deleted eventually
+        } else {
+            backupService = BackupService.init(cardSdkConfigRepository.sdk, this)
+        }
+
         lockUserWalletsTimer = LockUserWalletsTimer(
             owner = this,
             settingsRepository = settingsRepository,
@@ -382,6 +417,7 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
 
     private fun initIntentHandlers() {
         val hasSavedWalletsProvider = { userWalletsListManager.hasUserWallets }
+        intentProcessor.addHandler(OnPushClickedIntentHandler(analyticsEventsHandler))
         intentProcessor.addHandler(BackgroundScanIntentHandler(hasSavedWalletsProvider, lifecycleScope))
         intentProcessor.addHandler(WalletConnectLinkIntentHandler())
     }
@@ -487,6 +523,23 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
         lockUserWalletsTimer?.restart()
     }
 
+    override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+        val isPartiallyObscured = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            event.flags and MotionEvent.FLAG_WINDOW_IS_PARTIALLY_OBSCURED != 0
+        } else {
+            false
+        }
+
+        val isFullyObscured = event.flags and MotionEvent.FLAG_WINDOW_IS_OBSCURED != 0
+
+        if (isPartiallyObscured || isFullyObscured) {
+            Timber.e("Window is partially or fully obscured")
+            return false
+        }
+
+        return super.dispatchTouchEvent(event)
+    }
+
     private fun showSnackbar(text: String, length: Int, buttonTitle: String?, action: View.OnClickListener?) {
         if (snackbar != null) return
 
@@ -587,6 +640,22 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
         }
     }
 
+    private fun checkGoogleServicesAvailability() {
+        val isGoogleServicesAvailable = GoogleServicesHelper.checkGoogleServicesAvailability(this)
+
+        lifecycleScope.launch {
+            setGoogleServicesAvailabilityUseCase(isGoogleServicesAvailable)
+
+            if (isGoogleServicesAvailable) {
+                val paymentsClient = GoogleServicesHelper.createPaymentsClient(this@MainActivity)
+                val isGooglePayAvailable = GoogleServicesHelper.checkGooglePayAvailability(paymentsClient)
+                setGooglePayAvailabilityUseCase(isGooglePayAvailable)
+            } else {
+                setGooglePayAvailabilityUseCase(false)
+            }
+        }
+    }
+
     companion object {
         private const val APP_THEME_LOAD_TIMEOUT = 2
     }

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

@@ -9,6 +9,7 @@ import com.tangem.TangemSdkLogger
 import com.tangem.blockchain.network.BlockchainSdkRetrofitBuilder
 import com.tangem.blockchainsdk.BlockchainSDKFactory
 import com.tangem.blockchainsdk.signer.TransactionSignerFactory
+import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.common.routing.AppRouter
 import com.tangem.core.analytics.Analytics
 import com.tangem.core.analytics.api.ParamsInterceptor
@@ -17,7 +18,8 @@ import com.tangem.core.analytics.models.AnalyticsEvent
 import com.tangem.core.analytics.models.AnalyticsParam
 import com.tangem.core.analytics.models.Basic
 import com.tangem.core.analytics.models.Basic.TransactionSent.WalletForm
-import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
+import com.tangem.core.configtoggle.blockchain.ExcludedBlockchainsManager
+import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 import com.tangem.datasource.api.common.MoshiConverter
 import com.tangem.datasource.api.common.createNetworkLoggingInterceptor
 import com.tangem.datasource.connection.NetworkConnectionManager
@@ -36,6 +38,7 @@ import com.tangem.domain.feedback.GetCardInfoUseCase
 import com.tangem.domain.feedback.SendFeedbackEmailUseCase
 import com.tangem.domain.onboarding.SaveTwinsOnboardingShownUseCase
 import com.tangem.domain.onboarding.WasTwinsOnboardingShownUseCase
+import com.tangem.domain.onboarding.repository.OnboardingRepository
 import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.settings.usercountry.GetUserCountryUseCase
 import com.tangem.domain.walletmanager.WalletManagersFacade
@@ -57,9 +60,11 @@ import com.tangem.tap.domain.tasks.product.DerivationsFinder
 import com.tangem.tap.features.home.featuretoggles.HomeFeatureToggles
 import com.tangem.tap.proxy.AppStateHolder
 import com.tangem.tap.proxy.redux.DaggerGraphState
-import com.tangem.utils.coroutines.AppCoroutineDispatcherProvider
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.wallet.BuildConfig
 import dagger.hilt.EntryPoints
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.runBlocking
 import org.rekotlin.Store
 import com.tangem.tap.domain.walletconnect2.domain.LegacyWalletConnectRepository as WalletConnect2Repository
@@ -88,6 +93,9 @@ abstract class TangemApplication : Application(), ImageLoaderFactory {
     private val featureTogglesManager: FeatureTogglesManager
         get() = entryPoint.getFeatureTogglesManager()
 
+    private val excludedBlockchainsManager: ExcludedBlockchainsManager
+        get() = entryPoint.getExcludedBlockchainsManager()
+
     private val networkConnectionManager: NetworkConnectionManager
         get() = entryPoint.getNetworkConnectionManager()
 
@@ -180,6 +188,15 @@ abstract class TangemApplication : Application(), ImageLoaderFactory {
 
     private val onboardingV2FeatureToggles: OnboardingV2FeatureToggles
         get() = entryPoint.getOnboardingV2FeatureToggles()
+
+    private val onboardingRepository: OnboardingRepository
+        get() = entryPoint.getOnboardingRepository()
+
+    private val dispatchers: CoroutineDispatcherProvider
+        get() = entryPoint.getCoroutineDispatcherProvider()
+
+    private val excludedBlockchains: ExcludedBlockchains
+        get() = entryPoint.getExcludedBlockchains()
     // endregion
 
     override fun onCreate() {
@@ -200,9 +217,11 @@ abstract class TangemApplication : Application(), ImageLoaderFactory {
         // TODO: Try to performance and user experience.
         //  [REDACTED_JIRA]
         runBlocking {
-            featureTogglesManager.init()
-
-            initWithConfigDependency(environmentConfig = environmentConfigStorage.initialize())
+            awaitAll(
+                async { featureTogglesManager.init() },
+                async { excludedBlockchainsManager.init() },
+                async { initWithConfigDependency(environmentConfig = environmentConfigStorage.initialize()) },
+            )
         }
 
         loadNativeLibraries()
@@ -216,7 +235,7 @@ abstract class TangemApplication : Application(), ImageLoaderFactory {
 
         derivationsFinder = DerivationsFinder(
             appPreferencesStore = appPreferencesStore,
-            dispatchers = AppCoroutineDispatcherProvider(),
+            dispatchers = dispatchers,
         )
         appStateHolder.mainStore = store
 
@@ -258,6 +277,8 @@ abstract class TangemApplication : Application(), ImageLoaderFactory {
                     onrampFeatureToggles = onrampFeatureToggles,
                     environmentConfigStorage = environmentConfigStorage,
                     onboardingV2FeatureToggles = onboardingV2FeatureToggles,
+                    onboardingRepository = onboardingRepository,
+                    excludedBlockchains = excludedBlockchains,
                     appPreferencesStore = appPreferencesStore,
                 ),
             ),

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

@@ -140,11 +140,22 @@ class DialogManager : StoreSubscriber<GlobalState> {
                 message = state.dialog.error.message,
                 context = context,
             )
+            is WalletConnectDialog.UnsupportedWcVersion -> SimpleAlertDialog.create(
+                titleRes = R.string.common_error,
+                messageRes = R.string.unsupported_wc_version,
+                context = context,
+            )
             is BackupDialog.AttestationFailed -> AttestationFailedDialog.create(context)
             is BackupDialog.AddMoreBackupCards -> AddMoreBackupCardsDialog.create(context)
             is BackupDialog.BackupInProgress -> BackupInProgressDialog.create(context)
-            is BackupDialog.UnfinishedBackupFound -> UnfinishedBackupFoundDialog.create(context)
-            is BackupDialog.ConfirmDiscardingBackup -> ConfirmDiscardingBackupDialog.create(context)
+            is BackupDialog.UnfinishedBackupFound -> UnfinishedBackupFoundDialog.create(
+                context = context,
+                scanResponse = state.dialog.scanResponse,
+            )
+            is BackupDialog.ConfirmDiscardingBackup -> ConfirmDiscardingBackupDialog.create(
+                context = context,
+                unfinishedBackupScanResponse = state.dialog.scanResponse,
+            )
             is BackupDialog.ResetBackupCard -> ResetBackupCardDialog.create(
                 context = context,
                 cardId = state.dialog.cardId,

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

@@ -1,25 +0,0 @@
-package com.tangem.tap.common.analytics.events
-
-import com.tangem.core.analytics.models.AnalyticsEvent
-
-/**
-[REDACTED_AUTHOR]
- */
-sealed class MainScreen(
-    event: String,
-    params: Map<String, String> = mapOf(),
-) : AnalyticsEvent("Main Screen", event, params) {
-
-    class ScreenOpened : MainScreen("Screen opened")
-    class ButtonScanCard : MainScreen("Button - Scan Card")
-
-    class EnableBiometrics(state: AnalyticsParam.OnOffState) : MainScreen(
-        event = "Enable Biometric",
-        params = mapOf("State" to state.value),
-    )
-
-    class NoticeRateAppButton(result: AnalyticsParam.RateApp) : MainScreen(
-        event = "Notice - Rate The App Button Tapped",
-        params = mapOf("Result" to result.value),
-    )
-}

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

@@ -0,0 +1,13 @@
+package com.tangem.tap.common.analytics.events
+
+import com.tangem.core.analytics.models.AnalyticsEvent
+
+internal sealed class Push(event: String) : AnalyticsEvent(
+    category = "Push",
+    event = event,
+    params = emptyMap(),
+    error = null,
+) {
+
+    data object PushNotificationOpened : Push(event = "Push Notification Opened")
+}

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

@@ -11,7 +11,7 @@ sealed class SignIn(
     error: Throwable? = null,
 ) : AnalyticsEvent("Sign In", event, params, error) {
 
-    class ScreenOpened : SignIn(event = "Sing In Screen Opened")
+    class ScreenOpened : SignIn(event = "Sign In Screen Opened")
 
     class ButtonBiometricSignIn : SignIn(event = "Button - Biometric Sign In")
     class ButtonCardSignIn : SignIn(event = "Button - Card Sign In")

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

@@ -12,11 +12,12 @@ internal sealed class WalletConnect(
 ) : AnalyticsEvent("Wallet Connect", event, params, error) {
 
     class ScreenOpened : WalletConnect(event = "WC Screen Opened")
-    class NewSessionEstablished(dAppName: String, dAppUrl: String) : WalletConnect(
+    class NewSessionEstablished(dAppName: String, dAppUrl: String, blockchainNames: List<String>) : WalletConnect(
         event = "New Session Established",
         params = mapOf(
             AnalyticsParam.DAPP_NAME to dAppName,
             AnalyticsParam.DAPP_URL to dAppUrl,
+            AnalyticsParam.BLOCKCHAIN to blockchainNames.joinToString(","),
         ),
     )
 

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

@@ -9,7 +9,6 @@ import com.tangem.domain.wallets.builder.UserWalletIdBuilder
 import com.tangem.tap.common.analytics.converters.ParamCardCurrencyConverter
 import com.tangem.tap.common.analytics.events.AnalyticsParam
 import com.tangem.tap.common.analytics.events.IntroductionProcess
-import com.tangem.tap.common.analytics.events.MainScreen
 import com.tangem.tap.common.extensions.inject
 import com.tangem.tap.features.demo.DemoHelper
 import com.tangem.tap.proxy.redux.DaggerGraphState
@@ -31,7 +30,7 @@ class CardContextInterceptor(
 
     override fun canBeAppliedTo(event: AnalyticsEvent): Boolean {
         return when (event) {
-            is IntroductionProcess.ButtonScanCard, is MainScreen.ButtonScanCard -> false
+            is IntroductionProcess.ButtonScanCard -> false
             else -> true
         }
     }

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

@@ -1,18 +0,0 @@
-package com.tangem.tap.common.extensions
-
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.common.extensions.remove
-
-fun Blockchain.getNetworkStandardName(): String {
-    return when (this) {
-        Blockchain.Ethereum, Blockchain.EthereumTestnet -> "ERC20"
-        Blockchain.BSC, Blockchain.BSCTestnet -> "BEP20"
-        Blockchain.Binance, Blockchain.BinanceTestnet -> "BEP2"
-        Blockchain.Tron, Blockchain.TronTestnet -> "TRC20"
-        Blockchain.TON -> "TON"
-        else -> ""
-    }
-}
-
-val Blockchain.networkNameWithoutTestnet
-    get() = this.getNetworkName().remove(" Testnet")

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

@@ -43,7 +43,7 @@ suspend fun WalletManager.safeUpdate(isDemoCard: Boolean): Result<Wallet> = try
         Result.Failure(TapError.NoInternetConnection)
     } else {
         val blockchain = wallet.blockchain
-        val amountToCreateAccount = blockchain.amountToCreateAccount(wallet.getFirstToken())
+        val amountToCreateAccount = blockchain.amountToCreateAccount(this, wallet.getFirstToken())
 
         if (exception is BlockchainSdkError.AccountNotFound && amountToCreateAccount != null) {
             Result.Failure(TapError.WalletManager.NoAccountError(amountToCreateAccount.toString()))

app/src/main/java/com/tangem/tap/common/pushes/TangemPushNotificationService.kt

@@ -18,6 +18,7 @@ import com.google.firebase.messaging.RemoteMessage
 import com.tangem.domain.common.LogConfig
 import com.tangem.tap.MainActivity
 import com.tangem.tap.common.images.createCoilImageLoader
+import com.tangem.tap.features.intentHandler.handlers.OnPushClickedIntentHandler
 import com.tangem.wallet.R
 import timber.log.Timber
 
@@ -37,6 +38,7 @@ internal class TangemPushNotificationService : FirebaseMessagingService() {
 
         // TODO refactoring: [REDACTED_JIRA]
         val intent = Intent(applicationContext, MainActivity::class.java)
+        intent.putExtra(OnPushClickedIntentHandler.IS_OPENED_FROM_PUSH, true)
         intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
         val pendingIntent = PendingIntent.getActivity(
             /* context = */ this,

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

@@ -64,12 +64,16 @@ private fun handleAction(action: Action, appState: () -> AppState?) {
                 }
                 val cardProvider: () -> CardDTO? = { scanResponseProvider.invoke()?.card }
 
+                val buyService = makeBuyExchangeService(config)
+                val sellService = makeSellExchangeService(config)
                 val exchangeManager = CurrencyExchangeManager(
-                    buyService = makeBuyExchangeService(config),
-                    sellService = makeSellExchangeService(config),
+                    buyService = buyService,
+                    sellService = sellService,
                     primaryRules = CardExchangeRules(cardProvider),
                 )
                 // TODO: for refactoring (after remove old design refactor CurrencyExchangeManager and use 1 instance)
+                store.inject(DaggerGraphState::appStateHolder).buyService = buyService
+                store.inject(DaggerGraphState::appStateHolder).sellService = sellService
                 store.inject(DaggerGraphState::appStateHolder).exchangeService = exchangeManager
                 store.dispatchOnMain(GlobalAction.ExchangeManager.Init.Success(exchangeManager))
                 store.dispatchOnMain(GlobalAction.ExchangeManager.Update)

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

@@ -1,15 +1,23 @@
 package com.tangem.tap.di
 
+import com.tangem.blockchainsdk.utils.ExcludedBlockchains
+import com.tangem.datasource.exchangeservice.swap.ExpressServiceLoader
+import com.tangem.datasource.local.token.ExpressAssetsStore
 import com.tangem.domain.card.ScanCardUseCase
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.exchange.RampStateManager
+import com.tangem.domain.tokens.GetNetworkCoinStatusUseCase
 import com.tangem.domain.tokens.GetPolkadotCheckHasImmortalUseCase
 import com.tangem.domain.tokens.GetPolkadotCheckHasResetUseCase
+import com.tangem.domain.tokens.repository.CurrenciesRepository
 import com.tangem.domain.tokens.repository.PolkadotAccountHealthCheckRepository
+import com.tangem.features.onramp.OnrampFeatureToggles
 import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.tap.domain.scanCard.repository.DefaultScanCardRepository
 import com.tangem.tap.network.exchangeServices.DefaultRampManager
 import com.tangem.tap.proxy.AppStateHolder
+import com.tangem.utils.Provider
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -39,8 +47,28 @@ internal object ActivityModule {
 
     @Provides
     @Singleton
-    fun provideDefaultRampManager(appStateHolder: AppStateHolder): RampStateManager {
-        return DefaultRampManager(appStateHolder.exchangeService)
+    fun provideDefaultRampManager(
+        appStateHolder: AppStateHolder,
+        expressServiceLoader: ExpressServiceLoader,
+        currenciesRepository: CurrenciesRepository,
+        getNetworkCoinStatusUseCase: GetNetworkCoinStatusUseCase,
+        excludedBlockchains: ExcludedBlockchains,
+        dispatchers: CoroutineDispatcherProvider,
+        onrampFeatureToggles: OnrampFeatureToggles,
+        expressAssetsStore: ExpressAssetsStore,
+    ): RampStateManager {
+        return DefaultRampManager(
+            exchangeService = appStateHolder.exchangeService,
+            buyService = Provider { requireNotNull(appStateHolder.buyService) },
+            sellService = Provider { requireNotNull(appStateHolder.sellService) },
+            expressServiceLoader = expressServiceLoader,
+            currenciesRepository = currenciesRepository,
+            getNetworkCoinStatusUseCase = getNetworkCoinStatusUseCase,
+            excludedBlockchains = excludedBlockchains,
+            dispatchers = dispatchers,
+            onrampFeatureToggles = onrampFeatureToggles,
+            expressAssetsStore = expressAssetsStore,
+        )
     }
 
     @Provides

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

@@ -0,0 +1,17 @@
+package com.tangem.tap.di
+
+import com.tangem.sdk.api.BackupServiceHolder
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object TangemSdkModule {
+
+    @Provides
+    @Singleton
+    fun provideBackupServiceHolder(): BackupServiceHolder = BackupServiceHolder()
+}

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

@@ -1,5 +1,6 @@
 package com.tangem.tap.di.data
 
+import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.domain.card.repository.DerivationsRepository
 import com.tangem.sdk.api.TangemSdkManager
@@ -20,8 +21,9 @@ internal object CardDataModule {
     fun providesDerivationsRepository(
         tangemSdkManager: TangemSdkManager,
         userWalletsStore: UserWalletsStore,
+        excludedBlockchains: ExcludedBlockchains,
         dispatchers: CoroutineDispatcherProvider,
     ): DerivationsRepository {
-        return DefaultDerivationsRepository(tangemSdkManager, userWalletsStore, dispatchers)
+        return DefaultDerivationsRepository(tangemSdkManager, userWalletsStore, excludedBlockchains, dispatchers)
     }
 }

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

@@ -1,6 +1,6 @@
 package com.tangem.tap.di.domain
 
-import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
+import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 import com.tangem.domain.card.ScanCardProcessor
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.usecase.GenerateWalletNameUseCase

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

@@ -0,0 +1,232 @@
+package com.tangem.tap.di.domain
+
+import com.tangem.domain.onramp.*
+import com.tangem.domain.onramp.repositories.OnrampErrorResolver
+import com.tangem.domain.onramp.repositories.OnrampRepository
+import com.tangem.domain.onramp.repositories.OnrampTransactionRepository
+import com.tangem.domain.settings.repositories.SettingsRepository
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Suppress("TooManyFunctions")
+@Module
+@InstallIn(SingletonComponent::class)
+internal object OnrampDomainModule {
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampCurrenciesUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampCurrenciesUseCase {
+        return GetOnrampCurrenciesUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideOnrampSaveDefaultCurrencyUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): OnrampSaveDefaultCurrencyUseCase {
+        return OnrampSaveDefaultCurrencyUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampCountriesUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampCountriesUseCase {
+        return GetOnrampCountriesUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampCountryUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampCountryUseCase {
+        return GetOnrampCountryUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideOnrampSaveDefaultCountryUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): OnrampSaveDefaultCountryUseCase {
+        return OnrampSaveDefaultCountryUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideCheckOnrampAvailabilityUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): CheckOnrampAvailabilityUseCase {
+        return CheckOnrampAvailabilityUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampStatusUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampStatusUseCase {
+        return GetOnrampStatusUseCase(
+            onrampRepository,
+            onrampErrorResolver,
+        )
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampTransactionsUseCase(
+        onrampTransactionRepository: OnrampTransactionRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampTransactionsUseCase {
+        return GetOnrampTransactionsUseCase(onrampTransactionRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampTransactionUseCase(
+        onrampTransactionRepository: OnrampTransactionRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampTransactionUseCase {
+        return GetOnrampTransactionUseCase(onrampTransactionRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideOnrampRemoveTransactionUseCase(
+        onrampTransactionRepository: OnrampTransactionRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): OnrampRemoveTransactionUseCase {
+        return OnrampRemoveTransactionUseCase(onrampTransactionRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideOnrampSaveTransactionUseCase(
+        onrampTransactionRepository: OnrampTransactionRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): OnrampSaveTransactionUseCase {
+        return OnrampSaveTransactionUseCase(onrampTransactionRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideOnrampUpdateTransactionStatusUseCase(
+        onrampTransactionRepository: OnrampTransactionRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): OnrampUpdateTransactionStatusUseCase {
+        return OnrampUpdateTransactionStatusUseCase(onrampTransactionRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampPaymentMethodsUseCase(
+        onrampRepository: OnrampRepository,
+        settingsRepository: SettingsRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampPaymentMethodsUseCase {
+        return GetOnrampPaymentMethodsUseCase(onrampRepository, settingsRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideClearOnrampCacheUseCase(onrampRepository: OnrampRepository): ClearOnrampCacheUseCase {
+        return ClearOnrampCacheUseCase(onrampRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideOnrampFetchQuotesUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): OnrampFetchQuotesUseCase {
+        return OnrampFetchQuotesUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampQuotesUseCase(
+        settingsRepository: SettingsRepository,
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampQuotesUseCase {
+        return GetOnrampQuotesUseCase(
+            settingsRepository = settingsRepository,
+            repository = onrampRepository,
+            errorResolver = onrampErrorResolver,
+        )
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampSelectedPaymentMethodUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampSelectedPaymentMethodUseCase {
+        return GetOnrampSelectedPaymentMethodUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampProviderWithQuoteUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampProviderWithQuoteUseCase {
+        return GetOnrampProviderWithQuoteUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideOnrampSaveSelectedPaymentMethod(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): OnrampSaveSelectedPaymentMethod {
+        return OnrampSaveSelectedPaymentMethod(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideOnrampFetchPairsUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): OnrampFetchPairsUseCase {
+        return OnrampFetchPairsUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampRedirectUrlUseCase(
+        onrampRepository: OnrampRepository,
+        transactionRepository: OnrampTransactionRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): GetOnrampRedirectUrlUseCase {
+        return GetOnrampRedirectUrlUseCase(onrampRepository, transactionRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideFetchOnrampCurrenciesUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): FetchOnrampCurrenciesUseCase {
+        return FetchOnrampCurrenciesUseCase(onrampRepository, onrampErrorResolver)
+    }
+
+    @Provides
+    @Singleton
+    fun provideFetchOnrampCountriesUseCase(
+        onrampRepository: OnrampRepository,
+        onrampErrorResolver: OnrampErrorResolver,
+    ): FetchOnrampCountriesUseCase {
+        return FetchOnrampCountriesUseCase(onrampRepository, onrampErrorResolver)
+    }
+}

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

@@ -133,14 +133,6 @@ internal object SettingsDomainModule {
         return ShouldShowRingPromoUseCase(promoSettingsRepository)
     }
 
-    @Provides
-    @Singleton
-    fun provideShouldShowTravalaPromoWalletUseCase(
-        promoSettingsRepository: PromoSettingsRepository,
-    ): ShouldShowTravalaPromoWalletUseCase {
-        return ShouldShowTravalaPromoWalletUseCase(promoSettingsRepository)
-    }
-
     @Provides
     @Singleton
     fun provideShouldShowSwapPromoTokenUseCase(
@@ -234,4 +226,36 @@ internal object SettingsDomainModule {
     fun provideGetUserCountryCodeUseCase(settingsRepository: SettingsRepository): GetUserCountryUseCase {
         return GetUserCountryUseCase(settingsRepository)
     }
+
+    // region Google services availability
+    @Provides
+    @Singleton
+    fun provideSetGoogleServicesAvailabilityUseCase(
+        settingsRepository: SettingsRepository,
+    ): SetGoogleServicesAvailabilityUseCase {
+        return SetGoogleServicesAvailabilityUseCase(settingsRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideIsGoogleServicesAvailableUseCase(
+        settingsRepository: SettingsRepository,
+    ): IsGoogleServicesAvailableUseCase {
+        return IsGoogleServicesAvailableUseCase(settingsRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideSetGooglePayAvailabilityUseCase(
+        settingsRepository: SettingsRepository,
+    ): SetGooglePayAvailabilityUseCase {
+        return SetGooglePayAvailabilityUseCase(settingsRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideIsGooglePayAvailableUseCase(settingsRepository: SettingsRepository): IsGooglePayAvailableUseCase {
+        return IsGooglePayAvailableUseCase(settingsRepository)
+    }
+    // endregion
 }

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

@@ -0,0 +1,23 @@
+package com.tangem.tap.di.domain
+
+import com.tangem.feature.swap.domain.GetAvailablePairsUseCase
+import com.tangem.feature.swap.domain.api.SwapRepository
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+/**
+[REDACTED_AUTHOR]
+ */
+@Module
+@InstallIn(SingletonComponent::class)
+internal object SwapDomainModule {
+
+    @Provides
+    @Singleton
+    fun provideGetAvailablePairsUseCase(swapRepository: SwapRepository): GetAvailablePairsUseCase {
+        return GetAvailablePairsUseCase(swapRepository = swapRepository)
+    }
+}

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

@@ -7,7 +7,6 @@ import com.tangem.domain.tokens.*
 import com.tangem.domain.tokens.repository.*
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.feature.swap.domain.api.SwapRepository
-import com.tangem.features.staking.api.featuretoggles.StakingFeatureToggles
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import dagger.Module
 import dagger.Provides
@@ -119,26 +118,26 @@ internal object TokensDomainModule {
         currenciesRepository: CurrenciesRepository,
         quotesRepository: QuotesRepository,
         networksRepository: NetworksRepository,
-        marketCryptoCurrencyRepository: MarketCryptoCurrencyRepository,
         swapRepository: SwapRepository,
         currencyChecksRepository: CurrencyChecksRepository,
         showSwapPromoTokenUseCase: ShouldShowSwapPromoTokenUseCase,
         promoRepository: PromoRepository,
         stakingRepository: StakingRepository,
         dispatchers: CoroutineDispatcherProvider,
+        rampStateManager: RampStateManager,
     ): GetCurrencyWarningsUseCase {
         return GetCurrencyWarningsUseCase(
             walletManagersFacade = walletManagersFacade,
             currenciesRepository = currenciesRepository,
             quotesRepository = quotesRepository,
             networksRepository = networksRepository,
-            marketCryptoCurrencyRepository = marketCryptoCurrencyRepository,
             currencyChecksRepository = currencyChecksRepository,
             swapRepository = swapRepository,
             showSwapPromoTokenUseCase = showSwapPromoTokenUseCase,
             promoRepository = promoRepository,
             stakingRepository = stakingRepository,
             dispatchers = dispatchers,
+            rampStateManager = rampStateManager,
         )
     }
 
@@ -216,23 +215,19 @@ internal object TokensDomainModule {
     fun provideGetCryptoCurrencyActionsUseCase(
         rampStateManager: RampStateManager,
         walletManagersFacade: WalletManagersFacade,
-        marketCryptoCurrencyRepository: MarketCryptoCurrencyRepository,
         currenciesRepository: CurrenciesRepository,
         quotesRepository: QuotesRepository,
         networksRepository: NetworksRepository,
         stakingRepository: StakingRepository,
-        stakingFeatureToggles: StakingFeatureToggles,
         dispatchers: CoroutineDispatcherProvider,
     ): GetCryptoCurrencyActionsUseCase {
         return GetCryptoCurrencyActionsUseCase(
             rampManager = rampStateManager,
             walletManagersFacade = walletManagersFacade,
-            marketCryptoCurrencyRepository = marketCryptoCurrencyRepository,
             currenciesRepository = currenciesRepository,
             quotesRepository = quotesRepository,
             networksRepository = networksRepository,
             stakingRepository = stakingRepository,
-            stakingFeatureToggles = stakingFeatureToggles,
             dispatchers = dispatchers,
         )
     }

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

@@ -58,6 +58,28 @@ internal object TransactionDomainModule {
         )
     }
 
+    @Provides
+    @Singleton
+    fun provideRetryTransactionUseCase(
+        cardSdkConfigRepository: CardSdkConfigRepository,
+        walletManagersFacade: WalletManagersFacade,
+    ): RetryIncompleteTransactionUseCase {
+        return RetryIncompleteTransactionUseCase(
+            cardSdkConfigRepository = cardSdkConfigRepository,
+            walletManagersFacade = walletManagersFacade,
+        )
+    }
+
+    @Provides
+    @Singleton
+    fun provideDismissIncompleteTransactionUseCase(
+        walletManagersFacade: WalletManagersFacade,
+    ): DismissIncompleteTransactionUseCase {
+        return DismissIncompleteTransactionUseCase(
+            walletManagersFacade = walletManagersFacade,
+        )
+    }
+
     @Provides
     @Singleton
     fun provideCreateTransactionUseCase(transactionRepository: TransactionRepository): CreateTransactionUseCase {

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

@@ -1,6 +1,7 @@
 package com.tangem.tap.domain.card
 
 import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.blockchainsdk.utils.fromNetworkId
 import com.tangem.common.CompletionResult
 import com.tangem.common.card.EllipticCurve
@@ -32,6 +33,7 @@ private typealias DerivedKeys = Map<ByteArrayKey, ExtendedPublicKeysMap>
 internal class DefaultDerivationsRepository(
     private val tangemSdkManager: TangemSdkManager,
     private val userWalletsStore: UserWalletsStore,
+    private val excludedBlockchains: ExcludedBlockchains,
     private val dispatchers: CoroutineDispatcherProvider,
 ) : DerivationsRepository {
 
@@ -49,6 +51,7 @@ internal class DefaultDerivationsRepository(
                     blockchain = Blockchain.fromNetworkId(it.value) ?: return@mapNotNull null,
                     extraDerivationPath = null,
                     scanResponse = userWallet.scanResponse,
+                    excludedBlockchains = excludedBlockchains,
                 )
             },
         )
@@ -85,6 +88,7 @@ internal class DefaultDerivationsRepository(
                         blockchain = Blockchain.fromNetworkId(backendId) ?: return@mapNotNull null,
                         extraDerivationPath = extraDerivationPath,
                         scanResponse = userWallet.scanResponse,
+                        excludedBlockchains = excludedBlockchains,
                     )
                 },
             )

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

@@ -1,6 +1,6 @@
 package com.tangem.tap.domain.scanCard
 
-import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
+import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 
 /**
  * Add custom token feature toggles

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

@@ -7,6 +7,7 @@ import com.tangem.common.authentication.storage.AuthenticatedStorage
 import com.tangem.common.json.TangemSdkAdapter
 import com.tangem.common.services.secure.SecureStorage
 import com.tangem.datasource.local.preferences.AppPreferencesStore
+import com.tangem.domain.models.scan.serialization.*
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.sdk.storage.AndroidSecureStorage
 import com.tangem.sdk.storage.createEncryptedSharedPreferences
@@ -19,7 +20,6 @@ import com.tangem.tap.domain.userWalletList.repository.implementation.BiometricU
 import com.tangem.tap.domain.userWalletList.repository.implementation.DefaultSelectedUserWalletRepository
 import com.tangem.tap.domain.userWalletList.repository.implementation.DefaultUserWalletsPublicInformationRepository
 import com.tangem.tap.domain.userWalletList.repository.implementation.DefaultUserWalletsSensitiveInformationRepository
-import com.tangem.tap.domain.userWalletList.utils.json.*
 import com.tangem.tap.tangemSdkManager
 import com.tangem.utils.Provider
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider

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

@@ -1 +0,0 @@
-package com.tangem.tap.domain.userWalletList.utils

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

@@ -2,6 +2,11 @@ package com.tangem.tap.domain.walletconnect2.data
 
 import android.app.Application
 import arrow.core.flatten
+import com.reown.android.Core
+import com.reown.android.CoreClient
+import com.reown.android.relay.ConnectionType
+import com.reown.walletkit.client.Wallet
+import com.reown.walletkit.client.WalletKit
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.tap.common.analytics.events.WalletConnect
 import com.tangem.tap.domain.walletconnect2.domain.LegacyWalletConnectRepository
@@ -9,11 +14,6 @@ import com.tangem.tap.domain.walletconnect2.domain.WcJrpcMethods
 import com.tangem.tap.domain.walletconnect2.domain.WcJrpcRequestsDeserializer
 import com.tangem.tap.domain.walletconnect2.domain.WcRequest
 import com.tangem.tap.domain.walletconnect2.domain.models.*
-import com.walletconnect.android.Core
-import com.walletconnect.android.CoreClient
-import com.walletconnect.android.relay.ConnectionType
-import com.walletconnect.web3.wallet.client.Wallet
-import com.walletconnect.web3.wallet.client.Web3Wallet
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -72,7 +72,7 @@ internal class DefaultLegacyWalletConnectRepository(
             }
         }
 
-        Web3Wallet.initialize(Wallet.Params.Init(core = CoreClient)) { error ->
+        WalletKit.initialize(Wallet.Params.Init(core = CoreClient)) { error ->
             Timber.e("Error while initializing Web3Wallet: $error")
             scope.launch {
                 _events.emit(
@@ -84,11 +84,11 @@ internal class DefaultLegacyWalletConnectRepository(
         }
 
         val walletDelegate = defineWalletDelegate()
-        Web3Wallet.setWalletDelegate(walletDelegate)
+        WalletKit.setWalletDelegate(walletDelegate)
     }
 
-    private fun defineWalletDelegate(): Web3Wallet.WalletDelegate {
-        return object : Web3Wallet.WalletDelegate {
+    private fun defineWalletDelegate(): WalletKit.WalletDelegate {
+        return object : WalletKit.WalletDelegate {
             override fun onSessionProposal(
                 sessionProposal: Wallet.Model.SessionProposal,
                 verifyContext: Wallet.Model.VerifyContext,
@@ -188,14 +188,6 @@ internal class DefaultLegacyWalletConnectRepository(
                 }
             }
 
-            override fun onAuthRequest(
-                authRequest: Wallet.Model.AuthRequest,
-                verifyContext: Wallet.Model.VerifyContext,
-            ) {
-                // Triggered when Dapp / Requester makes an authorization request
-                Timber.i("onAuthRequest: $authRequest")
-            }
-
             override fun onSessionDelete(sessionDelete: Wallet.Model.SessionDelete) {
                 // Triggered when the session is deleted by the peer
                 if (sessionDelete is Wallet.Model.SessionDelete.Success) {
@@ -251,7 +243,7 @@ internal class DefaultLegacyWalletConnectRepository(
     }
 
     override fun pair(uri: String) {
-        Web3Wallet.pair(
+        WalletKit.pair(
             params = Wallet.Params.Pair(uri),
             onSuccess = {
                 Timber.i("Paired successfully: $it")
@@ -267,7 +259,7 @@ internal class DefaultLegacyWalletConnectRepository(
         )
     }
 
-    override fun approve(userNamespaces: Map<NetworkNamespace, List<Account>>) {
+    override fun approve(userNamespaces: Map<NetworkNamespace, List<Account>>, blockchainNames: List<String>) {
         val sessionProposal: Wallet.Model.SessionProposal = requireNotNull(this.sessionProposal)
 
         val userChains = userNamespaces.flatMap { namespace ->
@@ -303,7 +295,7 @@ internal class DefaultLegacyWalletConnectRepository(
 
         Timber.i("Session approval is prepared for sending: $sessionApproval")
 
-        Web3Wallet.approveSession(
+        WalletKit.approveSession(
             params = sessionApproval,
             onSuccess = {
                 Timber.i("Approved successfully: $it")
@@ -311,6 +303,7 @@ internal class DefaultLegacyWalletConnectRepository(
                     WalletConnect.NewSessionEstablished(
                         dAppName = sessionProposal.name,
                         dAppUrl = sessionProposal.url,
+                        blockchainNames = blockchainNames,
                     ),
                 )
             },
@@ -363,7 +356,7 @@ internal class DefaultLegacyWalletConnectRepository(
             )
         }
 
-        Web3Wallet.respondSessionRequest(
+        WalletKit.respondSessionRequest(
             params = Wallet.Params.SessionRequestResponse(
                 sessionTopic = requestData.topic,
                 jsonRpcResponse = Wallet.Model.JsonRpcResponse.JsonRpcResult(
@@ -408,7 +401,7 @@ internal class DefaultLegacyWalletConnectRepository(
     }
 
     override fun cancelRequest(topic: String, id: Long, message: String) {
-        Web3Wallet.respondSessionRequest(
+        WalletKit.respondSessionRequest(
             params = Wallet.Params.SessionRequestResponse(
                 sessionTopic = topic,
                 jsonRpcResponse = Wallet.Model.JsonRpcResponse.JsonRpcError(
@@ -423,7 +416,7 @@ internal class DefaultLegacyWalletConnectRepository(
     }
 
     override fun reject() {
-        Web3Wallet.rejectSession(
+        WalletKit.rejectSession(
             params = Wallet.Params.SessionReject(
                 proposerPublicKey = sessionProposal?.proposerPublicKey ?: "",
                 reason = "",
@@ -439,7 +432,7 @@ internal class DefaultLegacyWalletConnectRepository(
 
     override fun disconnect(topic: String) {
         val session = currentSessions.find { it.topic == topic }
-        Web3Wallet.disconnectSession(
+        WalletKit.disconnectSession(
             params = Wallet.Params.SessionDisconnect(topic),
             onSuccess = {
                 analyticsHandler.send(
@@ -458,7 +451,7 @@ internal class DefaultLegacyWalletConnectRepository(
     }
 
     fun send(topic: String, id: Long, data: String) {
-        Web3Wallet.respondSessionRequest(
+        WalletKit.respondSessionRequest(
             params = Wallet.Params.SessionRequestResponse(
                 sessionTopic = topic,
                 jsonRpcResponse = Wallet.Model.JsonRpcResponse.JsonRpcResult(
@@ -476,7 +469,7 @@ internal class DefaultLegacyWalletConnectRepository(
     }
 
     private fun updateSessionsInternal(): Job = scope.launch {
-        val availableSessions = Web3Wallet.getListOfActiveSessions()
+        val availableSessions = WalletKit.getListOfActiveSessions()
             .map {
                 WalletConnectSession(
                     topic = it.topic,

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

@@ -3,7 +3,7 @@ package com.tangem.tap.domain.walletconnect2.di
 import android.app.Application
 import com.squareup.moshi.Moshi
 import com.tangem.core.analytics.api.AnalyticsEventHandler
-import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
+import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 import com.tangem.datasource.di.SdkMoshi
 import com.tangem.datasource.files.FileReader
 import com.tangem.domain.tokens.repository.CurrenciesRepository

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

@@ -21,7 +21,7 @@ interface LegacyWalletConnectRepository {
 
     fun disconnect(topic: String)
 
-    fun approve(userNamespaces: Map<NetworkNamespace, List<Account>>)
+    fun approve(userNamespaces: Map<NetworkNamespace, List<Account>>, blockchainNames: List<String>)
 
     fun reject()
 

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

@@ -1,5 +1,6 @@
 package com.tangem.tap.domain.walletconnect2.domain
 
+import arrow.core.flatten
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchainsdk.utils.toNetworkId
 import com.tangem.domain.tokens.model.CryptoCurrency
@@ -236,8 +237,12 @@ class WalletConnectInteractor(
                 blockchainHelper.getNamespaceFromFullChainIdOrNull(account.chainId)
                     ?.let { NetworkNamespace(it) }
             }.filterNotNull()
+
+        val blockchainNames = blockchainHelper.chainIdsToBlockchains(userNamespaces.values.flatten().map { it.chainId })
+            .map { it.fullName }
         walletConnectRepository.approve(
             userNamespaces = userNamespaces,
+            blockchainNames = blockchainNames,
         )
     }
 

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

@@ -1,6 +1,6 @@
 package com.tangem.tap.domain.walletconnect2.toggles
 
-import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
+import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 
 internal class WalletConnectFeatureToggles(
     private val featureTogglesManager: FeatureTogglesManager,

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

@@ -37,5 +37,7 @@ sealed class WalletConnectAction : Action {
     data class PerformRequestedAction(val sessionRequest: WcPreparedRequest) : WalletConnectAction()
 
     data class PairConnectErrorAction(val throwable: Throwable) : WalletConnectAction()
+
+    data object UnsupportedDappRequest : WalletConnectAction()
     //endregion WalletConnect 2.0
 }

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

@@ -78,6 +78,12 @@ class WalletConnectMiddleware {
                 val index = action.wcUri.indexOf("@")
                 when (action.wcUri[index + 1]) {
                     '2' -> walletConnectRepository.pair(uri = action.wcUri)
+                    '1' -> {
+                        store.dispatchOnMain(WalletConnectAction.UnsupportedDappRequest)
+                        store.dispatchOnMain(
+                            GlobalAction.ShowDialog(WalletConnectDialog.UnsupportedWcVersion),
+                        )
+                    }
                 }
             }
             is WalletConnectAction.RejectRequest -> {

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

@@ -15,6 +15,7 @@ object WalletConnectReducer {
             is WalletConnectAction.SessionEstablished,
             is WalletConnectAction.SessionRejected,
             is WalletConnectAction.PairConnectErrorAction,
+            is WalletConnectAction.UnsupportedDappRequest,
             -> state.copy(loading = false)
             is WalletConnectAction.SessionListUpdated -> state.copy(
                 wc2Sessions = action.sessions,

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

@@ -82,6 +82,7 @@ data class WalletForSession(
 }
 
 sealed class WalletConnectDialog : StateDialog {
+    data object UnsupportedWcVersion : WalletConnectDialog()
     data class ClipboardOrScanQr(val clipboardUri: String) : WalletConnectDialog()
     data object UnsupportedCard : WalletConnectDialog()
     data class UnsupportedNetwork(val networks: List<String>? = null) : WalletConnectDialog()

app/src/main/java/com/tangem/tap/features/home/featuretoggles/HomeFeatureToggles.kt

@@ -1,6 +1,6 @@
 package com.tangem.tap.features.home.featuretoggles
 
-import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
+import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 import javax.inject.Inject
 
 class HomeFeatureToggles @Inject constructor(

app/src/main/java/com/tangem/tap/features/intentHandler/handlers/OnPushClickedIntentHandler.kt

@@ -0,0 +1,24 @@
+package com.tangem.tap.features.intentHandler.handlers
+
+import android.content.Intent
+import com.tangem.core.analytics.api.AnalyticsEventHandler
+import com.tangem.tap.common.analytics.events.Push
+import com.tangem.tap.features.intentHandler.IntentHandler
+
+internal class OnPushClickedIntentHandler(val analyticsEventHandler: AnalyticsEventHandler) : IntentHandler {
+
+    override fun handleIntent(intent: Intent?, isFromForeground: Boolean): Boolean {
+        val fromPush = intent?.extras?.getBoolean(IS_OPENED_FROM_PUSH) ?: false
+
+        return if (fromPush) {
+            analyticsEventHandler.send(Push.PushNotificationOpened)
+            true
+        } else {
+            false
+        }
+    }
+
+    companion object {
+        const val IS_OPENED_FROM_PUSH = "IS_OPENED_FROM_PUSH"
+    }
+}

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

@@ -17,7 +17,6 @@ import com.tangem.domain.settings.IncrementAppLaunchCounterUseCase
 import com.tangem.domain.settings.usercountry.FetchUserCountryUseCase
 import com.tangem.domain.staking.FetchStakingTokensUseCase
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
-import com.tangem.features.staking.api.featuretoggles.StakingFeatureToggles
 import com.tangem.tap.common.extensions.setContext
 import com.tangem.tap.features.home.featuretoggles.HomeFeatureToggles
 import com.tangem.tap.features.main.model.MainScreenState
@@ -40,7 +39,6 @@ internal class MainViewModel @Inject constructor(
     private val blockchainSDKFactory: BlockchainSDKFactory,
     private val userWalletsListManager: UserWalletsListManager,
     private val dispatchers: CoroutineDispatcherProvider,
-    stakingFeatureToggles: StakingFeatureToggles,
     private val fetchStakingTokensUseCase: FetchStakingTokensUseCase,
     private val apiConfigsManager: ApiConfigsManager,
     homeFeatureToggles: HomeFeatureToggles,
@@ -78,9 +76,7 @@ internal class MainViewModel @Inject constructor(
         displayBalancesHidingStatusToast()
         displayHiddenBalancesModalNotification()
 
-        if (stakingFeatureToggles.isStakingEnabled) {
-            fetchStakingTokens()
-        }
+        fetchStakingTokens()
 
         deleteDeprecatedLogsUseCase()
     }
@@ -216,7 +212,6 @@ internal class MainViewModel @Inject constructor(
 
     override fun onDismissBottomSheet() {
         listenToFlipsUseCase.changeUpdateEnabled(true)
-        router.pop()
         stateHolder.updateWithoutModalNotification()
         stateHolder.updateWithHiddenBalancesToast(true)
     }

app/src/main/java/com/tangem/tap/features/onboarding/OnboardingHelper.kt

@@ -16,6 +16,7 @@ import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.settings.usercountry.models.UserCountry
 import com.tangem.domain.wallets.builder.UserWalletBuilder
 import com.tangem.domain.wallets.builder.UserWalletIdBuilder
+import com.tangem.domain.wallets.models.UserWallet
 import com.tangem.tap.common.analytics.converters.ParamCardCurrencyConverter
 import com.tangem.tap.common.analytics.events.AnalyticsParam
 import com.tangem.tap.common.analytics.events.Onboarding
@@ -23,8 +24,9 @@ import com.tangem.tap.common.extensions.*
 import com.tangem.tap.common.redux.AppDialog
 import com.tangem.tap.common.redux.global.GlobalState
 import com.tangem.tap.features.demo.DemoHelper
-import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletAction
 import com.tangem.tap.features.home.RUSSIA_COUNTRY_CODE
+import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletAction
+import com.tangem.tap.features.onboarding.products.wallet.redux.BackupStartedSource
 import com.tangem.tap.features.saveWallet.redux.SaveWalletAction
 import com.tangem.tap.mainScope
 import com.tangem.tap.proxy.redux.DaggerGraphState
@@ -66,8 +68,22 @@ object OnboardingHelper {
     }
 
     fun whereToNavigate(scanResponse: ScanResponse): AppRoute {
-        if (store.inject(DaggerGraphState::onboardingV2FeatureToggles).isOnboardingV2Enabled) {
-            return AppRoute.Onboarding(scanResponse)
+        val newOnboardingSupportTypes = scanResponse.productType == ProductType.Wallet2 ||
+            scanResponse.productType == ProductType.Ring ||
+            scanResponse.productType == ProductType.Wallet
+        if (store.inject(DaggerGraphState::onboardingV2FeatureToggles).isOnboardingV2Enabled &&
+            newOnboardingSupportTypes
+        ) {
+            val backupState = store.state.onboardingWalletState.backupState
+
+            return AppRoute.Onboarding(
+                scanResponse = scanResponse,
+                startFromBackup = false,
+                mode = when (backupState.startedSource) {
+                    BackupStartedSource.Onboarding -> AppRoute.Onboarding.Mode.Onboarding
+                    BackupStartedSource.CreateBackup -> AppRoute.Onboarding.Mode.AddBackup
+                },
+            )
         }
 
         return when (val type = scanResponse.productType) {
@@ -88,6 +104,7 @@ object OnboardingHelper {
     }
 
     fun saveWallet(
+        alreadyCreatedWallet: UserWallet?,
         scanResponse: ScanResponse,
         accessCode: String? = null,
         backupCardsIds: List<String>? = null,
@@ -117,7 +134,7 @@ object OnboardingHelper {
                 // When should not save user wallets but device has biometry and save wallet screen has not been shown,
                 // then open save wallet screen
                 tangemSdkManager.checkCanUseBiometry() && settingsRepository.shouldShowSaveUserWalletScreen() -> {
-                    proceedWithScanResponse(scanResponse, backupCardsIds, hasBackupError)
+                    proceedWithScanResponse(scanResponse, backupCardsIds, hasBackupError, alreadyCreatedWallet)
 
                     delay(timeMillis = 1_200)
 
@@ -131,7 +148,7 @@ object OnboardingHelper {
                 }
                 // If device has no biometry and save wallet screen has been shown, then go through old scenario
                 else -> {
-                    proceedWithScanResponse(scanResponse, backupCardsIds, hasBackupError)
+                    proceedWithScanResponse(scanResponse, backupCardsIds, hasBackupError, alreadyCreatedWallet)
                 }
             }
         }
@@ -207,7 +224,9 @@ object OnboardingHelper {
 
     fun handleTopUpAction(walletManager: WalletManager, scanResponse: ScanResponse, globalState: GlobalState) {
         val blockchain = walletManager.wallet.blockchain
-        val cryptoCurrency = CryptoCurrencyFactory().createCoin(
+        val excludedBlockchains = store.inject(DaggerGraphState::excludedBlockchains)
+
+        val cryptoCurrency = CryptoCurrencyFactory(excludedBlockchains).createCoin(
             blockchain = blockchain,
             extraDerivationPath = null,
             scanResponse = scanResponse,
@@ -220,6 +239,7 @@ object OnboardingHelper {
 
         scope.launch {
             val homeFeatureToggles = store.inject(DaggerGraphState::homeFeatureToggles)
+            val onrampFeatureToggles = store.inject(DaggerGraphState::onrampFeatureToggles)
 
             val isRussia = if (homeFeatureToggles.isMigrateUserCountryCodeEnabled) {
                 val getUserCountryCodeUseCase = store.inject(DaggerGraphState::getUserCountryUseCase)
@@ -229,7 +249,7 @@ object OnboardingHelper {
                 globalState.userCountryCode == RUSSIA_COUNTRY_CODE
             }
 
-            if (isRussia) {
+            if (isRussia && !onrampFeatureToggles.isFeatureEnabled) {
                 val dialogData = AppDialog.RussianCardholdersWarningDialog.Data(topUpUrl)
                 store.dispatchDialogShow(AppDialog.RussianCardholdersWarningDialog(dialogData))
             } else {
@@ -242,9 +262,10 @@ object OnboardingHelper {
         scanResponse: ScanResponse,
         backupCardsIds: List<String>?,
         hasBackupError: Boolean,
+        alreadyCreatedWallet: UserWallet? = null,
     ) {
         val walletNameGenerateUseCase = store.inject(DaggerGraphState::generateWalletNameUseCase)
-        val userWallet = UserWalletBuilder(scanResponse, walletNameGenerateUseCase)
+        val userWallet = alreadyCreatedWallet ?: UserWalletBuilder(scanResponse, walletNameGenerateUseCase)
             .hasBackupError(hasBackupError)
             .backupCardsIds(backupCardsIds?.toSet())
             .build()

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletAction.kt

@@ -3,6 +3,7 @@ package com.tangem.tap.features.onboarding.products.wallet.redux
 import android.net.Uri
 import com.tangem.common.CompletionResult
 import com.tangem.common.card.Card
+import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.feature.onboarding.data.model.CreateWalletResponse
 import com.tangem.feature.onboarding.presentation.wallet2.analytics.SeedPhraseSource
@@ -98,7 +99,10 @@ sealed class BackupAction : Action {
 
     data object DiscardBackup : BackupAction()
     data object DiscardSavedBackup : BackupAction()
-    data object ResumeFoundUnfinishedBackup : BackupAction()
+
+    data class ResumeFoundUnfinishedBackup(
+        val unfinishedBackupScanResponse: ScanResponse?,
+    ) : BackupAction()
 
     data class ResetBackupCard(val cardId: String) : BackupAction()
 }

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletMiddleware.kt

@@ -197,11 +197,11 @@ private fun handleWalletAction(action: Action) {
     }
 }
 
-private fun handleFinishBackup(scanResponse: ScanResponse) {
+private fun handleFinishBackup(scanResponse: ScanResponse, userWallet: UserWallet? = null) {
     val backupState = store.state.onboardingWalletState.backupState
     val updatedScanResponse = updateScanResponseAfterBackup(scanResponse, backupState)
 
-    val userWalletId = UserWalletIdBuilder.scanResponse(scanResponse).build()
+    val userWalletId = userWallet?.walletId ?: UserWalletIdBuilder.scanResponse(scanResponse).build()
     if (backupState.hasRing && userWalletId != null) {
         scope.launch {
             store.inject(DaggerGraphState::walletsRepository).setHasWalletsWithRing(userWalletId = userWalletId)
@@ -209,6 +209,7 @@ private fun handleFinishBackup(scanResponse: ScanResponse) {
     }
 
     OnboardingHelper.saveWallet(
+        alreadyCreatedWallet = userWallet,
         scanResponse = updatedScanResponse,
         accessCode = backupState.accessCode,
         backupCardsIds = backupState.backupCardIds,
@@ -580,21 +581,50 @@ private fun handleBackupAction(appState: () -> AppState?, action: BackupAction)
                     store.state.globalState.onboardingState.onboardingManager?.finishActivation(it)
                 }
                 backupService.discardSavedBackup()
+
+                val isOnboardingV2Enabled = store.inject(DaggerGraphState::onboardingV2FeatureToggles)
+                    .isOnboardingV2Enabled
+
+                if (isOnboardingV2Enabled) {
+                    val onboardingRepository = store.inject(DaggerGraphState::onboardingRepository)
+                    onboardingRepository.clearUnfinishedFinalizeOnboarding()
+                }
             }
         }
         is BackupAction.CheckForUnfinishedBackup -> {
-            if (backupService.hasIncompletedBackup) {
-                store.dispatch(GlobalAction.ShowDialog(BackupDialog.UnfinishedBackupFound))
+            val isOnboardingV2Enabled = store.inject(DaggerGraphState::onboardingV2FeatureToggles).isOnboardingV2Enabled
+
+            if (isOnboardingV2Enabled) {
+                val onboardingRepository = store.inject(DaggerGraphState::onboardingRepository)
+
+                mainScope.launch {
+                    val onboardingScanResponse = onboardingRepository.getUnfinishedFinalizeOnboarding() ?: return@launch
+                    store.dispatch(GlobalAction.ShowDialog(BackupDialog.UnfinishedBackupFound(onboardingScanResponse)))
+                }
+            } else if (backupService.hasIncompletedBackup) {
+                store.dispatch(GlobalAction.ShowDialog(BackupDialog.UnfinishedBackupFound()))
             }
         }
         is BackupAction.ResumeFoundUnfinishedBackup -> {
-            store.dispatch(
-                GlobalAction.Onboarding.StartForUnfinishedBackup(
-                    addedBackupCardsCount = backupService.addedBackupCardsCount,
-                ),
-            )
+            if (action.unfinishedBackupScanResponse != null) {
+                // onboarding V2
+                store.dispatchNavigationAction {
+                    push(
+                        AppRoute.Onboarding(
+                            scanResponse = action.unfinishedBackupScanResponse,
+                            startFromBackup = false,
+                        ),
+                    )
+                }
+            } else {
+                store.dispatch(
+                    GlobalAction.Onboarding.StartForUnfinishedBackup(
+                        addedBackupCardsCount = backupService.addedBackupCardsCount,
+                    ),
+                )
 
-            store.dispatchNavigationAction { push(AppRoute.OnboardingWallet()) }
+                store.dispatchNavigationAction { push(AppRoute.OnboardingWallet()) }
+            }
         }
         is BackupAction.SkipBackup -> {
             Analytics.send(Onboarding.Backup.Skipped())
@@ -679,7 +709,7 @@ private fun handleBackupAction(appState: () -> AppState?, action: BackupAction)
                 Analytics.send(Onboarding.Finished())
 
                 store.state.globalState.onboardingState.onboardingManager?.finishActivation(notActivatedCardIds)
-                handleFinishBackup(requireNotNull(scanResponse))
+                handleFinishBackup(requireNotNull(scanResponse), userWallet)
                 delay(1000)
                 store.dispatchWithMain(BackupAction.BackupFinished(userWalletId = userWallet?.walletId))
             }
@@ -740,6 +770,7 @@ private suspend fun createUserWallet(scanResponse: ScanResponse, backupState: Ba
     return requireNotNull(
         value = UserWalletBuilder(scanResponse, walletNameGenerateUseCase)
             .backupCardsIds(backupState.backupCardIds.toSet())
+            .hasBackupError(backupState.hasBackupError)
             .build(),
         lazyMessage = { "User wallet not created" },
     )

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletState.kt

@@ -3,6 +3,7 @@ package com.tangem.tap.features.onboarding.products.wallet.redux
 import android.graphics.Bitmap
 import android.net.Uri
 import com.tangem.common.card.Card
+import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.redux.StateDialog
 import com.tangem.domain.wallets.models.UserWalletId
 import org.rekotlin.StateType
@@ -99,22 +100,29 @@ enum class AccessCodeError {
 typealias CardId = String
 
 sealed class BackupStep {
-    object InitBackup : BackupStep()
-    object ScanOriginCard : BackupStep()
-    object AddBackupCards : BackupStep()
-    object SetAccessCode : BackupStep()
-    object EnterAccessCode : BackupStep()
-    object ReenterAccessCode : BackupStep()
-    object WritePrimaryCard : BackupStep()
+    data object InitBackup : BackupStep()
+    data object ScanOriginCard : BackupStep()
+    data object AddBackupCards : BackupStep()
+    data object SetAccessCode : BackupStep()
+    data object EnterAccessCode : BackupStep()
+    data object ReenterAccessCode : BackupStep()
+    data object WritePrimaryCard : BackupStep()
     data class WriteBackupCard(val cardNumber: Int) : BackupStep()
-    object Finished : BackupStep()
+    data object Finished : BackupStep()
 }
 
 sealed class BackupDialog : StateDialog {
-    object AttestationFailed : BackupDialog()
-    object AddMoreBackupCards : BackupDialog()
-    object BackupInProgress : BackupDialog()
-    object UnfinishedBackupFound : BackupDialog()
-    object ConfirmDiscardingBackup : BackupDialog()
+    data object AttestationFailed : BackupDialog()
+    data object AddMoreBackupCards : BackupDialog()
+    data object BackupInProgress : BackupDialog()
+
+    data class UnfinishedBackupFound(
+        val scanResponse: ScanResponse? = null,
+    ) : BackupDialog()
+
+    data class ConfirmDiscardingBackup(
+        val scanResponse: ScanResponse? = null,
+    ) : BackupDialog()
+
     data class ResetBackupCard(val cardId: String) : BackupDialog()
 }

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/OnboardingWalletFragment.kt

@@ -272,6 +272,7 @@ class OnboardingWalletFragment :
         onboardingManageTokensComponent = onboardingManageTokensComponentFactory.create(
             context = onboardingComponentContext,
             params = OnboardingManageTokensComponent.Params(userWalletId = userWalletId),
+            onDone = {},
         )
     }
 

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/ConfirmDiscardingBackupDialog.kt

@@ -3,18 +3,19 @@ package com.tangem.tap.features.onboarding.products.wallet.ui.dialogs
 import android.content.Context
 import androidx.appcompat.app.AlertDialog
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.features.onboarding.products.wallet.redux.BackupAction
 import com.tangem.tap.store
 import com.tangem.wallet.R
 
 object ConfirmDiscardingBackupDialog {
-    fun create(context: Context): AlertDialog {
+    fun create(context: Context, unfinishedBackupScanResponse: ScanResponse? = null): AlertDialog {
         return MaterialAlertDialogBuilder(context, R.style.CustomMaterialDialog).apply {
             setTitle(R.string.welcome_interrupted_backup_discard_title)
             setMessage(R.string.welcome_interrupted_backup_discard_message)
             setPositiveButton(R.string.welcome_interrupted_backup_discard_resume) { _, _ ->
-                store.dispatch(BackupAction.ResumeFoundUnfinishedBackup)
+                store.dispatch(BackupAction.ResumeFoundUnfinishedBackup(unfinishedBackupScanResponse))
             }
             setNegativeButton(R.string.welcome_interrupted_backup_discard_discard) { _, _ ->
                 store.dispatch(BackupAction.DiscardSavedBackup)

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/UnfinishedBackupFoundDialog.kt

@@ -3,6 +3,9 @@ package com.tangem.tap.features.onboarding.products.wallet.ui.dialogs
 import android.content.Context
 import androidx.appcompat.app.AlertDialog
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.tangem.core.analytics.Analytics
+import com.tangem.domain.models.scan.ScanResponse
+import com.tangem.features.onboarding.v2.multiwallet.impl.analytics.OnboardingEvent
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.features.onboarding.products.wallet.redux.BackupAction
 import com.tangem.tap.features.onboarding.products.wallet.redux.BackupDialog
@@ -10,17 +13,19 @@ import com.tangem.tap.store
 import com.tangem.wallet.R
 
 object UnfinishedBackupFoundDialog {
-    fun create(context: Context): AlertDialog {
+    fun create(context: Context, scanResponse: ScanResponse? = null): AlertDialog {
         return MaterialAlertDialogBuilder(context, R.style.CustomMaterialDialog).apply {
             setTitle(R.string.common_warning)
             setMessage(R.string.welcome_interrupted_backup_alert_message)
             setPositiveButton(R.string.welcome_interrupted_backup_alert_resume) { _, _ ->
+                Analytics.send(OnboardingEvent.Backup.ResumeInterruptedBackup)
                 store.dispatch(GlobalAction.HideDialog)
-                store.dispatch(BackupAction.ResumeFoundUnfinishedBackup)
+                store.dispatch(BackupAction.ResumeFoundUnfinishedBackup(scanResponse))
             }
             setNegativeButton(R.string.welcome_interrupted_backup_alert_discard) { _, _ ->
+                Analytics.send(OnboardingEvent.Backup.CancelInterruptedBackup)
                 store.dispatch(GlobalAction.HideDialog)
-                store.dispatch(GlobalAction.ShowDialog(BackupDialog.ConfirmDiscardingBackup))
+                store.dispatch(GlobalAction.ShowDialog(BackupDialog.ConfirmDiscardingBackup(scanResponse)))
             }
             setCancelable(false)
         }.create()

app/src/main/java/com/tangem/tap/features/saveWallet/redux/SaveWalletMiddleware.kt

@@ -5,11 +5,11 @@ import com.tangem.common.core.TangemSdkError
 import com.tangem.common.extensions.guard
 import com.tangem.common.routing.AppRoute
 import com.tangem.core.analytics.Analytics
+import com.tangem.core.analytics.models.event.MainScreenAnalyticsEvent
 import com.tangem.domain.wallets.builder.UserWalletBuilder
 import com.tangem.domain.wallets.models.UserWallet
 import com.tangem.tap.*
 import com.tangem.tap.common.analytics.events.AnalyticsParam
-import com.tangem.tap.common.analytics.events.MainScreen
 import com.tangem.tap.common.analytics.events.Onboarding
 import com.tangem.tap.common.extensions.dispatchNavigationAction
 import com.tangem.tap.common.extensions.dispatchWithMain
@@ -110,7 +110,11 @@ internal class SaveWalletMiddleware {
             // TODO: Remove after onboarding refactoring
             Analytics.send(Onboarding.EnableBiometrics(AnalyticsParam.OnOffState.On))
         } else {
-            Analytics.send(MainScreen.EnableBiometrics(AnalyticsParam.OnOffState.On))
+            Analytics.send(
+                MainScreenAnalyticsEvent.EnableBiometrics(
+                    state = com.tangem.core.analytics.models.AnalyticsParam.OnOffState.On,
+                ),
+            )
         }
 
         /*
@@ -148,7 +152,11 @@ internal class SaveWalletMiddleware {
             // TODO: Remove after onboarding refactoring
             Analytics.send(Onboarding.EnableBiometrics(AnalyticsParam.OnOffState.Off))
         } else {
-            Analytics.send(MainScreen.EnableBiometrics(AnalyticsParam.OnOffState.Off))
+            Analytics.send(
+                MainScreenAnalyticsEvent.EnableBiometrics(
+                    com.tangem.core.analytics.models.AnalyticsParam.OnOffState.Off,
+                ),
+            )
         }
     }
 

app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/TradeCryptoMiddleware.kt

@@ -5,6 +5,7 @@ import com.tangem.blockchain.common.Blockchain
 import com.tangem.common.routing.AppRoute
 import com.tangem.common.routing.AppRouter
 import com.tangem.core.analytics.Analytics
+import com.tangem.domain.onramp.model.OnrampSource
 import com.tangem.domain.settings.usercountry.models.UserCountry
 import com.tangem.domain.tokens.legacy.TradeCryptoAction
 import com.tangem.domain.tokens.model.CryptoCurrency
@@ -55,11 +56,23 @@ object TradeCryptoMiddleware {
 
     private fun proceedBuyAction(state: () -> AppState?, action: TradeCryptoAction.Buy) {
         val isOnrampEnabled = store.inject(DaggerGraphState::onrampFeatureToggles).isFeatureEnabled
-        if (isOnrampEnabled) proceedWithOnramp() else proceedWithLegacyBuyAction(state, action)
+        if (isOnrampEnabled) {
+            proceedWithOnramp(action.userWallet.walletId, action.cryptoCurrencyStatus.currency, action.source)
+        } else {
+            proceedWithLegacyBuyAction(state, action)
+        }
     }
 
-    private fun proceedWithOnramp() {
-        store.dispatchNavigationAction { push(AppRoute.Onramp) }
+    private fun proceedWithOnramp(userWalletId: UserWalletId, cryptoCurrency: CryptoCurrency, source: OnrampSource) {
+        store.dispatchNavigationAction {
+            push(
+                AppRoute.Onramp(
+                    userWalletId = userWalletId,
+                    currency = cryptoCurrency,
+                    source = source,
+                ),
+            )
+        }
     }
 
     private fun proceedWithLegacyBuyAction(state: () -> AppState?, action: TradeCryptoAction.Buy) {
@@ -82,7 +95,7 @@ object TradeCryptoMiddleware {
 
         scope.launch {
             val homeFeatureToggles = store.inject(DaggerGraphState::homeFeatureToggles)
-
+            val onrampFeatureToggles = store.inject(DaggerGraphState::onrampFeatureToggles)
             val isRussia = if (homeFeatureToggles.isMigrateUserCountryCodeEnabled) {
                 val getUserCountryCodeUseCase = store.inject(DaggerGraphState::getUserCountryUseCase)
 
@@ -91,7 +104,7 @@ object TradeCryptoMiddleware {
                 state()?.globalState?.userCountryCode == RUSSIA_COUNTRY_CODE
             }
 
-            if (action.checkUserLocation && isRussia) {
+            if (action.checkUserLocation && isRussia && !onrampFeatureToggles.isFeatureEnabled) {
                 val dialogData = topUrl?.let {
                     AppDialog.RussianCardholdersWarningDialog.Data(topUpUrl = it)
                 }

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

@@ -2,6 +2,7 @@ package com.tangem.tap.network.exchangeServices
 
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.Token
+import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.data.common.currency.CryptoCurrencyFactory
 import com.tangem.domain.tokens.model.CryptoCurrency
 import com.tangem.tap.common.extensions.inject
@@ -10,9 +11,11 @@ import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.store
 import com.tangem.utils.converter.TwoWayConverter
 
-internal class CryptoCurrencyConverter : TwoWayConverter<Currency, CryptoCurrency> {
+internal class CryptoCurrencyConverter(
+    private val excludedBlockchains: ExcludedBlockchains,
+) : TwoWayConverter<Currency, CryptoCurrency> {
 
-    private val cryptoCurrencyFactory by lazy { CryptoCurrencyFactory() }
+    private val cryptoCurrencyFactory by lazy { CryptoCurrencyFactory(excludedBlockchains) }
 
     override fun convert(value: Currency): CryptoCurrency {
         return when (value) {

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

@@ -8,6 +8,8 @@ import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.transaction.TransactionFee
 import com.tangem.blockchain.extensions.Result
 import com.tangem.domain.common.TapWorkarounds.isTangemTwins
+import com.tangem.domain.core.utils.lceContent
+import com.tangem.domain.core.utils.lceLoading
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.tokens.model.CryptoCurrency
@@ -19,6 +21,8 @@ import com.tangem.tap.domain.model.Currency
 import com.tangem.tap.features.demo.isDemoCard
 import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.store
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import java.math.BigDecimal
 
 /**
@@ -30,9 +34,22 @@ class CurrencyExchangeManager(
     private val primaryRules: ExchangeRules,
 ) : ExchangeService {
 
+    override val initializationStatus: StateFlow<ExchangeServiceInitializationStatus>
+        get() = _initializationStatus
+
+    private val _initializationStatus: MutableStateFlow<ExchangeServiceInitializationStatus> =
+        MutableStateFlow(value = lceLoading())
+
     override suspend fun update() {
-        buyService.update()
+        _initializationStatus.value = lceLoading()
+
+        if (!store.inject(DaggerGraphState::onrampFeatureToggles).isFeatureEnabled) {
+            buyService.update()
+        }
+
         sellService.update()
+
+        _initializationStatus.value = lceContent()
     }
 
     override fun isBuyAllowed(): Boolean = primaryRules.isBuyAllowed() && buyService.isBuyAllowed()

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

@@ -1,22 +1,164 @@
 package com.tangem.tap.network.exchangeServices
 
+import com.tangem.blockchainsdk.utils.ExcludedBlockchains
+import com.tangem.datasource.api.express.models.TangemExpressValues.EMPTY_CONTRACT_ADDRESS_VALUE
+import com.tangem.datasource.api.express.models.response.Asset
+import com.tangem.datasource.exchangeservice.swap.ExpressServiceLoader
+import com.tangem.datasource.local.token.ExpressAssetsStore
 import com.tangem.domain.exchange.RampStateManager
 import com.tangem.domain.models.scan.ScanResponse
+import com.tangem.domain.tokens.GetNetworkCoinStatusUseCase
 import com.tangem.domain.tokens.model.CryptoCurrency
+import com.tangem.domain.tokens.model.CryptoCurrencyStatus
+import com.tangem.domain.tokens.model.ScenarioUnavailabilityReason
+import com.tangem.domain.tokens.repository.CurrenciesRepository
+import com.tangem.domain.wallets.models.UserWalletId
+import com.tangem.features.onramp.OnrampFeatureToggles
+import com.tangem.utils.Provider
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import com.tangem.utils.coroutines.runCatching
+import com.tangem.utils.isNullOrZero
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
 
-class DefaultRampManager(private val exchangeService: ExchangeService?) : RampStateManager {
+@Suppress("LongParameterList")
+internal class DefaultRampManager(
+    private val exchangeService: ExchangeService?,
+    private val buyService: Provider<ExchangeService>,
+    private val sellService: Provider<ExchangeService>,
+    private val expressServiceLoader: ExpressServiceLoader,
+    private val currenciesRepository: CurrenciesRepository,
+    private val getNetworkCoinStatusUseCase: GetNetworkCoinStatusUseCase,
+    private val dispatchers: CoroutineDispatcherProvider,
+    private val onrampFeatureToggles: OnrampFeatureToggles,
+    private val expressAssetsStore: ExpressAssetsStore,
+    excludedBlockchains: ExcludedBlockchains,
+) : RampStateManager {
 
-    private val cryptoCurrencyConverter = CryptoCurrencyConverter()
-    override fun availableForBuy(scanResponse: ScanResponse, cryptoCurrency: CryptoCurrency): Boolean {
-        return exchangeService?.availableForBuy(
-            scanResponse,
-            currency = cryptoCurrencyConverter.convertBack(cryptoCurrency),
-        ) ?: false
+    private val cryptoCurrencyConverter = CryptoCurrencyConverter(excludedBlockchains)
+
+    override fun isSellSupportedByService(cryptoCurrency: CryptoCurrency): Boolean {
+        return runCatching {
+            exchangeService?.availableForSell(
+                currency = cryptoCurrencyConverter.convertBack(cryptoCurrency),
+            )
+        }
+            .getOrNull()
+            ?: false
     }
 
-    override fun availableForSell(cryptoCurrency: CryptoCurrency): Boolean {
-        return exchangeService?.availableForSell(
-            currency = cryptoCurrencyConverter.convertBack(cryptoCurrency),
-        ) ?: false
+    override suspend fun availableForBuy(
+        scanResponse: ScanResponse,
+        userWalletId: UserWalletId,
+        cryptoCurrency: CryptoCurrency,
+    ): Boolean {
+        return runCatching {
+            when {
+                onrampFeatureToggles.isFeatureEnabled -> getOnrampAvailable(userWalletId, cryptoCurrency)
+                exchangeService != null -> exchangeService.availableForBuy(
+                    scanResponse = scanResponse,
+                    currency = cryptoCurrencyConverter.convertBack(cryptoCurrency),
+                )
+                else -> false
+            }
+        }
+            .getOrNull()
+            ?: false
+    }
+
+    override suspend fun availableForSell(userWalletId: UserWalletId, status: CryptoCurrencyStatus): Boolean {
+        return runCatching {
+            val sellSupportedByService = isSellSupportedByService(cryptoCurrency = status.currency)
+
+            if (!sellSupportedByService) return false
+
+            val reason = getSendUnavailabilityReason(userWalletId, status)
+
+            reason == ScenarioUnavailabilityReason.None
+        }
+            .getOrNull()
+            ?: false
+    }
+
+    override suspend fun availableForSwap(userWalletId: UserWalletId, cryptoCurrency: CryptoCurrency): Boolean {
+        return runCatching { getExchangeableFlag(userWalletId, cryptoCurrency) && !cryptoCurrency.isCustom }
+            .getOrNull()
+            ?: false
+    }
+
+    override fun getBuyInitializationStatus(): Flow<ExchangeServiceInitializationStatus> {
+        return buyService.invoke().initializationStatus
+    }
+
+    override suspend fun fetchBuyServiceData() {
+        runCatching(dispatchers.io) {
+            buyService.invoke().update()
+        }
+    }
+
+    override fun getSellInitializationStatus(): Flow<ExchangeServiceInitializationStatus> {
+        return sellService.invoke().initializationStatus
+    }
+
+    override suspend fun fetchSellServiceData() {
+        runCatching(dispatchers.io) {
+            sellService.invoke().update()
+        }
+    }
+
+    override fun getExpressInitializationStatus(userWalletId: UserWalletId): Flow<ExchangeServiceInitializationStatus> {
+        return expressServiceLoader.getInitializationStatus(userWalletId)
+    }
+
+    private suspend fun getExchangeableFlag(userWalletId: UserWalletId, cryptoCurrency: CryptoCurrency): Boolean {
+        return withContext(dispatchers.io) {
+            val asset = expressServiceLoader.getInitializationStatus(userWalletId)
+                .value
+                .getOrNull()
+                ?.find { cryptoCurrency.findAssetPredicate(it) }
+
+            asset?.exchangeAvailable ?: false
+        }
+    }
+
+    private suspend fun getOnrampAvailable(userWalletId: UserWalletId, cryptoCurrency: CryptoCurrency): Boolean {
+        val asset = expressAssetsStore.getSyncOrNull(userWalletId)?.find { cryptoCurrency.findAssetPredicate(it) }
+
+        return asset?.onrampAvailable ?: false
+    }
+
+    private fun CryptoCurrency.findAssetPredicate(asset: Asset): Boolean {
+        val contractAddress = (this as? CryptoCurrency.Token)?.contractAddress ?: EMPTY_CONTRACT_ADDRESS_VALUE
+        return asset.network == network.backendId && asset.contractAddress.equals(contractAddress, ignoreCase = true)
+    }
+
+    private suspend fun getSendUnavailabilityReason(
+        userWalletId: UserWalletId,
+        cryptoCurrencyStatus: CryptoCurrencyStatus,
+    ): ScenarioUnavailabilityReason {
+        val coinStatus = getNetworkCoinStatusUseCase.invokeSync(
+            userWalletId = userWalletId,
+            networkId = cryptoCurrencyStatus.currency.network.id,
+            derivationPath = cryptoCurrencyStatus.currency.network.derivationPath,
+            isSingleWalletWithTokens = false,
+        ).getOrNull()
+
+        return when {
+            cryptoCurrencyStatus.value.amount.isNullOrZero() -> {
+                ScenarioUnavailabilityReason.EmptyBalance(ScenarioUnavailabilityReason.WithdrawalScenario.SEND)
+            }
+            currenciesRepository.isSendBlockedByPendingTransactions(
+                cryptoCurrencyStatus = cryptoCurrencyStatus,
+                coinStatus = coinStatus,
+            ) -> {
+                ScenarioUnavailabilityReason.PendingTransaction(
+                    withdrawalScenario = ScenarioUnavailabilityReason.WithdrawalScenario.SEND,
+                    networkName = coinStatus?.currency?.network?.name.orEmpty(),
+                )
+            }
+            else -> {
+                ScenarioUnavailabilityReason.None
+            }
+        }
     }
 }

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

@@ -1,8 +1,14 @@
 package com.tangem.tap.network.exchangeServices
 
+import com.tangem.domain.core.lce.Lce
+import com.tangem.domain.core.utils.lceLoading
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.tokens.model.CryptoCurrency
 import com.tangem.tap.domain.model.Currency
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+
+typealias ExchangeServiceInitializationStatus = Lce<Throwable, Any>
 
 interface Exchanger {
     fun isBuyAllowed(): Boolean
@@ -12,10 +18,17 @@ interface Exchanger {
 }
 
 interface ExchangeService : Exchanger, ExchangeUrlBuilder {
+
+    val initializationStatus: StateFlow<ExchangeServiceInitializationStatus>
+
     suspend fun update()
 
     companion object {
         fun dummy(): ExchangeService = object : ExchangeService {
+
+            override val initializationStatus: StateFlow<ExchangeServiceInitializationStatus> =
+                MutableStateFlow(value = lceLoading())
+
             override suspend fun update() {}
             override fun isBuyAllowed(): Boolean = false
             override fun isSellAllowed(): Boolean = false

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

@@ -138,8 +138,11 @@ internal val Blockchain.mercuryoNetwork: String?
             Blockchain.CasperTestnet -> null
             Blockchain.Core -> null
             Blockchain.CoreTestnet -> null
+            Blockchain.Chiliz -> null
+            Blockchain.ChilizTestnet -> null
             Blockchain.Unknown -> null
             Blockchain.Xodex -> null
             Blockchain.Canxium -> null
+            Blockchain.Clore -> null
         }
     }

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

@@ -6,12 +6,19 @@ import com.tangem.common.extensions.calculateSha512
 import com.tangem.common.extensions.toHexString
 import com.tangem.common.services.Result
 import com.tangem.common.services.performRequest
+import com.tangem.domain.core.utils.lceContent
+import com.tangem.domain.core.utils.lceError
+import com.tangem.domain.core.utils.lceLoading
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.tokens.model.CryptoCurrency
 import com.tangem.tap.domain.model.Currency
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
 import com.tangem.tap.network.exchangeServices.ExchangeService
+import com.tangem.tap.network.exchangeServices.ExchangeServiceInitializationStatus
 import com.tangem.tap.network.exchangeServices.ExchangeUrlBuilder
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import timber.log.Timber
 import java.util.concurrent.CopyOnWriteArrayList
 
 /**
@@ -19,10 +26,34 @@ import java.util.concurrent.CopyOnWriteArrayList
  */
 internal class MercuryoService(private val environment: MercuryoEnvironment) : ExchangeService {
 
+    override val initializationStatus: StateFlow<ExchangeServiceInitializationStatus>
+        get() = _initializationStatus
+
+    private val _initializationStatus: MutableStateFlow<ExchangeServiceInitializationStatus> =
+        MutableStateFlow(value = lceLoading())
+
     private val api: MercuryoApi = environment.mercuryoApi
 
     private val availableMercuryoCurrencies = CopyOnWriteArrayList<MercuryoCurrenciesResponse.MercuryoCryptoCurrency>()
 
+    override suspend fun update() {
+        Timber.i("Start updating")
+        _initializationStatus.value = lceLoading()
+
+        val result = performRequest { api.currencies(environment.apiVersion) }
+        when {
+            result is Result.Success && result.data.status == RESPONSE_SUCCESS_STATUS_CODE -> {
+                handleSuccessfullyUpdatedData(data = result.data.data)
+            }
+            result is Result.Failure -> {
+                availableMercuryoCurrencies.clear()
+
+                Timber.e("Failed to load currencies", result.error)
+                _initializationStatus.value = result.error.lceError()
+            }
+        }
+    }
+
     override fun isBuyAllowed(): Boolean = true
 
     override fun isSellAllowed(): Boolean = false
@@ -42,18 +73,6 @@ internal class MercuryoService(private val environment: MercuryoEnvironment) : E
 
     override fun availableForSell(currency: Currency): Boolean = false
 
-    override suspend fun update() {
-        val result = performRequest { api.currencies(environment.apiVersion) }
-        when {
-            result is Result.Success && result.data.status == RESPONSE_SUCCESS_STATUS_CODE -> {
-                handleSuccessfullyUpdatedData(data = result.data.data)
-            }
-            result is Result.Failure -> {
-                availableMercuryoCurrencies.clear()
-            }
-        }
-    }
-
     override fun getUrl(
         action: CurrencyExchangeManager.Action,
         cryptoCurrency: CryptoCurrency,
@@ -89,6 +108,9 @@ internal class MercuryoService(private val environment: MercuryoEnvironment) : E
     private fun handleSuccessfullyUpdatedData(data: MercuryoCurrenciesResponse.Data) {
         availableMercuryoCurrencies.clear()
         availableMercuryoCurrencies.addAll(data.config.cryptoCurrencies)
+
+        Timber.i("Successfully updated")
+        _initializationStatus.value = lceContent()
     }
 
     private fun signature(address: String) = (address + environment.secret).calculateSha512().toHexString().lowercase()

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

@@ -7,13 +7,20 @@ import com.tangem.common.services.Result
 import com.tangem.common.services.performRequest
 import com.tangem.datasource.api.common.createRetrofitInstance
 import com.tangem.domain.common.extensions.withIOContext
+import com.tangem.domain.core.utils.lceContent
+import com.tangem.domain.core.utils.lceError
+import com.tangem.domain.core.utils.lceLoading
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.tokens.model.CryptoCurrency
 import com.tangem.tap.domain.model.Currency
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
 import com.tangem.tap.network.exchangeServices.ExchangeService
+import com.tangem.tap.network.exchangeServices.ExchangeServiceInitializationStatus
 import com.tangem.tap.network.exchangeServices.ExchangeUrlBuilder.Companion.SCHEME
 import com.tangem.tap.network.exchangeServices.moonpay.models.MoonPayAvailableCurrency
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import timber.log.Timber
 import javax.crypto.Mac
 import javax.crypto.spec.SecretKeySpec
 
@@ -23,6 +30,12 @@ class MoonPayService(
     private val logEnabled: Boolean,
 ) : ExchangeService {
 
+    override val initializationStatus: StateFlow<ExchangeServiceInitializationStatus>
+        get() = _initializationStatus
+
+    private val _initializationStatus: MutableStateFlow<ExchangeServiceInitializationStatus> =
+        MutableStateFlow(value = lceLoading())
+
     private val api: MoonPayApi by lazy {
         createRetrofitInstance(
             baseUrl = MoonPayApi.MOOONPAY_BASE_URL,
@@ -34,14 +47,25 @@ class MoonPayService(
 
     override suspend fun update() {
         withIOContext {
+            Timber.i("Start updating")
+            _initializationStatus.value = lceLoading()
+
             performRequest {
                 val userStatus = when (val result = performRequest { api.getUserStatus(apiKey) }) {
-                    is Result.Failure -> return@performRequest
+                    is Result.Failure -> {
+                        Timber.e("Failed to load user status", result.error)
+                        _initializationStatus.value = result.error.lceError()
+                        return@performRequest
+                    }
                     is Result.Success -> result.data
                 }
 
                 val currencies = when (val result = performRequest { api.getCurrencies(apiKey) }) {
-                    is Result.Failure -> return@performRequest
+                    is Result.Failure -> {
+                        Timber.e("Failed to load currencies", result.error)
+                        _initializationStatus.value = result.error.lceError()
+                        return@performRequest
+                    }
                     is Result.Success -> result.data
                 }
 
@@ -58,6 +82,8 @@ class MoonPayService(
                         )
                     }
 
+                Timber.i("Successfully updated")
+                _initializationStatus.value = lceContent()
                 status = MoonPayStatus(currenciesToSell, userStatus, currencies)
             }
         }

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

@@ -43,6 +43,7 @@ internal val Blockchain.moonPaySupportedCurrency: MoonPaySupportedCurrency?
         Filecoin -> MoonPaySupportedCurrency(networkCode = "filecoin", currencyCode = "fil")
         Sui -> MoonPaySupportedCurrency(networkCode = "sui", currencyCode = "sui")
         Core -> MoonPaySupportedCurrency(networkCode = "core", currencyCode = "core")
+        Chiliz -> MoonPaySupportedCurrency(networkCode = "ethereum", currencyCode = "chz")
         ArbitrumTestnet -> null
         AvalancheTestnet -> null
         BinanceTestnet -> null
@@ -139,7 +140,9 @@ internal val Blockchain.moonPaySupportedCurrency: MoonPaySupportedCurrency?
         Casper -> null
         CasperTestnet -> null
         CoreTestnet -> null
+        ChilizTestnet -> null
         Unknown -> null
         Xodex -> null
         Canxium -> null
+        Clore -> null
     }

app/src/main/java/com/tangem/tap/proxy/AppStateHolder.kt

@@ -1,6 +1,5 @@
 package com.tangem.tap.proxy
 
-import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.redux.ReduxStateHolder
 import com.tangem.domain.redux.StateDialog
@@ -26,10 +25,8 @@ class AppStateHolder @Inject constructor() : ReduxStateHolder {
     var mainStore: Store<AppState>? = null
     var tangemSdkManager: TangemSdkManager? = null
     var exchangeService: ExchangeService? = null
-
-    fun getActualCard(): CardDTO? {
-        return scanResponse?.card
-    }
+    var buyService: ExchangeService? = null
+    var sellService: ExchangeService? = null
 
     override fun dispatch(action: Action) {
         mainStore?.dispatch(action)

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

@@ -2,6 +2,7 @@ package com.tangem.tap.proxy.redux
 
 import com.tangem.blockchainsdk.BlockchainSDKFactory
 import com.tangem.blockchainsdk.signer.TransactionSignerFactory
+import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.common.routing.AppRouter
 import com.tangem.core.navigation.share.ShareManager
 import com.tangem.core.navigation.url.UrlOpener
@@ -20,6 +21,7 @@ import com.tangem.domain.feedback.GetCardInfoUseCase
 import com.tangem.domain.feedback.SendFeedbackEmailUseCase
 import com.tangem.domain.onboarding.SaveTwinsOnboardingShownUseCase
 import com.tangem.domain.onboarding.WasTwinsOnboardingShownUseCase
+import com.tangem.domain.onboarding.repository.OnboardingRepository
 import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.settings.usercountry.GetUserCountryUseCase
 import com.tangem.domain.walletmanager.WalletManagersFacade
@@ -72,5 +74,7 @@ data class DaggerGraphState(
     val onrampFeatureToggles: OnrampFeatureToggles? = null,
     val environmentConfigStorage: EnvironmentConfigStorage? = null,
     val onboardingV2FeatureToggles: OnboardingV2FeatureToggles? = null,
+    val onboardingRepository: OnboardingRepository? = null,
+    val excludedBlockchains: ExcludedBlockchains? = null,
     val appPreferencesStore: AppPreferencesStore? = null,
 ) : StateType

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

@@ -27,7 +27,7 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
 
     override val stack: Value<ChildStack<AppRoute, Child>> = childStack(
         source = navigationProvider.getOrCreateTyped(),
-        serializer = AppRoute.serializer(),
+        serializer = AppRoute.serializer(), // TODO Maybe set this to null for AppRoute.Onboarding case. Need to check
         initialConfiguration = getInitialRoute(),
         handleBackButton = false,
         childFactory = ::child,

app/src/main/java/com/tangem/tap/routing/utils/ChildFactory.kt

@@ -11,10 +11,8 @@ import com.tangem.features.disclaimer.api.components.DisclaimerComponent
 import com.tangem.features.managetokens.component.ManageTokensComponent
 import com.tangem.features.managetokens.component.ManageTokensSource
 import com.tangem.features.markets.details.MarketsTokenDetailsComponent
-import com.tangem.features.onramp.component.BuyCryptoComponent
 import com.tangem.features.onboarding.v2.entry.OnboardingEntryComponent
-import com.tangem.features.onramp.component.OnrampComponent
-import com.tangem.features.onramp.component.SellCryptoComponent
+import com.tangem.features.onramp.component.*
 import com.tangem.features.pushnotifications.api.navigation.PushNotificationsRouter
 import com.tangem.features.send.api.navigation.SendRouter
 import com.tangem.features.staking.api.navigation.StakingRouter
@@ -51,8 +49,10 @@ internal class ChildFactory @Inject constructor(
     private val manageTokensComponentFactory: ManageTokensComponent.Factory,
     private val marketsTokenDetailsComponentFactory: MarketsTokenDetailsComponent.Factory,
     private val onrampComponentFactory: OnrampComponent.Factory,
+    private val onrampSuccessComponentFactory: OnrampSuccessComponent.Factory,
     private val buyCryptoComponentFactory: BuyCryptoComponent.Factory,
     private val sellCryptoComponentFactory: SellCryptoComponent.Factory,
+    private val swapSelectTokensComponentFactory: SwapSelectTokensComponent.Factory,
     private val onboardingEntryComponentFactory: OnboardingEntryComponent.Factory,
     private val sendRouter: SendRouter,
     private val tokenDetailsRouter: TokenDetailsRouter,
@@ -197,10 +197,21 @@ internal class ChildFactory @Inject constructor(
             is AppRoute.Onramp -> {
                 route.asComponentChild(
                     contextProvider = contextProvider(route, contextFactory),
-                    params = OnrampComponent.Params(),
+                    params = OnrampComponent.Params(
+                        userWalletId = route.userWalletId,
+                        cryptoCurrency = route.currency,
+                        source = route.source,
+                    ),
                     componentFactory = onrampComponentFactory,
                 )
             }
+            is AppRoute.OnrampSuccess -> {
+                route.asComponentChild(
+                    contextProvider = contextProvider(route, contextFactory),
+                    params = OnrampSuccessComponent.Params(route.externalTxId),
+                    componentFactory = onrampSuccessComponentFactory,
+                )
+            }
             is AppRoute.BuyCrypto -> {
                 route.asComponentChild(
                     contextProvider = contextProvider(route, contextFactory),
@@ -215,10 +226,24 @@ internal class ChildFactory @Inject constructor(
                     componentFactory = sellCryptoComponentFactory,
                 )
             }
+            is AppRoute.SwapCrypto -> {
+                route.asComponentChild(
+                    contextProvider = contextProvider(route, contextFactory),
+                    params = SwapSelectTokensComponent.Params(userWalletId = route.userWalletId),
+                    componentFactory = swapSelectTokensComponentFactory,
+                )
+            }
             is AppRoute.Onboarding -> {
                 route.asComponentChild(
                     contextProvider = contextProvider(route, contextFactory),
-                    params = OnboardingEntryComponent.Params(route.scanResponse),
+                    params = OnboardingEntryComponent.Params(
+                        scanResponse = route.scanResponse,
+                        startBackupFlow = route.startFromBackup,
+                        multiWalletMode = when (route.mode) {
+                            AppRoute.Onboarding.Mode.Onboarding -> OnboardingEntryComponent.MultiWalletMode.Onboarding
+                            AppRoute.Onboarding.Mode.AddBackup -> OnboardingEntryComponent.MultiWalletMode.AddBackup
+                        },
+                    ),
                     componentFactory = onboardingEntryComponentFactory,
                 )
             }

app/src/main/res/layout/activity_main.xml

@@ -3,6 +3,7 @@
     android:id="@+id/fragment_container"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
-    android:background="@color/background_primary">
+    android:background="@color/background_primary"
+    android:filterTouchesWhenObscured="true">
 
 </androidx.coordinatorlayout.widget.CoordinatorLayout>

app/src/test/kotlin/com/tangem/tap/domain/card/CryptoCurrenciesMocks.kt

@@ -3,6 +3,7 @@ package com.tangem.tap.domain.card
 import com.tangem.blockchain.common.Blockchain
 import com.tangem.blockchain.common.FeePaidCurrency
 import com.tangem.blockchain.common.Token
+import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.blockchainsdk.utils.toNetworkId
 import com.tangem.data.common.currency.CryptoCurrencyFactory
 import com.tangem.data.common.currency.getNetworkDerivationPath
@@ -17,7 +18,7 @@ import com.tangem.domain.tokens.model.Network
  */
 internal class CryptoCurrenciesMocks(private val scanResponse: ScanResponse) {
 
-    private val factory = CryptoCurrencyFactory()
+    private val factory = CryptoCurrencyFactory(excludedBlockchains = ExcludedBlockchains())
 
     val cardano by lazy { listOf(createCoin(blockchain = Blockchain.Cardano)) }
     val chia by lazy { listOf(element = createCoin(Blockchain.Chia)) }
@@ -58,6 +59,7 @@ internal class CryptoCurrenciesMocks(private val scanResponse: ScanResponse) {
             standardType = getNetworkStandardType(blockchain),
             hasFiatFeeRate = blockchain.feePaidCurrency() !is FeePaidCurrency.FeeResource,
             canHandleTokens = false,
+            transactionExtrasType = Network.TransactionExtrasType.NONE,
         )
 
         return factory.createCoin(network = network)
@@ -85,6 +87,7 @@ internal class CryptoCurrenciesMocks(private val scanResponse: ScanResponse) {
                 standardType = Network.StandardType.ERC20,
                 hasFiatFeeRate = true,
                 canHandleTokens = true,
+                transactionExtrasType = Network.TransactionExtrasType.NONE,
             ),
             name = "NEVER-MIND",
             symbol = "NEVER-MIND",

app/src/test/kotlin/com/tangem/tap/domain/card/DefaultDerivationsRepositoryTest.kt

@@ -2,6 +2,7 @@ package com.tangem.tap.domain.card
 
 import android.annotation.SuppressLint
 import com.google.common.truth.Truth
+import com.tangem.blockchainsdk.utils.ExcludedBlockchains
 import com.tangem.common.CompletionResult
 import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.domain.card.ScanCardException
@@ -29,6 +30,7 @@ internal class DefaultDerivationsRepositoryTest {
         tangemSdkManager = tangemSdkManager,
         userWalletsStore = userWalletsStore,
         dispatchers = TestingCoroutineDispatcherProvider(),
+        excludedBlockchains = ExcludedBlockchains(),
     )
 
     private val defaultUserWalletId = UserWalletId("011")

common/google/build.gradle.kts

@@ -0,0 +1,15 @@
+plugins {
+    alias(deps.plugins.android.library)
+    alias(deps.plugins.kotlin.android)
+    id("configuration")
+}
+
+android {
+    namespace = "com.tangem.common.google"
+}
+
+dependencies {
+
+    implementation(deps.googlePlay.services.wallet)
+
+}

common/google/src/main/java/com/tangem/google/GoogleServicesHelper.kt

@@ -0,0 +1,89 @@
+package com.tangem.google
+
+import android.content.Context
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
+import com.google.android.gms.common.api.ApiException
+import com.google.android.gms.wallet.IsReadyToPayRequest
+import com.google.android.gms.wallet.PaymentsClient
+import com.google.android.gms.wallet.Wallet
+import org.json.JSONArray
+import org.json.JSONObject
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+object GoogleServicesHelper {
+
+    private val allowedCardNetworks = JSONArray(
+        listOf(
+            "AMEX",
+            "DISCOVER",
+            "INTERAC",
+            "JCB",
+            "MASTERCARD",
+            "VISA",
+        ),
+    )
+
+    private val allowedCardAuthMethods = JSONArray(
+        listOf(
+            "PAN_ONLY",
+            "CRYPTOGRAM_3DS",
+        ),
+    )
+
+    private val baseCardPaymentMethod: JSONObject = JSONObject().apply {
+        val parameters = JSONObject().apply {
+            put("allowedAuthMethods", allowedCardAuthMethods)
+            put("allowedCardNetworks", allowedCardNetworks)
+            put("billingAddressRequired", true)
+            put(
+                "billingAddressParameters",
+                JSONObject().apply {
+                    put("format", "FULL")
+                },
+            )
+        }
+
+        put("type", "CARD")
+        put("parameters", parameters)
+    }
+
+    private val baseRequest = JSONObject().apply {
+        put("apiVersion", 2)
+        put("apiVersionMinor", 0)
+    }
+
+    private val availabilityRequest = baseRequest.apply {
+        put("allowedPaymentMethods", JSONArray().put(baseCardPaymentMethod))
+    }
+
+    fun createPaymentsClient(context: Context): PaymentsClient {
+        val walletOptions = Wallet.WalletOptions.Builder()
+            .build()
+        return Wallet.getPaymentsClient(context, walletOptions)
+    }
+
+    fun checkGoogleServicesAvailability(context: Context): Boolean {
+        val googleApiAvailability = GoogleApiAvailability.getInstance()
+        val status = googleApiAvailability.isGooglePlayServicesAvailable(context)
+
+        return status == ConnectionResult.SUCCESS
+    }
+
+    suspend fun checkGooglePayAvailability(paymentsClient: PaymentsClient): Boolean {
+        val request = IsReadyToPayRequest.fromJson(availabilityRequest.toString())
+        val task = paymentsClient.isReadyToPay(request)
+
+        return suspendCoroutine<Result<Boolean>> { continuation ->
+            task.addOnCompleteListener { completedTask ->
+                try {
+                    val result = completedTask.getResult(ApiException::class.java)
+                    continuation.resume(Result.success(result))
+                } catch (exception: ApiException) {
+                    continuation.resume(Result.failure(exception))
+                }
+            }
+        }.getOrElse { false }
+    }
+}

common/routing/build.gradle.kts

@@ -20,6 +20,7 @@ dependencies {
     implementation(projects.domain.wallets.models)
     implementation(projects.domain.staking.models)
     implementation(projects.domain.markets.models)
+    implementation(projects.domain.onramp.models)
     implementation(projects.domain.appCurrency.models)
 
     /* Libs - Other */

common/routing/src/main/kotlin/com/tangem/common/routing/AppRoute.kt

@@ -8,6 +8,7 @@ import com.tangem.core.decompose.navigation.Route
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.markets.TokenMarketParams
 import com.tangem.domain.models.scan.ScanResponse
+import com.tangem.domain.onramp.model.OnrampSource
 import com.tangem.domain.qrscanning.models.SourceType
 import com.tangem.domain.staking.model.stakekit.Yield
 import com.tangem.domain.tokens.model.CryptoCurrency
@@ -219,16 +220,24 @@ sealed class AppRoute(val path: String) : Route {
 
     @Serializable
     data class Swap(
-        val currency: CryptoCurrency,
+        val currencyFrom: CryptoCurrency,
+        val currencyTo: CryptoCurrency? = null,
         val userWalletId: UserWalletId,
         val isInitialReverseOrder: Boolean = false,
-    ) : AppRoute(path = "/swap/${currency.id.value}/${userWalletId.stringValue}/$isInitialReverseOrder"),
+    ) : AppRoute(
+        path = "/swap" +
+            "/${currencyFrom.id.value}" +
+            "/${currencyTo?.id?.value}" +
+            "/${userWalletId.stringValue}" +
+            "/$isInitialReverseOrder",
+    ),
         RouteBundleParams {
 
         override fun getBundle(): Bundle = bundle(serializer())
 
         companion object {
-            const val CURRENCY_BUNDLE_KEY = "currency"
+            const val CURRENCY_FROM_KEY = "currencyFrom"
+            const val CURRENCY_TO_KEY = "currencyTo"
             const val USER_WALLET_ID_KEY = "userWalletId"
             const val IS_INITIAL_REVERSE_ORDER = "isInitialReverseOrder"
         }
@@ -287,7 +296,20 @@ sealed class AppRoute(val path: String) : Route {
     }
 
     @Serializable
-    data object Onramp : AppRoute(path = "/onramp")
+    data class Onramp(
+        val source: OnrampSource,
+        val userWalletId: UserWalletId,
+        val currency: CryptoCurrency,
+    ) : AppRoute(path = "/onramp/${userWalletId.stringValue}/${currency.symbol}"), RouteBundleParams {
+        override fun getBundle(): Bundle = bundle(serializer())
+    }
+
+    @Serializable
+    data class OnrampSuccess(
+        val externalTxId: String,
+    ) : AppRoute(path = "/onramp/success/$externalTxId"), RouteBundleParams {
+        override fun getBundle(): Bundle = bundle(serializer())
+    }
 
     @Serializable
     data class BuyCrypto(
@@ -299,6 +321,22 @@ sealed class AppRoute(val path: String) : Route {
         val userWalletId: UserWalletId,
     ) : AppRoute(path = "/sell_crypto/${userWalletId.stringValue}")
 
+    @Serializable
+    data class SwapCrypto(
+        val userWalletId: UserWalletId,
+    ) : AppRoute(path = "/swap_crypto/${userWalletId.stringValue}")
+
     // Onboarding V2
-    data class Onboarding(val scanResponse: ScanResponse) : AppRoute(path = "/onboarding_v2")
+    @Serializable
+    data class Onboarding(
+        val scanResponse: ScanResponse,
+        val startFromBackup: Boolean,
+        val mode: Mode = Mode.Onboarding,
+    ) : AppRoute(path = "/onboarding_v2${if (startFromBackup) "/backup" else ""}") {
+
+        enum class Mode {
+            Onboarding, // general Mode
+            AddBackup, // continue backup process for existing wallet 1
+        }
+    }
 }

common/ui/src/main/java/com/tangem/common/ui/bottomsheet/permission/GiveTxPermisssionBottomSheet.kt

@@ -31,10 +31,7 @@ import com.tangem.core.ui.components.bottomsheets.TangemBottomSheet
 import com.tangem.core.ui.components.bottomsheets.TangemBottomSheetConfig
 import com.tangem.core.ui.components.containers.FooterContainer
 import com.tangem.core.ui.components.inputrow.InputRowDefault
-import com.tangem.core.ui.extensions.TextReference
-import com.tangem.core.ui.extensions.resolveReference
-import com.tangem.core.ui.extensions.resourceReference
-import com.tangem.core.ui.extensions.wrappedList
+import com.tangem.core.ui.extensions.*
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
 import kotlinx.collections.immutable.ImmutableList
@@ -118,7 +115,7 @@ private fun GiveTxPermissionBottomSheetContent(content: GiveTxPermissionBottomSh
 @Composable
 private fun ApprovalBottomSheetInfo(data: GiveTxPermissionState.ReadyForRequest) {
     FooterContainer(
-        footer = stringResource(id = R.string.give_permission_policy_type_footer),
+        footer = resourceReference(R.string.give_permission_policy_type_footer),
         modifier = Modifier.padding(horizontal = TangemTheme.dimens.spacing16),
     ) {
         AmountItem(
@@ -130,7 +127,7 @@ private fun ApprovalBottomSheetInfo(data: GiveTxPermissionState.ReadyForRequest)
     }
     SpacerH16()
     FooterContainer(
-        footer = data.footerText.resolveReference(),
+        footer = data.footerText,
         modifier = Modifier.padding(horizontal = TangemTheme.dimens.spacing16),
     ) {
         FeeItem(fee = data.fee)

common/ui/src/main/java/com/tangem/common/ui/expressStatus/ExpressStatusBlock.kt

@@ -0,0 +1,228 @@
+package com.tangem.common.ui.expressStatus
+
+import androidx.annotation.DrawableRes
+import androidx.compose.animation.*
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.tooling.preview.Preview
+import com.tangem.common.ui.R
+import com.tangem.common.ui.expressStatus.state.ExpressLinkUM
+import com.tangem.common.ui.expressStatus.state.ExpressStatusItemState
+import com.tangem.common.ui.expressStatus.state.ExpressStatusItemUM
+import com.tangem.common.ui.expressStatus.state.ExpressStatusUM
+import com.tangem.core.ui.components.SpacerWMax
+import com.tangem.core.ui.extensions.resolveReference
+import com.tangem.core.ui.extensions.resourceReference
+import com.tangem.core.ui.extensions.stringReference
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.core.ui.res.TangemThemePreview
+import kotlinx.collections.immutable.persistentListOf
+
+/**
+ * Block with express statuses
+ *
+ * @param state ui holder
+ * @param modifier modifier
+ * @see [Figma](https://www.figma.com/design/Vs6SkVsFnUPsSCNwlnVf5U/Android-%E2%80%93-UI?node-id=18459-26521&t=4jox7bfqUiXnm2h1-4)
+ */
+@Composable
+fun ExpressStatusBlock(state: ExpressStatusUM, modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier
+            .clip(TangemTheme.shapes.roundedCornersXMedium)
+            .background(TangemTheme.colors.background.action)
+            .padding(
+                vertical = TangemTheme.dimens.spacing14,
+                horizontal = TangemTheme.dimens.spacing12,
+            ),
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier
+                .padding(bottom = TangemTheme.dimens.spacing16),
+        ) {
+            Text(
+                text = state.title.resolveReference(),
+                style = TangemTheme.typography.subtitle2,
+                color = TangemTheme.colors.text.tertiary,
+            )
+            SpacerWMax()
+            AnimatedVisibility(visible = state.link is ExpressLinkUM.Content) {
+                val link = remember(this) { state.link as ExpressLinkUM.Content }
+                Row(
+                    modifier = Modifier.clickable { link.onClick() },
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Icon(
+                        painter = painterResource(id = link.icon),
+                        contentDescription = null,
+                        tint = TangemTheme.colors.icon.informative,
+                        modifier = Modifier
+                            .size(TangemTheme.dimens.spacing16)
+                            .padding(end = TangemTheme.dimens.spacing2),
+                    )
+                    Text(
+                        text = link.text.resolveReference(),
+                        style = TangemTheme.typography.body2,
+                        color = TangemTheme.colors.text.tertiary,
+                    )
+                }
+            }
+        }
+
+        Column {
+            state.statuses.forEachIndexed { index, item ->
+                ExpressStatusStep(item, index == state.statuses.lastIndex)
+            }
+        }
+    }
+}
+
+@Composable
+private fun ExpressStatusStep(status: ExpressStatusItemUM, isLast: Boolean) {
+    AnimatedContent(
+        targetState = status,
+        label = "Exchange Step Change Success",
+        transitionSpec = {
+            fadeIn(tween(durationMillis = 220)) togetherWith
+                fadeOut(tween(durationMillis = 220))
+        },
+    ) { content ->
+        Row {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+            ) {
+                when (content.state) {
+                    ExpressStatusItemState.Active -> StepInProgress()
+                    ExpressStatusItemState.Default -> StepDefault()
+                    ExpressStatusItemState.Done -> Step(
+                        iconRes = R.drawable.ic_check_24,
+                        iconColor = TangemTheme.colors.icon.primary1,
+                        borderColor = TangemTheme.colors.field.focused,
+                    )
+                    ExpressStatusItemState.Error -> Step(
+                        iconRes = R.drawable.ic_close_24,
+                        iconColor = TangemTheme.colors.icon.warning,
+                    )
+                    ExpressStatusItemState.Warning -> Step(
+                        iconRes = R.drawable.ic_close_24,
+                        iconColor = TangemTheme.colors.icon.attention,
+                    )
+                }
+                if (!isLast) {
+                    StepSeparator()
+                }
+            }
+            val textColor = when (status.state) {
+                ExpressStatusItemState.Active -> TangemTheme.colors.text.primary1
+                ExpressStatusItemState.Default -> TangemTheme.colors.text.disabled
+                ExpressStatusItemState.Done -> TangemTheme.colors.text.primary1
+                ExpressStatusItemState.Error -> TangemTheme.colors.text.warning
+                ExpressStatusItemState.Warning -> TangemTheme.colors.text.attention
+            }
+            Text(
+                text = content.text.resolveReference(),
+                style = TangemTheme.typography.body2,
+                color = textColor,
+                modifier = Modifier
+                    .padding(start = TangemTheme.dimens.spacing12),
+            )
+        }
+    }
+}
+
+@Composable
+private fun StepDefault() {
+    Box(
+        modifier = Modifier
+            .size(TangemTheme.dimens.size20)
+            .border(
+                width = TangemTheme.dimens.size1_5,
+                color = TangemTheme.colors.field.focused,
+                shape = CircleShape,
+            )
+            .padding(TangemTheme.dimens.spacing2),
+    )
+}
+
+@Composable
+private fun Step(iconColor: Color, @DrawableRes iconRes: Int, borderColor: Color = iconColor) {
+    Icon(
+        painter = painterResource(id = iconRes),
+        contentDescription = null,
+        tint = iconColor,
+        modifier = Modifier
+            .size(TangemTheme.dimens.size20)
+            .border(
+                width = TangemTheme.dimens.size1_5,
+                color = borderColor,
+                shape = CircleShape,
+            )
+            .padding(TangemTheme.dimens.spacing2),
+    )
+}
+
+@Composable
+private fun StepInProgress() {
+    CircularProgressIndicator(
+        color = TangemTheme.colors.icon.primary1,
+        strokeWidth = TangemTheme.dimens.size2,
+        modifier = Modifier
+            .padding(TangemTheme.dimens.spacing2)
+            .size(TangemTheme.dimens.size14),
+    )
+}
+
+@Composable
+private fun StepSeparator() {
+    Box(
+        modifier = Modifier
+            .padding(vertical = TangemTheme.dimens.spacing2)
+            .size(
+                width = TangemTheme.dimens.size1_5,
+                height = TangemTheme.dimens.size10,
+            )
+            .background(
+                color = TangemTheme.colors.field.focused,
+                shape = CircleShape,
+            ),
+    )
+}
+
+@Preview
+@Composable
+private fun Preview_ExchangeStatusBlock() {
+    val state = ExpressStatusUM(
+        title = resourceReference(R.string.express_exchange_status_title),
+        link = ExpressLinkUM.Content(
+            icon = R.drawable.ic_alert_24,
+            text = resourceReference(R.string.common_go_to_provider),
+            onClick = {},
+        ),
+        statuses = persistentListOf(
+            ExpressStatusItemUM(text = stringReference("Done"), state = ExpressStatusItemState.Done),
+            ExpressStatusItemUM(text = stringReference("Active"), state = ExpressStatusItemState.Active),
+            ExpressStatusItemUM(text = stringReference("Warning"), state = ExpressStatusItemState.Warning),
+            ExpressStatusItemUM(text = stringReference("Error"), state = ExpressStatusItemState.Error),
+            ExpressStatusItemUM(text = stringReference("Default"), state = ExpressStatusItemState.Default),
+        ),
+    )
+
+    TangemThemePreview {
+        ExpressStatusBlock(state = state)
+    }
+}

common/ui/src/main/java/com/tangem/common/ui/expressStatus/ExpressStatusNotificationBlock.kt

@@ -0,0 +1,32 @@
+package com.tangem.common.ui.expressStatus
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import com.tangem.common.ui.notifications.ExpressNotificationsUM
+import com.tangem.common.ui.notifications.NotificationUM
+import com.tangem.core.ui.components.notifications.Notification
+import com.tangem.core.ui.res.TangemTheme
+
+@Composable
+fun ExpressStatusNotificationBlock(state: NotificationUM?) {
+    AnimatedVisibility(
+        visible = state?.config != null,
+        modifier = Modifier.padding(top = 12.dp),
+        label = "Express Status Notification Change",
+    ) {
+        val wrappedNotification = remember(this) { requireNotNull(state?.config) }
+        Notification(
+            config = wrappedNotification,
+            iconTint = when (state) {
+                is ExpressNotificationsUM.NeedVerification -> TangemTheme.colors.icon.attention
+                is ExpressNotificationsUM.FailedByProvider -> TangemTheme.colors.icon.warning
+                else -> null
+            },
+            containerColor = TangemTheme.colors.background.action,
+        )
+    }
+}

common/ui/src/main/java/com/tangem/common/ui/expressStatus/state/ExpressStatusUM.kt

@@ -0,0 +1,54 @@
+package com.tangem.common.ui.expressStatus.state
+
+import androidx.annotation.DrawableRes
+import androidx.compose.runtime.Stable
+import com.tangem.core.ui.extensions.TextReference
+import kotlinx.collections.immutable.ImmutableList
+
+/**
+ * UI data holder for express status block
+ *
+ * @property title block title
+ * @property link provider web link
+ * @property statuses list of possible and active statuses
+ */
+data class ExpressStatusUM(
+    val title: TextReference,
+    val link: ExpressLinkUM,
+    val statuses: ImmutableList<ExpressStatusItemUM>,
+)
+
+/**
+ * Provider web link for express status block.
+ * [Empty] if no link needed
+ * [Content] if link is provided and displayed
+ */
+@Stable
+sealed class ExpressLinkUM {
+    data object Empty : ExpressLinkUM()
+    data class Content(
+        @DrawableRes val icon: Int,
+        val text: TextReference,
+        val onClick: () -> Unit,
+    ) : ExpressLinkUM()
+}
+
+/**
+ * Single status item in express status block
+ */
+data class ExpressStatusItemUM(
+    val text: TextReference,
+    val state: ExpressStatusItemState,
+)
+
+/**
+ * Available status states for express status block
+ */
+enum class ExpressStatusItemState {
+    Active,
+    Default,
+    Done,
+    Warning,
+    Error,
+    ;
+}

common/ui/src/main/java/com/tangem/common/ui/notifications/ExpressNotificationsUM.kt

@@ -0,0 +1,28 @@
+package com.tangem.common.ui.notifications
+
+import com.tangem.common.ui.R
+import com.tangem.core.ui.components.notifications.NotificationConfig
+import com.tangem.core.ui.extensions.resourceReference
+
+object ExpressNotificationsUM {
+
+    data class NeedVerification(val onGoToProviderClick: () -> Unit) : NotificationUM.Warning(
+        title = resourceReference(R.string.express_exchange_notification_verification_title),
+        subtitle = resourceReference(R.string.express_exchange_notification_verification_text),
+        iconResId = R.drawable.ic_alert_triangle_20,
+        buttonsState = NotificationConfig.ButtonsState.SecondaryButtonConfig(
+            text = resourceReference(R.string.common_go_to_provider),
+            onClick = onGoToProviderClick,
+        ),
+    )
+
+    data class FailedByProvider(val onGoToProviderClick: () -> Unit) : NotificationUM.Error(
+        title = resourceReference(R.string.express_exchange_notification_failed_title),
+        subtitle = resourceReference(R.string.express_exchange_notification_failed_text),
+        iconResId = R.drawable.ic_alert_circle_24,
+        buttonState = NotificationConfig.ButtonsState.SecondaryButtonConfig(
+            text = resourceReference(R.string.common_go_to_provider),
+            onClick = onGoToProviderClick,
+        ),
+    )
+}

common/ui/src/main/java/com/tangem/common/ui/notifications/NotificationUM.kt

@@ -9,6 +9,7 @@ import com.tangem.core.ui.extensions.wrappedList
 import com.tangem.core.ui.format.bigdecimal.crypto
 import com.tangem.core.ui.format.bigdecimal.format
 import com.tangem.core.ui.format.bigdecimal.shorted
+import com.tangem.domain.tokens.model.warnings.CryptoCurrencyWarning
 import java.math.BigDecimal
 
 sealed class NotificationUM(val config: NotificationConfig) {
@@ -226,6 +227,24 @@ sealed class NotificationUM(val config: NotificationConfig) {
                 wrappedList(cryptoAmount, fiatAmount),
             ),
         )
+
+        data class OnrampErrorNotification(val errorCode: String?, val onRefresh: () -> Unit) : Warning(
+            title = resourceReference(R.string.common_error),
+            subtitle = if (errorCode != null) {
+                resourceReference(R.string.express_error_code, wrappedList(errorCode))
+            } else {
+                resourceReference(R.string.common_unknown_error)
+            },
+            buttonsState = NotificationConfig.ButtonsState.SecondaryButtonConfig(
+                text = resourceReference(R.string.warning_button_refresh),
+                onClick = onRefresh,
+            ),
+        )
+
+        data object SwapNoAvailablePair : Warning(
+            title = resourceReference(id = R.string.action_buttons_swap_no_available_pair_notification_title),
+            subtitle = resourceReference(id = R.string.action_buttons_swap_no_available_pair_notification_message),
+        )
     }
 
     open class Info(
@@ -307,4 +326,17 @@ sealed class NotificationUM(val config: NotificationConfig) {
             ),
         )
     }
+
+    sealed interface Solana {
+
+        data class RentInfo(
+            private val rentInfo: CryptoCurrencyWarning.Rent,
+        ) : Error(
+            title = TextReference.Res(R.string.send_notification_invalid_amount_title),
+            subtitle = TextReference.Res(
+                id = R.string.send_notification_invalid_amount_rent_fee,
+                formatArgs = wrappedList(rentInfo.exemptionAmount),
+            ),
+        )
+    }
 }

common/ui/src/main/java/com/tangem/common/ui/notifications/NotificationsFactory.kt

@@ -42,6 +42,41 @@ object NotificationsFactory {
         }
     }
 
+    fun MutableList<NotificationUM>.addFeeUnreachableNotification(
+        tokenStatus: CryptoCurrencyStatus,
+        coinStatus: CryptoCurrencyStatus,
+        feeError: GetFeeError?,
+        onReload: () -> Unit,
+        onClick: (currency: CryptoCurrency) -> Unit,
+    ) {
+        when (feeError) {
+            is GetFeeError.BlockchainErrors.TronActivationError -> add(
+                NotificationUM.Warning.TronAccountNotActivated(coinStatus.currency.name),
+            )
+            is GetFeeError.BlockchainErrors.KaspaZeroUtxo -> add(
+                NotificationUM.Error.TokenExceedsBalance(
+                    networkIconId = coinStatus.currency.networkIconResId,
+                    networkName = coinStatus.currency.name,
+                    currencyName = tokenStatus.currency.name,
+                    feeName = coinStatus.currency.name,
+                    feeSymbol = coinStatus.currency.symbol,
+                    mergeFeeNetworkName = false,
+                    onClick = {
+                        onClick(coinStatus.currency)
+                    },
+                ),
+            )
+            is GetFeeError.DataError,
+            is GetFeeError.UnknownError,
+            -> add(
+                NotificationUM.Warning.NetworkFeeUnreachable(onReload),
+            )
+            else -> {
+                /* do nothing */
+            }
+        }
+    }
+
     fun MutableList<NotificationUM>.addExceedBalanceNotification(
         feeAmount: BigDecimal,
         sendingAmount: BigDecimal,
@@ -185,7 +220,7 @@ object NotificationsFactory {
         if (dustValue == null) return
         val isExceedsLimit = checkDustLimits(
             feeAmount = feeValue,
-            receivedAmount = sendingAmount,
+            sendingAmount = sendingAmount,
             dustValue = dustValue,
             cryptoCurrencyStatus = cryptoCurrencyStatus,
             feeCurrencyStatus = feeCurrencyStatus,
@@ -345,9 +380,14 @@ object NotificationsFactory {
         }
     }
 
+    fun MutableList<NotificationUM>.addRentExemptionNotification(rentWarning: CryptoCurrencyWarning.Rent?) {
+        if (rentWarning == null) return
+        add(NotificationUM.Solana.RentInfo(rentWarning))
+    }
+
     private fun checkDustLimits(
         feeAmount: BigDecimal,
-        receivedAmount: BigDecimal,
+        sendingAmount: BigDecimal,
         dustValue: BigDecimal,
         cryptoCurrencyStatus: CryptoCurrencyStatus,
         feeCurrencyStatus: CryptoCurrencyStatus?,
@@ -355,7 +395,7 @@ object NotificationsFactory {
         val change = when (cryptoCurrencyStatus.currency) {
             is CryptoCurrency.Coin -> {
                 val balance = cryptoCurrencyStatus.value.amount ?: BigDecimal.ZERO
-                balance - (feeAmount + receivedAmount)
+                balance - (feeAmount + sendingAmount)
             }
             is CryptoCurrency.Token -> {
                 val balance = feeCurrencyStatus?.value?.amount ?: BigDecimal.ZERO
@@ -364,6 +404,9 @@ object NotificationsFactory {
         }
 
         val isChangeLowerThanDust = change < dustValue && change > BigDecimal.ZERO
-        return receivedAmount < dustValue || isChangeLowerThanDust
+        return when (cryptoCurrencyStatus.currency) {
+            is CryptoCurrency.Coin -> sendingAmount < dustValue || isChangeLowerThanDust
+            is CryptoCurrency.Token -> isChangeLowerThanDust
+        }
     }
 }

common/ui/src/main/java/com/tangem/common/ui/tokens/TokenItemStateConverter.kt

@@ -5,10 +5,11 @@ import com.tangem.core.ui.components.currency.icon.converter.CryptoCurrencyToIco
 import com.tangem.core.ui.components.marketprice.PriceChangeType
 import com.tangem.core.ui.components.marketprice.utils.PriceChangeConverter
 import com.tangem.core.ui.components.token.state.TokenItemState
+import com.tangem.core.ui.extensions.stringReference
 import com.tangem.core.ui.format.bigdecimal.crypto
+import com.tangem.core.ui.format.bigdecimal.fiat
 import com.tangem.core.ui.format.bigdecimal.format
 import com.tangem.core.ui.format.bigdecimal.percent
-import com.tangem.core.ui.utils.BigDecimalFormatter
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.staking.model.stakekit.YieldBalance
 import com.tangem.domain.tokens.model.CryptoCurrencyStatus
@@ -36,11 +37,14 @@ class TokenItemStateConverter(
     private val subtitleStateProvider: (CryptoCurrencyStatus) -> TokenItemState.SubtitleState? = {
         createSubtitleState(it, appCurrency)
     },
-    private val fiatAmountStateProvider: (CryptoCurrencyStatus) -> TokenItemState.FiatAmountState? = {
-        createFiatAmountState(it, appCurrency)
+    private val subtitle2StateProvider: (CryptoCurrencyStatus) -> TokenItemState.Subtitle2State? = {
+        createSubtitle2State(currencyStatus = it)
     },
-    private val onItemClick: (CryptoCurrencyStatus) -> Unit,
-    private val onItemLongClick: ((CryptoCurrencyStatus) -> Unit)? = null,
+    private val fiatAmountStateProvider: (CryptoCurrencyStatus) -> TokenItemState.FiatAmountState? = {
+        createFiatAmountState(status = it, appCurrency = appCurrency)
+    },
+    private val onItemClick: ((TokenItemState, CryptoCurrencyStatus) -> Unit)? = null,
+    private val onItemLongClick: ((TokenItemState, CryptoCurrencyStatus) -> Unit)? = null,
 ) : Converter<CryptoCurrencyStatus, TokenItemState> {
 
     override fun convert(value: CryptoCurrencyStatus): TokenItemState {
@@ -74,29 +78,27 @@ class TokenItemStateConverter(
             titleState = titleStateProvider(this),
             subtitleState = requireNotNull(subtitleStateProvider(this)),
             fiatAmountState = requireNotNull(fiatAmountStateProvider(this)),
-            subtitle2State = TokenItemState.Subtitle2State.TextContent(text = getFormattedAmount()),
-            onItemClick = { onItemClick(this) },
-            onItemLongClick = onItemLongClick?.let {
-                { it(this) }
+            subtitle2State = requireNotNull(subtitle2StateProvider(this)),
+            onItemClick = onItemClick?.let { onItemClick ->
+                { onItemClick(it, this) }
+            },
+            onItemLongClick = onItemLongClick?.let { onItemLongClick ->
+                { onItemLongClick(it, this) }
             },
         )
     }
 
-    private fun CryptoCurrencyStatus.getFormattedAmount(): String {
-        val amount = value.amount?.plus(getStakedBalance()) ?: return DASH_SIGN
-
-        return amount.format { crypto(currency) }
-    }
-
     private fun CryptoCurrencyStatus.mapToUnreachableTokenItemState(): TokenItemState.Unreachable {
         return TokenItemState.Unreachable(
             id = currency.id.value,
             iconState = iconStateProvider(this),
             titleState = titleStateProvider(this),
             subtitleState = subtitleStateProvider(this),
-            onItemClick = { onItemClick(this) },
-            onItemLongClick = onItemLongClick?.let {
-                { it(this) }
+            onItemClick = onItemClick?.let { onItemClick ->
+                { onItemClick(it, this) }
+            },
+            onItemLongClick = onItemLongClick?.let { onItemLongClick ->
+                { onItemLongClick(it, this) }
             },
         )
     }
@@ -107,14 +109,45 @@ class TokenItemStateConverter(
             iconState = iconStateProvider(this),
             titleState = titleStateProvider(this),
             subtitleState = subtitleStateProvider(this),
-            onItemLongClick = onItemLongClick?.let {
-                { it(this) }
+            onItemLongClick = onItemLongClick?.let { onItemLongClick ->
+                { onItemLongClick(it, this) }
             },
         )
     }
 
     companion object {
 
+        fun CryptoCurrencyStatus.getFormattedFiatAmount(appCurrency: AppCurrency, includeStaking: Boolean): String {
+            val fiatAmount = value.fiatAmount ?: return DASH_SIGN
+
+            val totalAmount = if (includeStaking) {
+                val fiatYieldBalance = value.fiatRate?.times(getStakedBalance()).orZero()
+
+                fiatAmount.plus(fiatYieldBalance)
+            } else {
+                fiatAmount
+            }
+
+            return totalAmount.format {
+                fiat(fiatCurrencyCode = appCurrency.code, fiatCurrencySymbol = appCurrency.symbol)
+            }
+        }
+
+        fun CryptoCurrencyStatus.getFormattedCryptoAmount(includeStaking: Boolean): String {
+            val cryptoAmount = value.amount ?: return DASH_SIGN
+
+            val totalAmount = if (includeStaking) {
+                cryptoAmount.plus(getStakedBalance())
+            } else {
+                cryptoAmount
+            }
+
+            return totalAmount.format { crypto(currency) }
+        }
+
+        fun CryptoCurrencyStatus.getStakedBalance() =
+            (value.yieldBalance as? YieldBalance.Data)?.getTotalWithRewardsStakingBalance().orZero()
+
         private fun createTitleState(currencyStatus: CryptoCurrencyStatus): TokenItemState.TitleState {
             return when (val value = currencyStatus.value) {
                 is CryptoCurrencyStatus.Loading,
@@ -122,7 +155,7 @@ class TokenItemStateConverter(
                 is CryptoCurrencyStatus.Unreachable,
                 is CryptoCurrencyStatus.NoAmount,
                 -> {
-                    TokenItemState.TitleState.Content(text = currencyStatus.currency.name)
+                    TokenItemState.TitleState.Content(text = stringReference(currencyStatus.currency.name))
                 }
                 is CryptoCurrencyStatus.Loaded,
                 is CryptoCurrencyStatus.Custom,
@@ -130,7 +163,7 @@ class TokenItemStateConverter(
                 is CryptoCurrencyStatus.NoAccount,
                 -> {
                     TokenItemState.TitleState.Content(
-                        text = currencyStatus.currency.name,
+                        text = stringReference(currencyStatus.currency.name),
                         hasPending = value.hasCurrentNetworkTransactions,
                     )
                 }
@@ -155,6 +188,25 @@ class TokenItemStateConverter(
             }
         }
 
+        private fun createSubtitle2State(currencyStatus: CryptoCurrencyStatus): TokenItemState.Subtitle2State? {
+            return when (currencyStatus.value) {
+                is CryptoCurrencyStatus.Loaded,
+                is CryptoCurrencyStatus.Custom,
+                is CryptoCurrencyStatus.NoQuote,
+                is CryptoCurrencyStatus.NoAccount,
+                -> {
+                    TokenItemState.Subtitle2State.TextContent(
+                        text = currencyStatus.getFormattedCryptoAmount(includeStaking = true),
+                    )
+                }
+                is CryptoCurrencyStatus.Loading,
+                is CryptoCurrencyStatus.MissedDerivation,
+                is CryptoCurrencyStatus.Unreachable,
+                is CryptoCurrencyStatus.NoAmount,
+                -> null
+            }
+        }
+
         private fun createFiatAmountState(
             status: CryptoCurrencyStatus,
             appCurrency: AppCurrency,
@@ -166,7 +218,7 @@ class TokenItemStateConverter(
                 is CryptoCurrencyStatus.NoAccount,
                 -> {
                     TokenItemState.FiatAmountState.Content(
-                        text = status.getFormattedFiatAmount(appCurrency),
+                        text = status.getFormattedFiatAmount(appCurrency = appCurrency, includeStaking = true),
                         hasStaked = !status.getStakedBalance().isZero(),
                     )
                 }
@@ -194,25 +246,13 @@ class TokenItemStateConverter(
         }
 
         private fun BigDecimal.getFormattedCryptoPrice(appCurrency: AppCurrency): String {
-            return BigDecimalFormatter.formatFiatAmountUncapped(
-                fiatAmount = this,
-                fiatCurrencyCode = appCurrency.code,
-                fiatCurrencySymbol = appCurrency.symbol,
-            )
+            return format {
+                fiat(fiatCurrencyCode = appCurrency.code, fiatCurrencySymbol = appCurrency.symbol)
+            }
         }
 
         private fun BigDecimal.getPriceChangeType(): PriceChangeType {
             return PriceChangeConverter.fromBigDecimal(value = this)
         }
-
-        fun CryptoCurrencyStatus.getFormattedFiatAmount(appCurrency: AppCurrency): String {
-            val fiatYieldBalance = value.fiatRate?.times(getStakedBalance()).orZero()
-            val fiatAmount = value.fiatAmount?.plus(fiatYieldBalance) ?: return DASH_SIGN
-
-            return BigDecimalFormatter.formatFiatAmount(fiatAmount, appCurrency.code, appCurrency.symbol)
-        }
-
-        private fun CryptoCurrencyStatus.getStakedBalance() =
-            (value.yieldBalance as? YieldBalance.Data)?.getTotalWithRewardsStakingBalance().orZero()
     }
 }

core/analytics/models/src/main/java/com/tangem/core/analytics/models/AnalyticsParam.kt

@@ -76,6 +76,9 @@ sealed class AnalyticsParam {
         data object MyWallets : ScreensSources("My Wallets")
         data object Token : ScreensSources("Token")
         data object Stories : ScreensSources("Stories")
+        data object Buy : ScreensSources("Buy")
+        data object Swap : ScreensSources("Swap")
+        data object Sell : ScreensSources("Sell")
     }
 
     sealed class TxSentFrom(val value: String) {
@@ -161,11 +164,18 @@ sealed class AnalyticsParam {
         }
     }
 
+    enum class Status(val value: String) {
+        Success(value = "Success"),
+        Error(value = "Error"),
+        Pending(value = "Pending"),
+    }
+
     companion object Key {
         const val BLOCKCHAIN = "blockchain"
         const val TOKEN_PARAM = "Token"
         const val SOURCE = "Source"
         const val BALANCE = "Balance"
+        const val TOKENS_COUNT = "Tokens Count"
         const val STATE = "State"
         const val BATCH = "Batch"
         const val TYPE = "Type"
@@ -190,12 +200,10 @@ sealed class AnalyticsParam {
         const val INPUT = "Input"
         const val COUNT = "Count"
         const val DERIVATION = "Derivation"
-
-        // region swap
-        const val TOKEN_CATEGORY = "Token"
         const val STATUS = "Status"
         const val PROVIDER = "Provider"
         const val PLACE = "Place"
-        //
+        const val RESIDENCE = "Residence"
+        const val PAYMENT_METHOD = "Payment Method"
     }
 }

core/analytics/models/src/main/java/com/tangem/core/analytics/models/event/MainScreenAnalyticsEvent.kt

@@ -0,0 +1,75 @@
+package com.tangem.core.analytics.models.event
+
+import com.tangem.core.analytics.models.AnalyticsEvent
+import com.tangem.core.analytics.models.AnalyticsParam
+import com.tangem.core.analytics.models.AnalyticsParam.Key.TOKEN_PARAM
+
+/**
+ * Main screen analytics event
+ *
+ * @param event  event name
+ * @param params params
+ */
+sealed class MainScreenAnalyticsEvent(
+    event: String,
+    params: Map<String, String> = mapOf(),
+) : AnalyticsEvent(category = "Main Screen", event = event, params = params) {
+
+    class EnableBiometrics(state: AnalyticsParam.OnOffState) : MainScreenAnalyticsEvent(
+        event = "Enable Biometric",
+        params = mapOf("State" to state.value),
+    )
+
+    // region Action Buttons feature
+    data class ButtonBuy(val status: AnalyticsParam.Status) : MainScreenAnalyticsEvent(
+        event = "Button - Buy",
+        params = mapOf(AnalyticsParam.STATUS to status.value),
+    )
+
+    data class ButtonSwap(val status: AnalyticsParam.Status) : MainScreenAnalyticsEvent(
+        event = "Button - Swap",
+        params = mapOf(AnalyticsParam.STATUS to status.value),
+    )
+
+    data class ButtonSell(val status: AnalyticsParam.Status) : MainScreenAnalyticsEvent(
+        event = "Button - Sell",
+        params = mapOf(AnalyticsParam.STATUS to status.value),
+    )
+
+    data object BuyScreenOpened : MainScreenAnalyticsEvent(event = "Buy Screen Opened")
+
+    data object SwapScreenOpened : MainScreenAnalyticsEvent(event = "Swap Screen Opened")
+
+    data object SellScreenOpened : MainScreenAnalyticsEvent(event = "Sell Screen Opened")
+
+    data class BuyTokenClicked(val currencySymbol: String) : MainScreenAnalyticsEvent(
+        event = "Buy Token Clicked",
+        params = mapOf(TOKEN_PARAM to currencySymbol),
+    )
+
+    data class SellTokenClicked(val currencySymbol: String) : MainScreenAnalyticsEvent(
+        event = "Sell Token Clicked",
+        params = mapOf(TOKEN_PARAM to currencySymbol),
+    )
+
+    data class SwapTokenClicked(val currencySymbol: String) : MainScreenAnalyticsEvent(
+        event = "Swap Token Clicked",
+        params = mapOf(TOKEN_PARAM to currencySymbol),
+    )
+
+    data class ReceiveTokenClicked(val currencySymbol: String) : MainScreenAnalyticsEvent(
+        event = "Receive Token Clicked",
+        params = mapOf(TOKEN_PARAM to currencySymbol),
+    )
+
+    data class RemoveTokenClicked(val currencySymbol: String) : MainScreenAnalyticsEvent(
+        event = "Remove Button Clicked",
+        params = mapOf(TOKEN_PARAM to currencySymbol),
+    )
+
+    data class ButtonClose(val source: AnalyticsParam.ScreensSources) : MainScreenAnalyticsEvent(
+        event = "Button - Close",
+        params = mapOf(AnalyticsParam.SOURCE to source.value),
+    )
+    // endregion
+}

core/config-toggles/.gitignore

@@ -0,0 +1 @@
+/build

core/config-toggles/build.gradle.kts

@@ -7,7 +7,7 @@ plugins {
 }
 
 android {
-    namespace = "com.tangem.core.featuretoggles"
+    namespace = "com.tangem.core.configtoggle"
 }
 
 dependencies {

core/config-toggles/src/main/assets/configs/excluded_blockchains_config.json

@@ -0,0 +1,14 @@
+[
+    {
+        "name": "",
+        "version": "undefined"
+    },
+    {
+        "name": "NEXA",
+        "version": "undefined"
+    },
+    {
+        "name": "clore-ai",
+        "version": "undefined"
+    }
+]

core/config-toggles/src/main/assets/configs/feature_toggles_config.json

@@ -7,10 +7,6 @@
         "name": "WC_SOLANA_TX_SIGN_ENABLED",
         "version": "5.18.0"
     },
-    {
-        "name": "STAKING_ENABLED",
-        "version": "5.15.0"
-    },
     {
         "name": "IS_ETHEREUM_EIP_1559_ENABLED",
         "version": "5.17.0"
@@ -21,11 +17,11 @@
     },
     {
         "name": "ONRAMP_ENABLED",
-        "version": "undefined"
+        "version": "5.19.0"
     },
     {
         "name": "MAIN_ACTION_BUTTONS_ENABLED",
-        "version": "undefined"
+        "version": "5.19.0"
     },
     {
         "name": "ONBOARDING_CODE_REFACTORING_ENABLED",

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/blockchain/ExcludedBlockchainsManager.kt

@@ -0,0 +1,8 @@
+package com.tangem.core.configtoggle.blockchain
+
+interface ExcludedBlockchainsManager {
+
+    val excludedBlockchainsIds: Set<String>
+
+    suspend fun init()
+}

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/blockchain/MutableExcludedBlockchainsManager.kt

@@ -0,0 +1,10 @@
+package com.tangem.core.configtoggle.blockchain
+
+interface MutableExcludedBlockchainsManager : ExcludedBlockchainsManager {
+
+    suspend fun excludeBlockchain(mainnetId: String, isExcluded: Boolean)
+
+    fun isMatchLocalConfig(): Boolean
+
+    suspend fun recoverLocalConfig()
+}

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/blockchain/impl/DefaultExcludedBlockchainsManager.kt

@@ -0,0 +1,78 @@
+package com.tangem.core.configtoggle.blockchain.impl
+
+import com.tangem.core.configtoggle.blockchain.MutableExcludedBlockchainsManager
+import com.tangem.core.configtoggle.storage.TogglesStorage
+import com.tangem.core.configtoggle.utils.associateToggles
+import com.tangem.core.configtoggle.version.VersionProvider
+import com.tangem.datasource.local.preferences.AppPreferencesStore
+import com.tangem.datasource.local.preferences.PreferencesKeys
+import com.tangem.datasource.local.preferences.utils.getSyncOrDefault
+import com.tangem.datasource.local.preferences.utils.store
+
+internal class DefaultExcludedBlockchainsManager(
+    private val localTogglesStorage: TogglesStorage,
+    private val appPreferencesStore: AppPreferencesStore,
+    private val versionProvider: VersionProvider,
+) : MutableExcludedBlockchainsManager {
+
+    private var isInitialized: Boolean = false
+
+    private lateinit var currentExcludedBlockchainsIds: Set<String>
+    private lateinit var localExcludedBlockchainsIds: Set<String>
+
+    override val excludedBlockchainsIds: Set<String>
+        get() {
+            if (!isInitialized) error("ExcludedBlockchainsManager is not initialized")
+
+            return currentExcludedBlockchainsIds
+        }
+
+    override suspend fun init() {
+        localTogglesStorage.populate(path = "configs/excluded_blockchains_config")
+
+        val storedExcludedBlockchainsIds = appPreferencesStore.getSyncOrDefault(
+            key = PreferencesKeys.EXCLUDED_BLOCKCHAINS_KEY,
+            default = emptySet(),
+        )
+
+        localExcludedBlockchainsIds = localTogglesStorage.toggles
+            .associateToggles(currentVersion = versionProvider.get().orEmpty())
+            .filterValues { isIncluded -> !isIncluded }
+            .keys
+
+        if (storedExcludedBlockchainsIds.isEmpty()) {
+            recoverLocalConfig()
+        } else {
+            currentExcludedBlockchainsIds = storedExcludedBlockchainsIds
+        }
+
+        isInitialized = true
+    }
+
+    override suspend fun excludeBlockchain(mainnetId: String, isExcluded: Boolean) {
+        if (isExcluded) {
+            currentExcludedBlockchainsIds += mainnetId
+        } else {
+            currentExcludedBlockchainsIds -= mainnetId
+        }
+
+        storeCurrent()
+    }
+
+    override fun isMatchLocalConfig(): Boolean {
+        return currentExcludedBlockchainsIds == localExcludedBlockchainsIds
+    }
+
+    override suspend fun recoverLocalConfig() {
+        currentExcludedBlockchainsIds = localExcludedBlockchainsIds
+
+        storeCurrent()
+    }
+
+    private suspend fun storeCurrent() {
+        appPreferencesStore.store(
+            PreferencesKeys.EXCLUDED_BLOCKCHAINS_KEY,
+            currentExcludedBlockchainsIds,
+        )
+    }
+}

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/di/ExcludedBlockchainsManagerModule.kt

@@ -0,0 +1,49 @@
+package com.tangem.core.configtoggle.di
+
+import android.content.Context
+import com.tangem.core.configtoggle.BuildConfig
+import com.tangem.core.configtoggle.blockchain.ExcludedBlockchainsManager
+import com.tangem.core.configtoggle.blockchain.MutableExcludedBlockchainsManager
+import com.tangem.core.configtoggle.blockchain.impl.DefaultExcludedBlockchainsManager
+import com.tangem.core.configtoggle.storage.LocalTogglesStorage
+import com.tangem.core.configtoggle.version.DefaultVersionProvider
+import com.tangem.datasource.asset.loader.AssetLoader
+import com.tangem.datasource.local.preferences.AppPreferencesStore
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object ExcludedBlockchainsManagerModule {
+
+    @Provides
+    @Singleton
+    fun provideExcludedBlockchainsManager(
+        @ApplicationContext context: Context,
+        assetLoader: AssetLoader,
+        appPreferencesStore: AppPreferencesStore,
+    ): ExcludedBlockchainsManager {
+        val localTogglesStorage = LocalTogglesStorage(assetLoader)
+        val versionProvider = DefaultVersionProvider(context)
+
+        return DefaultExcludedBlockchainsManager(
+            localTogglesStorage,
+            appPreferencesStore,
+            versionProvider,
+        )
+    }
+
+    @Provides
+    @Singleton
+    fun provideMutableExcludedBlockchainsManager(
+        manager: ExcludedBlockchainsManager,
+    ): MutableExcludedBlockchainsManager? {
+        if (!BuildConfig.TESTER_MENU_ENABLED) return null
+
+        return manager as MutableExcludedBlockchainsManager
+    }
+}

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/di/FeatureTogglesManagerModule.kt

@@ -1,12 +1,12 @@
-package com.tangem.core.featuretoggle.di
+package com.tangem.core.configtoggle.di
 
 import android.content.Context
-import com.tangem.core.featuretoggle.manager.DevFeatureTogglesManager
-import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
-import com.tangem.core.featuretoggle.manager.ProdFeatureTogglesManager
-import com.tangem.core.featuretoggle.storage.LocalFeatureTogglesStorage
-import com.tangem.core.featuretoggle.version.DefaultVersionProvider
-import com.tangem.core.featuretoggles.BuildConfig
+import com.tangem.core.configtoggle.BuildConfig
+import com.tangem.core.configtoggle.feature.FeatureTogglesManager
+import com.tangem.core.configtoggle.feature.impl.DevFeatureTogglesManager
+import com.tangem.core.configtoggle.feature.impl.ProdFeatureTogglesManager
+import com.tangem.core.configtoggle.storage.LocalTogglesStorage
+import com.tangem.core.configtoggle.version.DefaultVersionProvider
 import com.tangem.datasource.asset.loader.AssetLoader
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import dagger.Module
@@ -27,18 +27,18 @@ internal object FeatureTogglesManagerModule {
         assetLoader: AssetLoader,
         appPreferencesStore: AppPreferencesStore,
     ): FeatureTogglesManager {
-        val localFeatureTogglesStorage = LocalFeatureTogglesStorage(assetLoader)
+        val localTogglesStorage = LocalTogglesStorage(assetLoader)
         val versionProvider = DefaultVersionProvider(context)
 
         return if (BuildConfig.TESTER_MENU_ENABLED) {
             DevFeatureTogglesManager(
-                localFeatureTogglesStorage = localFeatureTogglesStorage,
+                localTogglesStorage = localTogglesStorage,
                 appPreferencesStore = appPreferencesStore,
                 versionProvider = versionProvider,
             )
         } else {
             ProdFeatureTogglesManager(
-                localFeatureTogglesStorage = localFeatureTogglesStorage,
+                localTogglesStorage = localTogglesStorage,
                 versionProvider = versionProvider,
             )
         }

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/feature/FeatureTogglesManager.kt

@@ -1,4 +1,4 @@
-package com.tangem.core.featuretoggle.manager
+package com.tangem.core.configtoggle.feature
 
 /**
  * Component for getting information about the availability of feature toggles

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/feature/MutableFeatureTogglesManager.kt

@@ -1,4 +1,4 @@
-package com.tangem.core.featuretoggle.manager
+package com.tangem.core.configtoggle.feature
 
 /**
  * Component for change information about the availability of feature toggles

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/feature/impl/DevFeatureTogglesManager.kt

@@ -1,9 +1,10 @@
-package com.tangem.core.featuretoggle.manager
+package com.tangem.core.configtoggle.feature.impl
 
 import androidx.annotation.VisibleForTesting
-import com.tangem.core.featuretoggle.storage.FeatureTogglesStorage
-import com.tangem.core.featuretoggle.utils.associateToggles
-import com.tangem.core.featuretoggle.version.VersionProvider
+import com.tangem.core.configtoggle.feature.MutableFeatureTogglesManager
+import com.tangem.core.configtoggle.storage.TogglesStorage
+import com.tangem.core.configtoggle.utils.associateToggles
+import com.tangem.core.configtoggle.version.VersionProvider
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.datasource.local.preferences.PreferencesKeys
 import com.tangem.datasource.local.preferences.utils.getObjectSyncOrNull
@@ -13,12 +14,12 @@ import kotlin.properties.Delegates
 /**
  * Feature toggles manager implementation in DEV build
  *
- * @property localFeatureTogglesStorage local feature toggles storage
+ * @property localTogglesStorage local feature toggles storage
  * @property appPreferencesStore        application local store
  * @property versionProvider            application version provider
  */
 internal class DevFeatureTogglesManager(
-    private val localFeatureTogglesStorage: FeatureTogglesStorage,
+    private val localTogglesStorage: TogglesStorage,
     private val appPreferencesStore: AppPreferencesStore,
     private val versionProvider: VersionProvider,
 ) : MutableFeatureTogglesManager {
@@ -27,13 +28,13 @@ internal class DevFeatureTogglesManager(
     private var localFeatureTogglesMap: Map<String, Boolean> by Delegates.notNull()
 
     override suspend fun init() {
-        localFeatureTogglesStorage.init()
+        localTogglesStorage.populate(FeatureTogglesConstants.LOCAL_CONFIG_PATH)
 
         val savedFeatureToggles = appPreferencesStore.getObjectSyncOrNull<Map<String, Boolean>>(
             key = PreferencesKeys.FEATURE_TOGGLES_KEY,
         ) ?: emptyMap()
 
-        val localFeatureToggles = localFeatureTogglesStorage.featureToggles
+        val localFeatureToggles = localTogglesStorage.toggles
             .associateToggles(currentVersion = versionProvider.get().orEmpty())
 
         localFeatureTogglesMap = localFeatureToggles

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/feature/impl/FeatureTogglesConstants.kt

@@ -0,0 +1,6 @@
+package com.tangem.core.configtoggle.feature.impl
+
+internal object FeatureTogglesConstants {
+
+    const val LOCAL_CONFIG_PATH: String = "configs/feature_toggles_config"
+}

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/feature/impl/ProdFeatureTogglesManager.kt

@@ -1,27 +1,28 @@
-package com.tangem.core.featuretoggle.manager
+package com.tangem.core.configtoggle.feature.impl
 
 import androidx.annotation.VisibleForTesting
-import com.tangem.core.featuretoggle.storage.FeatureTogglesStorage
-import com.tangem.core.featuretoggle.utils.associateToggles
-import com.tangem.core.featuretoggle.version.VersionProvider
+import com.tangem.core.configtoggle.feature.FeatureTogglesManager
+import com.tangem.core.configtoggle.storage.TogglesStorage
+import com.tangem.core.configtoggle.utils.associateToggles
+import com.tangem.core.configtoggle.version.VersionProvider
 import kotlin.properties.Delegates
 
 /**
  * Feature toggles manager implementation in PROD build
  *
- * @property localFeatureTogglesStorage local feature toggles storage
+ * @property localTogglesStorage local feature toggles storage
  * @property versionProvider            application version provider
  */
 internal class ProdFeatureTogglesManager(
-    private val localFeatureTogglesStorage: FeatureTogglesStorage,
+    private val localTogglesStorage: TogglesStorage,
     private val versionProvider: VersionProvider,
 ) : FeatureTogglesManager {
 
     private var featureToggles: Map<String, Boolean> by Delegates.notNull()
 
     override suspend fun init() {
-        localFeatureTogglesStorage.init()
-        featureToggles = localFeatureTogglesStorage.featureToggles
+        localTogglesStorage.populate(FeatureTogglesConstants.LOCAL_CONFIG_PATH)
+        featureToggles = localTogglesStorage.toggles
             .associateToggles(currentVersion = versionProvider.get() ?: "")
     }
 

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/storage/ConfigToggle.kt

@@ -0,0 +1,20 @@
+package com.tangem.core.configtoggle.storage
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+/**
+ * Data model with information about config toggle
+ *
+ * @property name    toggle name
+ * @property version version in which the toggle will be enabled
+ *
+ * IMPORTANT: if the version is "undefined", it means that toggle is disabled!
+ *
+[REDACTED_AUTHOR]
+ */
+@JsonClass(generateAdapter = true)
+internal data class ConfigToggle(
+    @Json(name = "name") val name: String,
+    @Json(name = "version") val version: String,
+)

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/storage/LocalTogglesStorage.kt

@@ -0,0 +1,24 @@
+package com.tangem.core.configtoggle.storage
+
+import com.tangem.datasource.asset.loader.AssetLoader
+import kotlin.properties.Delegates
+
+/**
+ * Storage implementation for storing local feature toggles.
+ * Feature toggles are declared in file [LOCAL_CONFIG_PATH].
+ *
+ * @property assetLoader asset loader
+ *
+[REDACTED_AUTHOR]
+ */
+internal class LocalTogglesStorage(
+    private val assetLoader: AssetLoader,
+) : TogglesStorage {
+
+    override var toggles: List<ConfigToggle> by Delegates.notNull()
+        private set
+
+    override suspend fun populate(path: String) {
+        toggles = assetLoader.loadList<ConfigToggle>(path)
+    }
+}

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/storage/TogglesStorage.kt

@@ -0,0 +1,15 @@
+package com.tangem.core.configtoggle.storage
+
+/**
+ * Component that initializes and stores a list of feature toggles
+ *
+[REDACTED_AUTHOR]
+ */
+internal interface TogglesStorage {
+
+    /** List of feature toggles */
+    val toggles: List<ConfigToggle>
+
+    /** Populate the storage with toggles */
+    suspend fun populate(path: String)
+}

core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/utils/CollectionExt.kt

@@ -0,0 +1,13 @@
+package com.tangem.core.configtoggle.utils
+
+import com.tangem.core.configtoggle.storage.ConfigToggle
+import com.tangem.core.configtoggle.version.VersionAvailabilityContract
+
+internal fun List<ConfigToggle>.associateToggles(currentVersion: String): Map<String, Boolean> {
+    return associate { localToggle ->
+        Pair(
+            first = localToggle.name,
+            second = VersionAvailabilityContract(currentVersion, localToggle.version),
+        )
+    }
+}