Updated on 2026-08-14

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

@@ -1,5 +1,6 @@
 package com.tangem.tap.features.details.redux.walletconnect
 
+import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.tap.domain.walletconnect2.domain.WcPreparedRequest
 import com.tangem.tap.domain.walletconnect2.domain.models.WalletConnectError
 import com.tangem.tap.domain.walletconnect2.domain.models.WalletConnectEvents
@@ -14,6 +15,7 @@ sealed class WalletConnectAction : Action {
     data class OpenSession(
         val wcUri: String,
         val source: SourceType,
+        val userWalletId: UserWalletId,
     ) : WalletConnectAction() {
         enum class SourceType { QR, DEEPLINK, CLIPBOARD, ETC }
     }

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

@@ -63,7 +63,11 @@ class WalletConnectMiddleware {
             is WalletConnectAction.OpenSession -> {
                 val index = action.wcUri.indexOf("@")
                 when (action.wcUri[index + 1]) {
-                    '2' -> walletConnectRepository.pair(uri = action.wcUri, source = action.source)
+                    '2' -> walletConnectRepository.pair(
+                        uri = action.wcUri,
+                        source = action.source,
+                        userWalletId = action.userWalletId,
+                    )
                     '1' -> {
                         store.dispatchOnMain(WalletConnectAction.UnsupportedDappRequest)
                         store.dispatchOnMain(

app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/DefaultWalletConnectComponent.kt

@@ -22,10 +22,10 @@ import org.rekotlin.StoreSubscriber
 @Suppress("UnusedPrivateMember")
 internal class DefaultWalletConnectComponent @AssistedInject constructor(
     @Assisted appComponentContext: AppComponentContext,
-    @Assisted params: Unit,
+    @Assisted params: WalletConnectComponent.Params,
 ) : WalletConnectComponent, AppComponentContext by appComponentContext, StoreSubscriber<WalletConnectState> {
 
-    private val model: WalletConnectModel = getOrCreateModel()
+    private val model: WalletConnectModel = getOrCreateModel(params)
 
     private var screenState: MutableState<WalletConnectScreenState> =
         mutableStateOf(model.updateState(store.state.walletConnectState))
@@ -65,6 +65,9 @@ internal class DefaultWalletConnectComponent @AssistedInject constructor(
 
     @AssistedFactory
     interface Factory : WalletConnectComponent.Factory {
-        override fun create(context: AppComponentContext, params: Unit): DefaultWalletConnectComponent
+        override fun create(
+            context: AppComponentContext,
+            params: WalletConnectComponent.Params,
+        ): DefaultWalletConnectComponent
     }
 }

app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/WalletConnectModel.kt

@@ -4,10 +4,12 @@ import androidx.compose.runtime.Stable
 import arrow.core.getOrElse
 import com.tangem.core.decompose.di.ModelScoped
 import com.tangem.core.decompose.model.Model
+import com.tangem.core.decompose.model.ParamsContainer
 import com.tangem.domain.qrscanning.models.SourceType
 import com.tangem.domain.qrscanning.usecases.ListenToQrScanningUseCase
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectAction
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectState
+import com.tangem.tap.features.details.ui.walletconnect.api.WalletConnectComponent
 import com.tangem.tap.store
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import kotlinx.collections.immutable.toImmutableList
@@ -22,13 +24,22 @@ import javax.inject.Inject
 internal class WalletConnectModel @Inject constructor(
     override val dispatchers: CoroutineDispatcherProvider,
     private val listenToQrScanningUseCase: ListenToQrScanningUseCase,
+    paramsContainer: ParamsContainer,
 ) : Model() {
 
+    private val params = paramsContainer.require<WalletConnectComponent.Params>()
+
     init {
         modelScope.launch {
             listenToQrScanningUseCase(SourceType.WALLET_CONNECT)
                 .getOrElse { emptyFlow() }
-                .map { WalletConnectAction.OpenSession(it, WalletConnectAction.OpenSession.SourceType.QR) }
+                .map {
+                    WalletConnectAction.OpenSession(
+                        wcUri = it,
+                        source = WalletConnectAction.OpenSession.SourceType.QR,
+                        userWalletId = params.userWalletId,
+                    )
+                }
                 .collect { store.dispatch(it) }
         }
     }

app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/api/WalletConnectComponent.kt

@@ -2,7 +2,9 @@ package com.tangem.tap.features.details.ui.walletconnect.api
 
 import com.tangem.core.decompose.factory.ComponentFactory
 import com.tangem.core.ui.decompose.ComposableContentComponent
+import com.tangem.domain.wallets.models.UserWalletId
 
 interface WalletConnectComponent : ComposableContentComponent {
-    interface Factory : ComponentFactory<Unit, WalletConnectComponent>
+    data class Params(val userWalletId: UserWalletId)
+    interface Factory : ComponentFactory<Params, WalletConnectComponent>
 }

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

@@ -4,6 +4,7 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.tangem.blockchainsdk.BlockchainSDKFactory
 import com.tangem.common.keyboard.KeyboardValidator
+import com.tangem.common.routing.RoutingFeatureToggle
 import com.tangem.core.analytics.Analytics
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.analytics.models.event.TechAnalyticsEvent
@@ -22,6 +23,10 @@ import com.tangem.domain.balancehiding.BalanceHidingSettings
 import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
 import com.tangem.domain.balancehiding.ListenToFlipsUseCase
 import com.tangem.domain.balancehiding.UpdateBalanceHidingSettingsUseCase
+import com.tangem.domain.notifications.GetApplicationIdUseCase
+import com.tangem.domain.notifications.SendPushTokenUseCase
+import com.tangem.domain.notifications.models.ApplicationId
+import com.tangem.domain.notifications.toggles.NotificationsFeatureToggles
 import com.tangem.domain.onboarding.repository.OnboardingRepository
 import com.tangem.domain.onramp.FetchHotCryptoUseCase
 import com.tangem.domain.promo.GetStoryContentUseCase
@@ -31,6 +36,9 @@ 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.domain.wallets.usecase.AssociateWalletsWithApplicationIdUseCase
+import com.tangem.domain.wallets.usecase.GetSavedWalletChangesUseCase
+import com.tangem.domain.wallets.usecase.UpdateRemoteWalletsInfoUseCase
 import com.tangem.feature.swap.analytics.StoriesEvents
 import com.tangem.features.onramp.deeplink.OnrampDeepLink
 import com.tangem.tap.common.extensions.setContext
@@ -38,11 +46,15 @@ import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.features.onboarding.products.wallet.redux.BackupDialog
 import com.tangem.tap.store
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import com.tangem.wallet.BuildConfig
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeout
 import timber.log.Timber
 import javax.inject.Inject
+import kotlin.time.Duration.Companion.seconds
 
 @Suppress("LongParameterList")
 @HiltViewModel
@@ -56,7 +68,6 @@ internal class MainViewModel @Inject constructor(
     private val userWalletsListManager: UserWalletsListManager,
     private val dispatchers: CoroutineDispatcherProvider,
     private val fetchStakingTokensUseCase: FetchStakingTokensUseCase,
-    private val apiConfigsManager: ApiConfigsManager,
     private val fetchUserCountryUseCase: FetchUserCountryUseCase,
     @GlobalUiMessageSender private val messageSender: UiMessageSender,
     private val keyboardValidator: KeyboardValidator,
@@ -67,6 +78,14 @@ internal class MainViewModel @Inject constructor(
     private val onboardingRepository: OnboardingRepository,
     private val deepLinksRegistry: DeepLinksRegistry,
     private val onrampDeepLinkFactory: OnrampDeepLink.Factory,
+    private val notificationsToggles: NotificationsFeatureToggles,
+    private val getApplicationIdUseCase: GetApplicationIdUseCase,
+    private val subscribeOnWalletsUseCase: GetSavedWalletChangesUseCase,
+    private val associateWalletsWithApplicationIdUseCase: AssociateWalletsWithApplicationIdUseCase,
+    private val updateRemoteWalletsInfoUseCase: UpdateRemoteWalletsInfoUseCase,
+    private val sendPushTokenUseCase: SendPushTokenUseCase,
+    private val apiConfigsManager: ApiConfigsManager,
+    routingFeatureToggle: RoutingFeatureToggle,
     getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
 ) : ViewModel() {
 
@@ -77,32 +96,38 @@ internal class MainViewModel @Inject constructor(
         private set
 
     init {
+        /**
+         * Run any data initialization here that needs to happen before the app starts
+         * and is hidden behind the SplashScreen
+         */
         loadApplicationResources()
 
-        viewModelScope.launch(dispatchers.main) { incrementAppLaunchCounterUseCase() }
+        /** Run any API data load here that runs in parallel and does not block the app from starting */
+        launchAPIRequests {
+            launch { fetchHotCryptoUseCase() }
 
-        viewModelScope.launch {
-            fetchUserCountryUseCase().onLeft {
-                Timber.e("Unable to fetch the user country code $it")
-            }
+            launch { fetchAppCurrenciesUseCase() }
+
+            launch { fetchStakingTokens() }
+
+            launch { initPushNotifications() }
         }
 
-        viewModelScope.launch { fetchHotCryptoUseCase() }
+        viewModelScope.launch { incrementAppLaunchCounterUseCase() }
 
-        updateAppCurrencies()
         observeFlips()
         displayBalancesHidingStatusToast()
         displayHiddenBalancesModalNotification()
 
-        fetchStakingTokens()
-
         deleteDeprecatedLogsUseCase()
 
         sendKeyboardIdentifierEvent()
 
         preloadImages()
 
-        initializeDeepLinks()
+        if (!routingFeatureToggle.isDeepLinkNavigationEnabled) {
+            initializeDeepLinks()
+        }
     }
 
     fun checkForUnfinishedBackup() {
@@ -114,16 +139,41 @@ internal class MainViewModel @Inject constructor(
 
     /** Loading the resources needed to run the application */
     private fun loadApplicationResources() {
-        viewModelScope.launch(dispatchers.main) {
-            apiConfigsManager.initialize()
+        viewModelScope.launch {
+            launchAPIRequests {
+                launch { blockchainSDKFactory.init() }
+
+                launch {
+                    withTimeout(timeMillis = 1.seconds.inWholeMilliseconds) { fetchUserCountry() }
+                }
+            }
 
-            blockchainSDKFactory.init()
             prepareSelectedWalletFeedback()
 
             isSplashScreenShown = false
         }
     }
 
+    private suspend fun fetchUserCountry() {
+        fetchUserCountryUseCase().onLeft {
+            Timber.e("Unable to fetch the user country code $it")
+        }
+    }
+
+    private fun launchAPIRequests(function: suspend CoroutineScope.() -> Unit) {
+        viewModelScope.launch {
+            if (BuildConfig.TESTER_MENU_ENABLED) {
+                apiConfigsManager.isInitialized
+                    .filter { it }
+                    .first() // wait until isInitialized becomes true
+
+                function()
+            } else {
+                function()
+            }
+        }
+    }
+
     private fun prepareSelectedWalletFeedback() {
         userWalletsListManager.selectedUserWallet
             .distinctUntilChanged()
@@ -134,18 +184,10 @@ internal class MainViewModel @Inject constructor(
             .launchIn(viewModelScope)
     }
 
-    private fun updateAppCurrencies() {
-        viewModelScope.launch(dispatchers.main) {
-            fetchAppCurrenciesUseCase.invoke()
-        }
-    }
-
-    private fun fetchStakingTokens() {
-        viewModelScope.launch(dispatchers.main) {
-            fetchStakingTokensUseCase()
-                .onLeft { Timber.e(it.toString(), "Unable to fetch the staking tokens list") }
-                .onRight { Timber.d("Staking token list was fetched successfully") }
-        }
+    private suspend fun fetchStakingTokens() {
+        fetchStakingTokensUseCase()
+            .onLeft { Timber.e(it.toString(), "Unable to fetch the staking tokens list") }
+            .onRight { Timber.d("Staking token list was fetched successfully") }
     }
 
     private fun observeFlips() {
@@ -343,4 +385,20 @@ internal class MainViewModel @Inject constructor(
     private fun initializeDeepLinks() {
         deepLinksRegistry.register(onrampDeepLinkFactory.create(viewModelScope))
     }
+
+    private suspend fun initPushNotifications() {
+        if (notificationsToggles.isNotificationsEnabled) {
+            getApplicationIdUseCase().onRight { applicationId ->
+                sendPushTokenUseCase(applicationId = applicationId)
+                associateWalletsWithApplicationId(applicationId = applicationId)
+                updateRemoteWalletsInfoUseCase(applicationId = applicationId)
+            }.onLeft { Timber.e(it.toString()) }
+        }
+    }
+
+    private fun associateWalletsWithApplicationId(applicationId: ApplicationId) {
+        subscribeOnWalletsUseCase().onEach { wallets ->
+            associateWalletsWithApplicationIdUseCase(applicationId, wallets)
+        }.launchIn(viewModelScope)
+    }
 }

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

@@ -5,10 +5,10 @@ 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.models.currency.CryptoCurrency
+import com.tangem.domain.models.network.NetworkAddress
 import com.tangem.domain.onramp.model.OnrampSource
 import com.tangem.domain.tokens.legacy.TradeCryptoAction
-import com.tangem.domain.tokens.model.CryptoCurrency
-import com.tangem.domain.tokens.model.NetworkAddress
 import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.tap.common.analytics.events.Token
 import com.tangem.tap.common.apptheme.MutableAppThemeModeHolder
@@ -79,7 +79,7 @@ object TradeCryptoMiddleware {
 
         val status = action.cryptoCurrencyStatus
         val currency = status.currency
-        val blockchain = Blockchain.fromId(currency.network.id.value)
+        val blockchain = Blockchain.fromId(currency.network.rawId)
         val exchangeManager = store.state.globalState.exchangeManager
         val topUrl = exchangeManager.getUrl(
             action = CurrencyExchangeManager.Action.Buy,