Updated on 2026-08-14

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

@@ -7,7 +7,7 @@ import com.tangem.tap.domain.walletconnect2.domain.WcBlockchainHelper
 import com.tangem.tap.domain.walletconnect2.toggles.WalletConnectFeatureToggles
 
 internal class TangemWcBlockchainHelper(
-    private val featureToggles: WalletConnectFeatureToggles,
+    featureToggles: WalletConnectFeatureToggles,
 ) : WcBlockchainHelper {
 
     private val supportedNonEvmBlockchains = if (featureToggles.isSolanaTxSignEnabled) {

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

@@ -6,6 +6,9 @@ import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
 import com.tangem.datasource.di.SdkMoshi
 import com.tangem.datasource.files.FileReader
+import com.tangem.domain.tokens.repository.CurrenciesRepository
+import com.tangem.domain.walletmanager.WalletManagersFacade
+import com.tangem.domain.wallets.legacy.WalletsStateHolder
 import com.tangem.tap.domain.walletconnect.WalletConnectSdkHelper
 import com.tangem.tap.domain.walletconnect2.app.TangemWcBlockchainHelper
 import com.tangem.tap.domain.walletconnect2.app.WalletConnectEventsHandlerImpl
@@ -35,6 +38,9 @@ internal object WalletConnectInteractorModule {
         wcRepository: WalletConnectRepository,
         wcSessionsRepository: WalletConnectSessionsRepository,
         walletConnectFeatureToggles: WalletConnectFeatureToggles,
+        currenciesRepository: CurrenciesRepository,
+        walletManagersFacade: WalletManagersFacade,
+        walletsStateHolder: WalletsStateHolder,
     ): WalletConnectInteractor {
         return WalletConnectInteractor(
             handler = WalletConnectEventsHandlerImpl(),
@@ -42,7 +48,10 @@ internal object WalletConnectInteractorModule {
             sessionsRepository = wcSessionsRepository,
             sdkHelper = WalletConnectSdkHelper(),
             blockchainHelper = TangemWcBlockchainHelper(walletConnectFeatureToggles),
-            dispatcher = AppCoroutineDispatcherProvider(),
+            currenciesRepository = currenciesRepository,
+            walletManagersFacade = walletManagersFacade,
+            walletsStateHolder = walletsStateHolder,
+            dispatchers = AppCoroutineDispatcherProvider(),
         )
     }
 }

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

@@ -1,26 +1,52 @@
 package com.tangem.tap.domain.walletconnect2.domain
 
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.domain.common.extensions.toNetworkId
+import com.tangem.domain.tokens.model.CryptoCurrency
+import com.tangem.domain.tokens.model.Network
+import com.tangem.domain.tokens.repository.CurrenciesRepository
+import com.tangem.domain.walletmanager.WalletManagersFacade
+import com.tangem.domain.wallets.legacy.WalletsStateHolder
+import com.tangem.domain.wallets.models.UserWallet
+import com.tangem.domain.wallets.usecase.GetSelectedWalletUseCase
 import com.tangem.tap.common.extensions.filterNotNull
 import com.tangem.tap.domain.walletconnect.WalletConnectSdkHelper
 import com.tangem.tap.domain.walletconnect2.domain.models.*
 import com.tangem.tap.features.details.ui.walletconnect.WcSessionForScreen
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.flow.collect
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.onEach
+import com.tangem.utils.coroutines.FeatureCoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelChildren
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import timber.log.Timber
 
+@Suppress("LargeClass", "LongParameterList")
 class WalletConnectInteractor(
     private val handler: WalletConnectEventsHandler,
     private val walletConnectRepository: WalletConnectRepository,
     private val sessionsRepository: WalletConnectSessionsRepository,
     private val sdkHelper: WalletConnectSdkHelper,
-    private val dispatcher: CoroutineDispatcherProvider,
+    private val dispatchers: CoroutineDispatcherProvider,
+    private val walletManagersFacade: WalletManagersFacade,
+    private val currenciesRepository: CurrenciesRepository,
+    private val walletsStateHolder: WalletsStateHolder,
     val blockchainHelper: WcBlockchainHelper,
 ) {
 
+    private val getSelectedWalletUseCase by lazy(LazyThreadSafetyMode.NONE) {
+        GetSelectedWalletUseCase(walletsStateHolder)
+    }
+
+    private val wcScope = CoroutineScope(
+        Job() + dispatchers.io + FeatureCoroutineExceptionHandler.create("wcScope"),
+    )
+
+    private val listenerScope = CoroutineScope(
+        Job() + dispatchers.io + FeatureCoroutineExceptionHandler.create("listenScope"),
+    )
+
     private val events = walletConnectRepository.events
     private val sessions = walletConnectRepository.activeSessions
 
@@ -34,19 +60,56 @@ class WalletConnectInteractor(
         sdkHelper = sdkHelper,
     )
 
-    suspend fun startListening(userWalletId: String, cardId: String?) {
+    init {
+        getSelectedWalletUseCase().onRight { userWalletFlow ->
+            userWalletFlow
+                .conflate()
+                .distinctUntilChanged()
+                .onEach(::initWithWallet)
+                .flowOn(dispatchers.io)
+                .launchIn(wcScope)
+        }
+    }
+
+    private suspend fun initWithWallet(userWallet: UserWallet) {
+        if (userWallet.isMultiCurrency) {
+            Timber.d("WalletConnect: initialize and setup networks for ${userWallet.walletId}")
+            startListeningWc(userWallet.walletId.stringValue, getCardId(userWallet))
+            subscribeOnCurrenciesUpdates(userWallet)
+        }
+    }
+
+    private fun subscribeOnCurrenciesUpdates(userWallet: UserWallet) {
+        currenciesRepository.getMultiCurrencyWalletCurrenciesUpdates(userWallet.walletId)
+            .conflate()
+            .distinctUntilChanged()
+            .onEach { currencies ->
+                setupUserChains(userWallet, currencies)
+            }
+            .flowOn(dispatchers.io)
+            .launchIn(wcScope)
+    }
+
+    private suspend fun setupUserChains(userWallet: UserWallet, currencies: List<CryptoCurrency>) {
+        val accounts = getAccountsForWc(
+            userWallet = userWallet,
+            networks = currencies.map { it.network },
+        )
+        setUserChains(accounts)
+    }
+
+    private suspend fun startListeningWc(userWalletId: String, cardId: String?) {
         this.userWalletId = userWalletId
         this.cardId = cardId
-
-        coroutineScope {
+        listenerScope.coroutineContext.cancelChildren()
+        listenerScope.launch {
             launch { subscribeToEvents() }
             launch { subscribeToSessions() }
-
             walletConnectRepository.updateSessions()
         }
     }
 
-    fun setUserChains(accounts: List<Account>) {
+    private fun setUserChains(accounts: List<Account>) {
         val userNamespaces: Map<NetworkNamespace, List<Account>> = accounts
             .groupBy { account ->
                 blockchainHelper.getNamespaceFromFullChainIdOrNull(account.chainId)
@@ -106,7 +169,7 @@ class WalletConnectInteractor(
                     }
                 }
             }
-            .flowOn(dispatcher.io)
+            .flowOn(dispatchers.io)
             .collect()
     }
 
@@ -117,7 +180,7 @@ class WalletConnectInteractor(
                 val filteredSessions = filterSessionsForUserWallet(listOfSessions, relevantTopics)
                 handler.onListOfSessionsUpdated(filteredSessions)
             }
-            .flowOn(dispatcher.io)
+            .flowOn(dispatchers.io)
             .collect()
     }
 
@@ -258,6 +321,38 @@ class WalletConnectInteractor(
         return uri.lowercase().startsWith(WC_SCHEME)
     }
 
+    private fun getCardId(userWallet: UserWallet): String? {
+        return if (userWallet.scanResponse.card.backupStatus?.isActive != true) {
+            userWallet.cardId
+        } else { // if wallet has backup, any card from wallet can be used to sign
+            null
+        }
+    }
+
+    private suspend fun getAccountsForWc(userWallet: UserWallet, networks: List<Network>): List<Account> {
+        val walletManagers = networks.mapNotNull {
+            val blockchain = Blockchain.fromId(it.id.value)
+            walletManagersFacade.getOrCreateWalletManager(
+                userWalletId = userWallet.walletId,
+                blockchain = blockchain,
+                derivationPath = it.derivationPath.value,
+            )
+        }
+        return walletManagers.mapNotNull {
+            val wallet = it.wallet
+            val chainId = blockchainHelper.networkIdToChainIdOrNull(
+                wallet.blockchain.toNetworkId(),
+            )
+            chainId?.let {
+                Account(
+                    chainId,
+                    wallet.address,
+                    wallet.publicKey.derivationPath?.rawPath,
+                )
+            }
+        }
+    }
+
     private suspend fun prepareRequestData(sessionRequest: WalletConnectEvents.SessionRequest): WcPreparedRequest? {
         return sessionRequestConverter.prepareRequest(sessionRequest, userWalletId)
     }

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

@@ -6,8 +6,6 @@ import com.tangem.core.navigation.AppScreen
 import com.tangem.core.navigation.NavigationAction
 import com.tangem.domain.common.extensions.toNetworkId
 import com.tangem.domain.qrscanning.models.SourceType
-import com.tangem.domain.walletconnect.WalletConnectActions
-import com.tangem.domain.wallets.models.UserWallet
 import com.tangem.feature.qrscanning.QrScanningRouter
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.extensions.inject
@@ -49,28 +47,6 @@ class WalletConnectMiddleware {
         if (DemoHelper.tryHandle(state, action)) return
 
         when (action) {
-            is WalletConnectActions.New.Initialize -> {
-                val userWallet = action.userWallet
-                val cardId = if (userWallet.scanResponse.card.backupStatus?.isActive != true) {
-                    userWallet.cardId
-                } else { // if wallet has backup, any card from wallet can be used to sign
-                    null
-                }
-                scope.launch {
-                    val wcInteractor = store.state.daggerGraphState.walletConnectInteractor ?: return@launch
-                    wcInteractor.startListening(
-                        userWalletId = userWallet.walletId.stringValue,
-                        cardId = cardId,
-                    )
-                }
-            }
-            is WalletConnectActions.New.SetupUserChains -> {
-                scope.launch {
-                    val userWallet = action.userWallet
-                    val wcInteractor = store.state.daggerGraphState.walletConnectInteractor ?: return@launch
-                    wcInteractor.setUserChains(getAccountsForWc(wcInteractor, userWallet))
-                }
-            }
             is WalletConnectAction.HandleDeepLink -> {
                 if (!action.wcUri.isNullOrBlank()) {
                     store.dispatchOnMain(WalletConnectAction.OpenSession(action.wcUri))
@@ -206,21 +182,4 @@ class WalletConnectMiddleware {
     private fun isWalletConnectUri(uri: String): Boolean {
         return walletConnectInteractor.isWalletConnectUri(uri)
     }
-
-    private suspend fun getAccountsForWc(wcInteractor: WalletConnectInteractor, userWallet: UserWallet): List<Account> {
-        val walletManagerFacade = store.inject(DaggerGraphState::walletManagersFacade)
-        return walletManagerFacade.getStoredWalletManagers(userWallet.walletId).mapNotNull {
-            val wallet = it.wallet
-            val chainId = wcInteractor.blockchainHelper.networkIdToChainIdOrNull(
-                wallet.blockchain.toNetworkId(),
-            )
-            chainId?.let {
-                Account(
-                    chainId,
-                    wallet.address,
-                    wallet.publicKey.derivationPath?.rawPath,
-                )
-            }
-        }
-    }
 }

domain/legacy/src/main/java/com/tangem/domain/walletconnect/WalletConnectActions.kt

@@ -1,12 +0,0 @@
-package com.tangem.domain.walletconnect
-
-import com.tangem.domain.wallets.models.UserWallet
-import org.rekotlin.Action
-
-sealed class WalletConnectActions : Action {
-    sealed class New {
-        data class Initialize(val userWallet: UserWallet) : WalletConnectActions()
-
-        data class SetupUserChains(val userWallet: UserWallet) : WalletConnectActions()
-    }
-}

features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/wallet/loaders/implementors/MultiWalletContentLoader.kt

@@ -1,7 +1,6 @@
 package com.tangem.feature.wallet.presentation.wallet.loaders.implementors
 
 import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
-import com.tangem.domain.redux.ReduxStateHolder
 import com.tangem.domain.tokens.ApplyTokenListSortingUseCase
 import com.tangem.domain.tokens.GetTokenListUseCase
 import com.tangem.domain.wallets.models.UserWallet
@@ -12,7 +11,6 @@ import com.tangem.feature.wallet.presentation.wallet.domain.WalletWithFundsCheck
 import com.tangem.feature.wallet.presentation.wallet.state.WalletStateController
 import com.tangem.feature.wallet.presentation.wallet.subscribers.MultiWalletTokenListSubscriber
 import com.tangem.feature.wallet.presentation.wallet.subscribers.MultiWalletWarningsSubscriber
-import com.tangem.feature.wallet.presentation.wallet.subscribers.WalletConnectNetworksSubscriber
 import com.tangem.feature.wallet.presentation.wallet.subscribers.WalletSubscriber
 import com.tangem.feature.wallet.presentation.wallet.viewmodels.intents.WalletClickIntents
 
@@ -28,7 +26,6 @@ internal class MultiWalletContentLoader(
     private val getSelectedAppCurrencyUseCase: GetSelectedAppCurrencyUseCase,
     private val applyTokenListSortingUseCase: ApplyTokenListSortingUseCase,
     private val getMultiWalletWarningsFactory: GetMultiWalletWarningsFactory,
-    private val reduxStateHolder: ReduxStateHolder,
 ) : WalletContentLoader(id = userWallet.walletId) {
 
     override fun create(): List<WalletSubscriber> {
@@ -50,11 +47,6 @@ internal class MultiWalletContentLoader(
                 getMultiWalletWarningsFactory = getMultiWalletWarningsFactory,
                 walletWarningsAnalyticsSender = walletWarningsAnalyticsSender,
             ),
-            WalletConnectNetworksSubscriber(
-                userWallet = userWallet,
-                getTokenListUseCase = getTokenListUseCase,
-                reduxStateHolder = reduxStateHolder,
-            ),
         )
     }
 }

features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/wallet/loaders/implementors/MultiWalletContentLoaderFactory.kt

@@ -1,7 +1,6 @@
 package com.tangem.feature.wallet.presentation.wallet.loaders.implementors
 
 import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
-import com.tangem.domain.redux.ReduxStateHolder
 import com.tangem.domain.tokens.ApplyTokenListSortingUseCase
 import com.tangem.domain.tokens.GetTokenListUseCase
 import com.tangem.domain.wallets.models.UserWallet
@@ -24,7 +23,6 @@ internal class MultiWalletContentLoaderFactory @Inject constructor(
     private val getTokenListUseCase: GetTokenListUseCase,
     private val getSelectedAppCurrencyUseCase: GetSelectedAppCurrencyUseCase,
     private val applyTokenListSortingUseCase: ApplyTokenListSortingUseCase,
-    private val reduxStateHolder: ReduxStateHolder,
     private val walletWarningsAnalyticsSender: WalletWarningsAnalyticsSender,
 ) {
 
@@ -38,7 +36,6 @@ internal class MultiWalletContentLoaderFactory @Inject constructor(
             getTokenListUseCase = getTokenListUseCase,
             getSelectedAppCurrencyUseCase = getSelectedAppCurrencyUseCase,
             getMultiWalletWarningsFactory = getMultiWalletWarningsFactory,
-            reduxStateHolder = reduxStateHolder,
             walletWarningsAnalyticsSender = walletWarningsAnalyticsSender,
             applyTokenListSortingUseCase = applyTokenListSortingUseCase,
         )

features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/wallet/subscribers/WalletConnectNetworksSubscriber.kt

@@ -1,80 +0,0 @@
-package com.tangem.feature.wallet.presentation.wallet.subscribers
-
-import arrow.core.Either
-import com.tangem.domain.redux.ReduxStateHolder
-import com.tangem.domain.tokens.GetTokenListUseCase
-import com.tangem.domain.tokens.error.TokenListError
-import com.tangem.domain.tokens.model.CryptoCurrencyStatus
-import com.tangem.domain.tokens.model.NetworkGroup
-import com.tangem.domain.tokens.model.TokenList
-import com.tangem.domain.walletconnect.WalletConnectActions
-import com.tangem.domain.wallets.models.UserWallet
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import timber.log.Timber
-
-/**
- * WalletConnect networks subscriber. Update WalletConnect networks for a specified [userWallet].
- *
- * @property userWallet          user wallet
- * @property getTokenListUseCase use case for subscribing on token list changes
- * @property reduxStateHolder    redux state holder
- *
-[REDACTED_AUTHOR]
- */
-internal class WalletConnectNetworksSubscriber(
-    private val userWallet: UserWallet,
-    private val getTokenListUseCase: GetTokenListUseCase,
-    private val reduxStateHolder: ReduxStateHolder,
-) : WalletSubscriber() {
-
-    private val mutex = Mutex()
-
-    override fun create(coroutineScope: CoroutineScope): Flow<Either<TokenListError, TokenList>> {
-        return getTokenListUseCase(userWalletId = userWallet.walletId)
-            .conflate()
-            .distinctUntilCurrenciesChanged()
-            .filterLoadedTokens()
-            .onEach {
-                mutex.withLock {
-                    Timber.d("WalletConnect: ${userWallet.walletId} networks is updated")
-
-                    reduxStateHolder.dispatch(
-                        action = WalletConnectActions.New.SetupUserChains(userWallet = userWallet),
-                    )
-                }
-            }
-    }
-
-    private fun MaybeTokenListFlow.distinctUntilCurrenciesChanged(): MaybeTokenListFlow {
-        return distinctUntilChanged { old, new ->
-            val oldCurrencies = old.fold(ifLeft = { null }, ifRight = { it.getCryptoCurrencies() })
-            val newCurrencies = new.fold(ifLeft = { null }, ifRight = { it.getCryptoCurrencies() })
-
-            oldCurrencies == newCurrencies
-        }
-    }
-
-    private fun MaybeTokenListFlow.filterLoadedTokens(): MaybeTokenListFlow {
-        return filter { either ->
-            either.fold(
-                ifLeft = { false },
-                ifRight = { it.getCryptoCurrencies().isAllCurrenciesLoaded() },
-            )
-        }
-    }
-
-    private fun TokenList.getCryptoCurrencies(): List<CryptoCurrencyStatus> {
-        return when (this) {
-            is TokenList.Ungrouped -> currencies
-            is TokenList.GroupedByNetwork -> groups.flatMap(NetworkGroup::currencies)
-            else -> emptyList()
-        }
-    }
-
-    private fun List<CryptoCurrencyStatus>.isAllCurrenciesLoaded(): Boolean {
-        return none { it.value is CryptoCurrencyStatus.Loading }
-    }
-}

features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/wallet/viewmodels/WalletViewModel.kt

@@ -7,11 +7,9 @@ import androidx.lifecycle.viewModelScope
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.core.navigation.AppScreen
 import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
-import com.tangem.domain.redux.ReduxStateHolder
 import com.tangem.domain.settings.CanUseBiometryUseCase
 import com.tangem.domain.settings.IsWalletsScrollPreviewEnabled
 import com.tangem.domain.settings.ShouldShowSaveWalletScreenUseCase
-import com.tangem.domain.walletconnect.WalletConnectActions
 import com.tangem.domain.wallets.usecase.GetSelectedWalletUseCase
 import com.tangem.domain.wallets.usecase.GetWalletsUseCase
 import com.tangem.feature.wallet.presentation.deeplink.WalletDeepLinksHandler
@@ -37,7 +35,6 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import timber.log.Timber
 import javax.inject.Inject
 
 @Suppress("LongParameterList")
@@ -56,7 +53,6 @@ internal class WalletViewModel @Inject constructor(
     private val getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
     analyticsEventsHandler: AnalyticsEventHandler,
     private val dispatchers: CoroutineDispatcherProvider,
-    private val reduxStateHolder: ReduxStateHolder,
     private val screenLifecycleProvider: ScreenLifecycleProvider,
     private val selectedWalletAnalyticsSender: SelectedWalletAnalyticsSender,
     private val walletDeepLinksHandler: WalletDeepLinksHandler,
@@ -141,16 +137,6 @@ internal class WalletViewModel @Inject constructor(
                 .distinctUntilChanged()
                 .onEach { selectedWallet ->
                     if (selectedWallet.isMultiCurrency) {
-                        Timber.d("WalletConnect: initialize and setup networks for ${selectedWallet.walletId}")
-
-                        reduxStateHolder.dispatch(
-                            action = WalletConnectActions.New.Initialize(userWallet = selectedWallet),
-                        )
-
-                        reduxStateHolder.dispatch(
-                            action = WalletConnectActions.New.SetupUserChains(userWallet = selectedWallet),
-                        )
-
                         selectedWalletAnalyticsSender.send(selectedWallet)
                     }