Updated on 2026-08-14

2024-11-14 11:03:01 +03:00 · 2024-11-14 11:03:01 +03:00 · 00805c1380
commit 00805c1380
parent 11acf5179b 6c641b3655
268 changed files with 6515 additions and 1380 deletions
--- a/app/src/main/java/com/tangem/tap/MainActivity.kt
+++ b/app/src/main/java/com/tangem/tap/MainActivity.kt
@ -52,6 +52,7 @@ 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
@ -59,6 +60,7 @@ 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.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
@ -185,6 +187,12 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
    @Inject
    lateinit var shouldInitiallyAskPermissionUseCase: ShouldInitiallyAskPermissionUseCase

+    @Inject
+    lateinit var backupServiceHolder: BackupServiceHolder
+
+    @Inject
+    lateinit var onboardingV2FeatureToggles: OnboardingV2FeatureToggles
+
    internal val viewModel: MainViewModel by viewModels()

    private lateinit var appThemeModeFlow: SharedFlow<AppThemeMode>
@ -294,7 +302,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,
@ -550,6 +565,7 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
            }
        }

+        // TODO add onboarding v2 handling
        store.dispatch(BackupAction.CheckForUnfinishedBackup)
    }

--- a/app/src/main/java/com/tangem/tap/common/redux/global/GlobalMiddleware.kt
+++ b/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)
--- a/app/src/main/java/com/tangem/tap/di/ActivityModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/ActivityModule.kt
@ -1,5 +1,6 @@
 package com.tangem.tap.di

+import com.tangem.datasource.exchangeservice.swap.SwapServiceLoader
 import com.tangem.domain.card.ScanCardUseCase
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.exchange.RampStateManager
@ -10,6 +11,8 @@ 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 +42,18 @@ internal object ActivityModule {

    @Provides
    @Singleton
-    fun provideDefaultRampManager(appStateHolder: AppStateHolder): RampStateManager {
-        return DefaultRampManager(appStateHolder.exchangeService)
+    fun provideDefaultRampManager(
+        appStateHolder: AppStateHolder,
+        swapServiceLoader: SwapServiceLoader,
+        dispatchers: CoroutineDispatcherProvider,
+    ): RampStateManager {
+        return DefaultRampManager(
+            exchangeService = appStateHolder.exchangeService,
+            buyService = Provider { requireNotNull(appStateHolder.buyService) },
+            sellService = Provider { requireNotNull(appStateHolder.sellService) },
+            swapServiceLoader = swapServiceLoader,
+            dispatchers = dispatchers,
+        )
    }

    @Provides
--- a/app/src/main/java/com/tangem/tap/di/TangemSdkModule.kt
+++ b/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()
+}
--- a/app/src/main/java/com/tangem/tap/di/domain/OnrampDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/OnrampDomainModule.kt
@ -0,0 +1,50 @@
+package com.tangem.tap.di.domain
+
+import com.tangem.domain.onramp.*
+import com.tangem.domain.onramp.repositories.OnrampRepository
+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 OnrampDomainModule {
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampCurrenciesUseCase(onrampRepository: OnrampRepository): GetOnrampCurrenciesUseCase {
+        return GetOnrampCurrenciesUseCase(onrampRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideOnrampSaveDefaultCurrencyUseCase(onrampRepository: OnrampRepository): OnrampSaveDefaultCurrencyUseCase {
+        return OnrampSaveDefaultCurrencyUseCase(onrampRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampCountriesUseCase(onrampRepository: OnrampRepository): GetOnrampCountriesUseCase {
+        return GetOnrampCountriesUseCase(onrampRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideGetOnrampCountryUseCase(onrampRepository: OnrampRepository): GetOnrampCountryUseCase {
+        return GetOnrampCountryUseCase(onrampRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideOnrampSaveDefaultCountryUseCase(onrampRepository: OnrampRepository): OnrampSaveDefaultCountryUseCase {
+        return OnrampSaveDefaultCountryUseCase(onrampRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideCheckOnrampAvailabilityUseCase(onrampRepository: OnrampRepository): CheckOnrampAvailabilityUseCase {
+        return CheckOnrampAvailabilityUseCase(onrampRepository)
+    }
+}
--- a/app/src/main/java/com/tangem/tap/di/domain/SwapDomainModule.kt
+++ b/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)
+    }
+}
--- a/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
@ -7,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,
        )
    }
--- a/app/src/main/java/com/tangem/tap/features/main/MainViewModel.kt
+++ b/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()
    }
--- a/app/src/main/java/com/tangem/tap/features/onboarding/OnboardingHelper.kt
+++ b/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
@ -67,7 +68,10 @@ object OnboardingHelper {

    fun whereToNavigate(scanResponse: ScanResponse): AppRoute {
        if (store.inject(DaggerGraphState::onboardingV2FeatureToggles).isOnboardingV2Enabled) {
-            return AppRoute.Onboarding(scanResponse)
+            return AppRoute.Onboarding(
+                scanResponse = scanResponse,
+                startFromBackup = false,
+            )
        }

        return when (val type = scanResponse.productType) {
@ -88,6 +92,7 @@ object OnboardingHelper {
    }

    fun saveWallet(
+        alreadyCreatedWallet: UserWallet?,
        scanResponse: ScanResponse,
        accessCode: String? = null,
        backupCardsIds: List<String>? = null,
@ -117,7 +122,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 +136,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)
                }
            }
        }
@ -242,9 +247,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()
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletMiddleware.kt
@ -196,11 +196,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)
@ -208,6 +208,7 @@ private fun handleFinishBackup(scanResponse: ScanResponse) {
    }

    OnboardingHelper.saveWallet(
+        alreadyCreatedWallet = userWallet,
        scanResponse = updatedScanResponse,
        accessCode = backupState.accessCode,
        backupCardsIds = backupState.backupCardIds,
@ -667,7 +668,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))
            }
@ -728,6 +729,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" },
    )
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/TradeCryptoMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/TradeCryptoMiddleware.kt
@ -55,11 +55,15 @@ 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.cryptoCurrencyStatus.currency)
+        } else {
+            proceedWithLegacyBuyAction(state, action)
+        }
    }

-    private fun proceedWithOnramp() {
-        store.dispatchNavigationAction { push(AppRoute.Onramp) }
+    private fun proceedWithOnramp(cryptoCurrency: CryptoCurrency) {
+        store.dispatchNavigationAction { push(AppRoute.Onramp(cryptoCurrency)) }
    }

    private fun proceedWithLegacyBuyAction(state: () -> AppState?, action: TradeCryptoAction.Buy) {
--- a/app/src/main/java/com/tangem/tap/network/exchangeServices/CurrencyExchangeManager.kt
+++ b/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,19 @@ 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() {
+        _initializationStatus.value = lceLoading()
+
        buyService.update()
        sellService.update()
+
+        _initializationStatus.value = lceContent()
    }

    override fun isBuyAllowed(): Boolean = primaryRules.isBuyAllowed() && buyService.isBuyAllowed()
--- a/app/src/main/java/com/tangem/tap/network/exchangeServices/DefaultRampManager.kt
+++ b/app/src/main/java/com/tangem/tap/network/exchangeServices/DefaultRampManager.kt
@ -1,15 +1,29 @@
 package com.tangem.tap.network.exchangeServices

+import com.tangem.datasource.api.express.models.TangemExpressValues.EMPTY_CONTRACT_ADDRESS_VALUE
+import com.tangem.datasource.exchangeservice.swap.SwapServiceLoader
 import com.tangem.domain.exchange.RampStateManager
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.tokens.model.CryptoCurrency
+import com.tangem.domain.wallets.models.UserWalletId
+import com.tangem.utils.Provider
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext

-class DefaultRampManager(private val exchangeService: ExchangeService?) : RampStateManager {
+internal class DefaultRampManager(
+    private val exchangeService: ExchangeService?,
+    private val buyService: Provider<ExchangeService>,
+    private val sellService: Provider<ExchangeService>,
+    private val swapServiceLoader: SwapServiceLoader,
+    private val dispatchers: CoroutineDispatcherProvider,
+) : RampStateManager {

    private val cryptoCurrencyConverter = CryptoCurrencyConverter()
+
    override fun availableForBuy(scanResponse: ScanResponse, cryptoCurrency: CryptoCurrency): Boolean {
        return exchangeService?.availableForBuy(
-            scanResponse,
+            scanResponse = scanResponse,
            currency = cryptoCurrencyConverter.convertBack(cryptoCurrency),
        ) ?: false
    }
@ -19,4 +33,46 @@ class DefaultRampManager(private val exchangeService: ExchangeService?) : RampSt
            currency = cryptoCurrencyConverter.convertBack(cryptoCurrency),
        ) ?: false
    }
+
+    override suspend fun availableForSwap(userWalletId: UserWalletId, cryptoCurrency: CryptoCurrency): Boolean {
+        return getExchangeableFlag(userWalletId, cryptoCurrency) && !cryptoCurrency.isCustom
+    }
+
+    override fun getBuyInitializationStatus(): Flow<ExchangeServiceInitializationStatus> {
+        return buyService.invoke().initializationStatus
+    }
+
+    override suspend fun fetchBuyServiceData() {
+        withContext(dispatchers.io) {
+            buyService.invoke().update()
+        }
+    }
+
+    override fun getSellInitializationStatus(): Flow<ExchangeServiceInitializationStatus> {
+        return sellService.invoke().initializationStatus
+    }
+
+    override suspend fun fetchSellServiceData() {
+        withContext(dispatchers.io) {
+            sellService.invoke().update()
+        }
+    }
+
+    override fun getSwapInitializationStatus(userWalletId: UserWalletId): Flow<ExchangeServiceInitializationStatus> {
+        return swapServiceLoader.getInitializationStatus(userWalletId)
+    }
+
+    private suspend fun getExchangeableFlag(userWalletId: UserWalletId, cryptoCurrency: CryptoCurrency): Boolean {
+        return withContext(dispatchers.io) {
+            val contractAddress = (cryptoCurrency as? CryptoCurrency.Token)?.contractAddress
+                ?: EMPTY_CONTRACT_ADDRESS_VALUE
+
+            val asset = swapServiceLoader.getInitializationStatus(userWalletId).value.getOrNull()?.find {
+                it.network == cryptoCurrency.network.backendId &&
+                    it.contractAddress.equals(contractAddress, ignoreCase = true)
+            }
+
+            asset?.exchangeAvailable ?: false
+        }
+    }
 }
--- a/app/src/main/java/com/tangem/tap/network/exchangeServices/ExchangeService.kt
+++ b/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
--- a/app/src/main/java/com/tangem/tap/network/exchangeServices/mercuryo/MercuryoBlockchainMapping.kt
+++ b/app/src/main/java/com/tangem/tap/network/exchangeServices/mercuryo/MercuryoBlockchainMapping.kt
@ -138,6 +138,8 @@ 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
--- a/app/src/main/java/com/tangem/tap/network/exchangeServices/mercuryo/MercuryoService.kt
+++ b/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()
--- a/app/src/main/java/com/tangem/tap/network/exchangeServices/moonpay/MoonPayService.kt
+++ b/app/src/main/java/com/tangem/tap/network/exchangeServices/moonpay/MoonPayService.kt
@ -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)
            }
        }
--- a/app/src/main/java/com/tangem/tap/network/exchangeServices/moonpay/MoonpayBlockchainMapping.kt
+++ b/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,6 +140,7 @@ internal val Blockchain.moonPaySupportedCurrency: MoonPaySupportedCurrency?
        Casper -> null
        CasperTestnet -> null
        CoreTestnet -> null
+        ChilizTestnet -> null
        Unknown -> null
        Xodex -> null
        Canxium -> null
--- a/app/src/main/java/com/tangem/tap/proxy/AppStateHolder.kt
+++ b/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)
--- a/app/src/main/java/com/tangem/tap/routing/impl/DefaultRoutingComponent.kt
+++ b/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,
--- a/app/src/main/java/com/tangem/tap/routing/utils/ChildFactory.kt
+++ b/app/src/main/java/com/tangem/tap/routing/utils/ChildFactory.kt
@ -11,10 +11,11 @@ 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.BuyCryptoComponent
 import com.tangem.features.onramp.component.OnrampComponent
 import com.tangem.features.onramp.component.SellCryptoComponent
+import com.tangem.features.onramp.component.SwapSelectTokensComponent
 import com.tangem.features.pushnotifications.api.navigation.PushNotificationsRouter
 import com.tangem.features.send.api.navigation.SendRouter
 import com.tangem.features.staking.api.navigation.StakingRouter
@ -53,6 +54,7 @@ internal class ChildFactory @Inject constructor(
    private val onrampComponentFactory: OnrampComponent.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,7 +199,7 @@ internal class ChildFactory @Inject constructor(
            is AppRoute.Onramp -> {
                route.asComponentChild(
                    contextProvider = contextProvider(route, contextFactory),
-                    params = OnrampComponent.Params(),
+                    params = OnrampComponent.Params(route.currency.name),
                    componentFactory = onrampComponentFactory,
                )
            }
@ -215,10 +217,20 @@ 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,
+                    ),
                    componentFactory = onboardingEntryComponentFactory,
                )
            }