Updated on 2026-08-14

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

@@ -13,6 +13,7 @@ import com.tangem.domain.walletconnect.WcPairService
 import com.tangem.domain.walletconnect.model.WcPairRequest
 import com.tangem.domain.walletconnect.model.legacy.Account
 import com.tangem.domain.walletconnect.usecase.initialize.WcInitializeUseCase
+import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.features.walletconnect.components.WalletConnectFeatureToggles
 import com.tangem.tap.common.analytics.events.WalletConnect
 import com.tangem.tap.domain.walletconnect2.app.TangemWcBlockchainHelper
@@ -64,14 +65,18 @@ internal class DefaultLegacyWalletConnectRepositoryFacade constructor(
         if (isNewWc) stub.updateSessions() else legacy.updateSessions()
     }
 
-    override fun pair(uri: String, source: SourceType) {
+    override fun pair(userWalletId: UserWalletId, uri: String, source: SourceType) {
         val src = when (source) {
             SourceType.QR -> WcPairRequest.Source.QR
             SourceType.DEEPLINK -> WcPairRequest.Source.DEEPLINK
             SourceType.CLIPBOARD -> WcPairRequest.Source.CLIPBOARD
             SourceType.ETC -> WcPairRequest.Source.ETC
         }
-        if (isNewWc) wcPairService.pair(WcPairRequest(uri, src)) else legacy.pair(uri, source)
+        if (isNewWc) {
+            wcPairService.pair(WcPairRequest(uri = uri, source = src, userWalletId = userWalletId))
+        } else {
+            legacy.pair(userWalletId = userWalletId, uri = uri, source = source)
+        }
     }
 
     override fun disconnect(topic: String) {
@@ -110,7 +115,7 @@ internal class LegacyWalletConnectRepositoryStub : LegacyWalletConnectRepository
 
     override fun updateSessions() = Unit
 
-    override fun pair(uri: String, source: SourceType) = Unit
+    override fun pair(userWalletId: UserWalletId, uri: String, source: SourceType) = Unit
 
     override fun disconnect(topic: String) = Unit
 
@@ -405,7 +410,7 @@ internal class DefaultLegacyWalletConnectRepository(
         this.userNamespaces = userNamespaces
     }
 
-    override fun pair(uri: String, source: SourceType) {
+    override fun pair(userWalletId: UserWalletId, uri: String, source: SourceType) {
         analyticsHandler.send(WalletConnect.NewSessionInitiated(source = source))
         WalletKit.pair(
             params = Wallet.Params.Pair(uri),

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

@@ -1,6 +1,7 @@
 package com.tangem.tap.domain.walletconnect2.domain
 
 import com.tangem.domain.walletconnect.model.legacy.Account
+import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.tap.domain.walletconnect2.domain.models.*
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectAction.OpenSession.SourceType
 import kotlinx.coroutines.flow.Flow
@@ -19,7 +20,7 @@ interface LegacyWalletConnectRepository {
 
     fun updateSessions()
 
-    fun pair(uri: String, source: SourceType)
+    fun pair(userWalletId: UserWalletId, uri: String, source: SourceType)
 
     fun disconnect(topic: String)
 

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

@@ -12,6 +12,7 @@ import com.tangem.domain.walletconnect.model.legacy.WalletConnectSessionsReposit
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.domain.wallets.models.UserWallet
+import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.domain.wallets.usecase.GetSelectedWalletUseCase
 import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.extensions.filterNotNull
@@ -139,7 +140,11 @@ class WalletConnectInteractor(
             if (deeplinkStack.empty()) return
             val lastDeeplink = deeplinkStack.pop()
             val action = WalletConnectAction
-                .OpenSession(lastDeeplink, WalletConnectAction.OpenSession.SourceType.DEEPLINK)
+                .OpenSession(
+                    wcUri = lastDeeplink,
+                    source = WalletConnectAction.OpenSession.SourceType.DEEPLINK,
+                    userWalletId = UserWalletId(userWalletId),
+                )
             store.dispatchOnMain(action)
         }.onFailure {
             Timber.e("WC deeplink handling failed. $it")
@@ -393,7 +398,11 @@ class WalletConnectInteractor(
         }
 
         if (isWalletConnectReadyForDeepLinks) {
-            val action = WalletConnectAction.OpenSession(deeplink, WalletConnectAction.OpenSession.SourceType.DEEPLINK)
+            val action = WalletConnectAction.OpenSession(
+                wcUri = deeplink,
+                source = WalletConnectAction.OpenSession.SourceType.DEEPLINK,
+                userWalletId = UserWalletId(userWalletId),
+            )
             store.dispatchOnMain(action)
         } else {
             deeplinkStack.push(deeplink)

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/routing/utils/ChildFactory.kt

@@ -291,13 +291,13 @@ internal class ChildFactory @Inject constructor(
                 if (walletConnectFeatureToggles.isRedesignedWalletConnectEnabled) {
                     createComponentChild(
                         context = context,
-                        params = Unit,
+                        params = RedesignedWalletConnectComponent.Params(route.userWalletId),
                         componentFactory = redesignedWalletConnectComponentFactory,
                     )
                 } else {
                     createComponentChild(
                         context = context,
-                        params = Unit,
+                        params = WalletConnectComponent.Params(route.userWalletId),
                         componentFactory = walletConnectComponentFactory,
                     )
                 }

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

@@ -122,7 +122,7 @@ sealed class AppRoute(val path: String) : Route {
     }
 
     @Serializable
-    data object WalletConnectSessions : AppRoute(path = "/wallet_connect_sessions")
+    data class WalletConnectSessions(val userWalletId: UserWalletId) : AppRoute(path = "/wallet_connect_sessions")
 
     @Serializable
     data class QrScanning(val source: Source) : AppRoute(path = "/$source/qr_scanning${source.path}") {

data/wallet-connect/src/test/kotlin/com/tangem/domain/walletconnect/DefaultWcPairUseCaseTest.kt

@@ -20,6 +20,7 @@ import com.tangem.domain.walletconnect.model.WcSession
 import com.tangem.domain.walletconnect.model.WcSessionApprove
 import com.tangem.domain.walletconnect.repository.WcSessionsManager
 import com.tangem.domain.walletconnect.usecase.pair.WcPairState
+import com.tangem.domain.wallets.models.UserWalletId
 import io.mockk.coEvery
 import io.mockk.coVerifyOrder
 import io.mockk.mockk
@@ -99,7 +100,7 @@ internal class DefaultWcPairUseCaseTest {
         caipNamespaceDelegate = caipNamespaceDelegate,
         sdkDelegate = sdkDelegate,
         blockAidVerifier = blockAidVerifier,
-        pairRequest = WcPairRequest(url, source),
+        pairRequest = WcPairRequest(userWalletId = UserWalletId(""), uri = url, source = source),
     )
 
     @Before

domain/wallet-connect/models/src/main/java/com/tangem/domain/walletconnect/model/WcPairRequest.kt

@@ -1,11 +1,13 @@
 package com.tangem.domain.walletconnect.model
 
+import com.tangem.domain.wallets.models.UserWalletId
 import kotlinx.serialization.Serializable
 
 @Serializable
 data class WcPairRequest(
     val uri: String,
     val source: Source,
+    val userWalletId: UserWalletId,
 ) {
     enum class Source { QR, DEEPLINK, CLIPBOARD, ETC }
 }

features/details/impl/src/main/kotlin/com/tangem/features/details/component/preview/PreviewDetailsComponent.kt

@@ -5,6 +5,7 @@ import androidx.compose.ui.Modifier
 import com.tangem.core.decompose.navigation.DummyRouter
 import com.tangem.core.navigation.url.DummyUrlOpener
 import com.tangem.core.ui.components.bottomsheets.TangemBottomSheetConfig
+import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.features.details.component.DetailsComponent
 import com.tangem.features.details.entity.DetailsFooterUM
 import com.tangem.features.details.entity.DetailsUM
@@ -18,7 +19,12 @@ internal class PreviewDetailsComponent : DetailsComponent {
     private val previewBlocks = runBlocking {
         ItemsBuilder(
             router = DummyRouter(),
-        ).buildAll(isWalletConnectAvailable = true, onSupportClick = {}, onBuyClick = {})
+        ).buildAll(
+            isWalletConnectAvailable = true,
+            userWalletId = UserWalletId(""),
+            onSupportClick = {},
+            onBuyClick = {},
+        )
     }
 
     private val previewFooter = DetailsFooterUM(

features/details/impl/src/main/kotlin/com/tangem/features/details/model/DetailsModel.kt

@@ -80,6 +80,7 @@ internal class DetailsModel @Inject constructor(
         items = MutableStateFlow(
             itemsBuilder.buildAll(
                 isWalletConnectAvailable = isWalletConnectAvailable,
+                userWalletId = params.userWalletId,
                 onSupportClick = ::sendFeedback,
                 onBuyClick = ::onBuyClick,
             ),

features/details/impl/src/main/kotlin/com/tangem/features/details/utils/ItemsBuilder.kt

@@ -6,6 +6,7 @@ import com.tangem.core.decompose.navigation.Router
 import com.tangem.core.ui.components.block.model.BlockUM
 import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.core.ui.extensions.stringReference
+import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.features.details.entity.DetailsItemUM
 import com.tangem.features.details.impl.BuildConfig
 import com.tangem.features.details.impl.R
@@ -19,20 +20,21 @@ internal class ItemsBuilder @Inject constructor(private val router: Router) {
 
     fun buildAll(
         isWalletConnectAvailable: Boolean,
+        userWalletId: UserWalletId,
         onSupportClick: () -> Unit,
         onBuyClick: () -> Unit,
     ): ImmutableList<DetailsItemUM> = buildList {
-        buildWalletConnectBlock(isWalletConnectAvailable)?.let(::add)
+        buildWalletConnectBlock(isWalletConnectAvailable, userWalletId)?.let(::add)
         buildUserWalletListBlock().let(::add)
         buildShopBlock(onBuyClick).let(::add)
         buildSettingsBlock().let(::add)
         buildSupportBlock(onSupportClick).let(::add)
     }.toImmutableList()
 
-    private fun buildWalletConnectBlock(isWalletConnectAvailable: Boolean): DetailsItemUM? {
+    private fun buildWalletConnectBlock(isWalletConnectAvailable: Boolean, userWalletId: UserWalletId): DetailsItemUM? {
         return if (isWalletConnectAvailable) {
             DetailsItemUM.WalletConnect(
-                onClick = { router.push(AppRoute.WalletConnectSessions) },
+                onClick = { router.push(AppRoute.WalletConnectSessions(userWalletId)) },
             )
         } else {
             null

features/walletconnect/api/src/main/kotlin/com/tangem/features/walletconnect/components/WalletConnectEntryComponent.kt

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

features/walletconnect/impl/build.gradle.kts

@@ -12,9 +12,8 @@ android {
 }
 
 dependencies {
+    implementation(projects.features.wallet.api)
     implementation(projects.features.walletconnect.api)
-    implementation(projects.domain.walletConnect)
-    implementation(projects.domain.walletConnect.models)
 
     /** Core */
     implementation(projects.core.configToggles)
@@ -24,13 +23,22 @@ dependencies {
     implementation(projects.common.ui)
 
     /** Domain models */
+    implementation(projects.domain.appCurrency.models)
+    implementation(projects.domain.balanceHiding.models)
     implementation(projects.domain.blockaid.models)
+    implementation(projects.domain.models)
     implementation(projects.domain.qrScanning.models)
     implementation(projects.domain.tokens.models)
     implementation(projects.domain.wallets.models)
+    implementation(projects.domain.walletConnect)
+    implementation(projects.domain.walletConnect.models)
 
     /** Domain */
+    implementation(projects.domain.appCurrency)
+    implementation(projects.domain.balanceHiding)
     implementation(projects.domain.qrScanning)
+    implementation(projects.domain.tokens)
+    implementation(projects.domain.wallets)
 
     /** DI */
     implementation(deps.hilt.android)

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/components/ConnectionsComponent.kt

@@ -13,15 +13,17 @@ import com.tangem.core.decompose.context.childByContext
 import com.tangem.core.decompose.model.getOrCreateModel
 import com.tangem.core.ui.decompose.ComposableBottomSheetComponent
 import com.tangem.core.ui.decompose.ComposableContentComponent
+import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.features.walletconnect.connections.model.WcConnectionsModel
 import com.tangem.features.walletconnect.connections.routes.WcConnectionsBottomSheetConfig
 import com.tangem.features.walletconnect.connections.ui.WcConnectionsContent
 
 internal class ConnectionsComponent(
     appComponentContext: AppComponentContext,
+    params: Params,
 ) : AppComponentContext by appComponentContext, ComposableContentComponent {
 
-    private val model: WcConnectionsModel = getOrCreateModel()
+    private val model: WcConnectionsModel = getOrCreateModel(params)
     private val bottomSheetSlot = childSlot(
         source = model.bottomSheetNavigation,
         serializer = null,
@@ -52,4 +54,6 @@ internal class ConnectionsComponent(
             )
         }
     }
+
+    data class Params(val userWalletId: UserWalletId)
 }

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/components/DefaultWalletConnectEntryComponent.kt

@@ -22,7 +22,7 @@ import dagger.assisted.AssistedInject
 @Suppress("UnusedPrivateMember")
 internal class DefaultWalletConnectEntryComponent @AssistedInject constructor(
     @Assisted private val appComponentContext: AppComponentContext,
-    @Assisted params: Unit,
+    @Assisted private val params: WalletConnectEntryComponent.Params,
 ) : AppComponentContext by appComponentContext, WalletConnectEntryComponent {
 
     private val contentNavigation = StackNavigation<ConnectionsInnerRoute>()
@@ -47,12 +47,18 @@ internal class DefaultWalletConnectEntryComponent @AssistedInject constructor(
         config: ConnectionsInnerRoute,
         componentContext: ComponentContext,
     ): ComposableContentComponent = when (config) {
-        ConnectionsInnerRoute.Connections -> ConnectionsComponent(childByContext(componentContext))
+        ConnectionsInnerRoute.Connections -> ConnectionsComponent(
+            appComponentContext = childByContext(componentContext),
+            params = ConnectionsComponent.Params(params.userWalletId),
+        )
         ConnectionsInnerRoute.QrScan -> TODO("[REDACTED_JIRA]")
     }
 
     @AssistedFactory
     interface Factory : WalletConnectEntryComponent.Factory {
-        override fun create(context: AppComponentContext, params: Unit): DefaultWalletConnectEntryComponent
+        override fun create(
+            context: AppComponentContext,
+            params: WalletConnectEntryComponent.Params,
+        ): DefaultWalletConnectEntryComponent
     }
 }

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/components/WcAppInfoContainerComponent.kt

@@ -1,13 +1,12 @@
 package com.tangem.features.walletconnect.connections.components
 
+import androidx.compose.animation.animateContentSize
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
 import com.arkivanov.decompose.ComponentContext
 import com.arkivanov.decompose.extensions.compose.stack.Children
-import com.arkivanov.decompose.extensions.compose.stack.animation.stackAnimation
 import com.arkivanov.decompose.extensions.compose.subscribeAsState
-import com.arkivanov.decompose.router.stack.StackNavigation
 import com.arkivanov.decompose.router.stack.childStack
 import com.arkivanov.decompose.router.stack.pop
 import com.tangem.core.decompose.context.AppComponentContext
@@ -18,8 +17,10 @@ import com.tangem.core.ui.components.bottomsheets.modal.TangemModalBottomSheet
 import com.tangem.core.ui.components.bottomsheets.modal.TangemModalBottomSheetTitle
 import com.tangem.core.ui.decompose.ComposableContentComponent
 import com.tangem.core.ui.extensions.resourceReference
+import com.tangem.core.ui.extensions.stringReference
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.domain.walletconnect.model.WcPairRequest
+import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.features.walletconnect.connections.model.WcAppInfoModel
 import com.tangem.features.walletconnect.connections.routes.WcAppInfoRoutes
 import com.tangem.features.walletconnect.impl.R
@@ -30,9 +31,8 @@ internal class WcAppInfoContainerComponent(
 ) : AppComponentContext by appComponentContext, ComposableContentComponent {
 
     private val model: WcAppInfoModel = getOrCreateModel(params = params)
-    private val contentNavigation = StackNavigation<WcAppInfoRoutes>()
     private val contentStack = childStack(
-        source = contentNavigation,
+        source = model.contentNavigation,
         serializer = WcAppInfoRoutes.serializer(),
         initialConfiguration = WcAppInfoRoutes.AppInfo,
         childFactory = ::screenChild,
@@ -51,10 +51,17 @@ internal class WcAppInfoContainerComponent(
                 onDismissRequest = ::dismiss,
                 content = content.active.configuration,
             ),
-            containerColor = TangemTheme.colors.background.tertiary,
+            onBack = ::contentBack,
+            containerColor = when (content.active.configuration) {
+                is WcAppInfoRoutes.Alert,
+                is WcAppInfoRoutes.SelectNetworks,
+                is WcAppInfoRoutes.AppInfo,
+                -> TangemTheme.colors.background.tertiary
+                is WcAppInfoRoutes.SelectWallet -> TangemTheme.colors.background.primary
+            },
             title = { config -> Title(route = config) },
             content = {
-                Children(stack = content, animation = stackAnimation()) { child ->
+                Children(modifier = Modifier.animateContentSize(), stack = content) { child ->
                     child.instance.Content(modifier = Modifier)
                 }
             },
@@ -64,7 +71,12 @@ internal class WcAppInfoContainerComponent(
     @Composable
     private fun Title(route: WcAppInfoRoutes) {
         TangemModalBottomSheetTitle(
-            title = resourceReference(R.string.wc_wallet_connect),
+            title = when (route) {
+                is WcAppInfoRoutes.Alert -> null
+                WcAppInfoRoutes.AppInfo -> resourceReference(R.string.wc_wallet_connect)
+                WcAppInfoRoutes.SelectNetworks -> TODO("[REDACTED_TASK_KEY]")
+                WcAppInfoRoutes.SelectWallet -> stringReference("Choose wallet")
+            },
             startIconRes = when (route) {
                 is WcAppInfoRoutes.AppInfo, is WcAppInfoRoutes.Alert -> null
                 is WcAppInfoRoutes.SelectNetworks, is WcAppInfoRoutes.SelectWallet -> R.drawable.ic_back_24
@@ -88,19 +100,25 @@ internal class WcAppInfoContainerComponent(
     }
 
     private fun contentBack() {
-        contentNavigation.pop()
+        if (contentStack.value.active.configuration == WcAppInfoRoutes.AppInfo) {
+            dismiss()
+        } else {
+            model.contentNavigation.pop()
+        }
     }
 
-    private fun screenChild(config: WcAppInfoRoutes, componentContext: ComponentContext): ComposableContentComponent =
-        when (config) {
-            is WcAppInfoRoutes.AppInfo -> WcAppInfoComponent(
-                appComponentContext = childByContext(componentContext),
-                model = model,
-            )
+    private fun screenChild(config: WcAppInfoRoutes, componentContext: ComponentContext): ComposableContentComponent {
+        val appComponentContext = childByContext(componentContext)
+        return when (config) {
+            is WcAppInfoRoutes.AppInfo -> WcAppInfoComponent(appComponentContext = appComponentContext, model = model)
             is WcAppInfoRoutes.Alert -> TODO()
             WcAppInfoRoutes.SelectNetworks -> TODO()
-            WcAppInfoRoutes.SelectWallet -> TODO()
+            WcAppInfoRoutes.SelectWallet -> WcSelectWalletComponent(
+                appComponentContext = appComponentContext,
+                model = model,
+            )
         }
+    }
 
-    data class Params(val wcUrl: String, val source: WcPairRequest.Source)
+    data class Params(val userWalletId: UserWalletId, val wcUrl: String, val source: WcPairRequest.Source)
 }

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/components/WcSelectWalletComponent.kt

@@ -0,0 +1,130 @@
+package com.tangem.features.walletconnect.connections.components
+
+import android.content.res.Configuration
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.tooling.preview.Devices
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.util.fastForEach
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.tangem.common.ui.userwallet.UserWalletItem
+import com.tangem.common.ui.userwallet.state.UserWalletItemUM
+import com.tangem.core.decompose.context.AppComponentContext
+import com.tangem.core.ui.components.block.TangemBlockCardColors
+import com.tangem.core.ui.decompose.ComposableContentComponent
+import com.tangem.core.ui.extensions.stringReference
+import com.tangem.core.ui.res.TangemTheme
+import com.tangem.core.ui.res.TangemThemePreview
+import com.tangem.domain.wallets.models.UserWalletId
+import com.tangem.features.walletconnect.connections.model.WcAppInfoModel
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+
+internal class WcSelectWalletComponent(
+    appComponentContext: AppComponentContext,
+    private val model: WcAppInfoModel,
+) : AppComponentContext by appComponentContext, ComposableContentComponent {
+
+    @Composable
+    override fun Content(modifier: Modifier) {
+        val walletsState by model.walletsUiState.collectAsStateWithLifecycle()
+        WcSelectWalletContent(
+            modifier = modifier.padding(start = 16.dp, end = 16.dp, bottom = 16.dp),
+            wallets = walletsState.wallets,
+            selectedWalletId = walletsState.selectedUserWallet.walletId,
+        )
+    }
+}
+
+@Composable
+private fun WcSelectWalletContent(
+    wallets: ImmutableList<UserWalletItemUM>,
+    selectedWalletId: UserWalletId,
+    modifier: Modifier = Modifier,
+) {
+    Column(modifier = modifier) {
+        wallets.fastForEach { state ->
+            key(state.id) {
+                val baseModifier = Modifier
+                    .clip(RoundedCornerShape(14.dp))
+                    .clickable(onClick = state.onClick)
+                val itemModifier = if (state.id == selectedWalletId) {
+                    baseModifier.border(
+                        width = 1.dp,
+                        color = TangemTheme.colors.text.accent,
+                        shape = RoundedCornerShape(14.dp),
+                    )
+                } else {
+                    baseModifier
+                }
+                UserWalletItem(
+                    modifier = itemModifier,
+                    state = state,
+                    blockColors = TangemBlockCardColors.copy(
+                        containerColor = Color.Unspecified,
+                        disabledContainerColor = Color.Unspecified,
+                    ),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+@Preview(showBackground = true, device = Devices.PIXEL_7_PRO)
+@Preview(showBackground = true, device = Devices.PIXEL_7_PRO, uiMode = Configuration.UI_MODE_NIGHT_YES)
+private fun WcSelectWalletContent_Preview() {
+    TangemThemePreview {
+        WcSelectWalletContent(
+            modifier = Modifier
+                .background(TangemTheme.colors.background.tertiary)
+                .padding(start = 16.dp, end = 16.dp, bottom = 16.dp),
+            selectedWalletId = UserWalletId("user_wallet_1".encodeToByteArray()),
+            wallets = persistentListOf(
+                UserWalletItemUM(
+                    id = UserWalletId("user_wallet_1".encodeToByteArray()),
+                    name = stringReference("Tangem 2.0"),
+                    information = stringReference("42 tokens"),
+                    balance = UserWalletItemUM.Balance.Loaded("1 496,34 \$", isFlickering = false),
+                    isEnabled = true,
+                    onClick = {},
+                ),
+                UserWalletItemUM(
+                    id = UserWalletId("user_wallet_2".encodeToByteArray()),
+                    name = stringReference("Tangem White"),
+                    information = stringReference("24 tokens"),
+                    balance = UserWalletItemUM.Balance.Loaded("1 496,34 \$", isFlickering = false),
+                    isEnabled = true,
+                    onClick = {},
+                ),
+                UserWalletItemUM(
+                    id = UserWalletId("user_wallet_3".encodeToByteArray()),
+                    name = stringReference("Bitcoin"),
+                    information = stringReference("1 token"),
+                    balance = UserWalletItemUM.Balance.Loaded("1 496,34 \$", isFlickering = false),
+                    isEnabled = true,
+                    onClick = {},
+                ),
+                UserWalletItemUM(
+                    id = UserWalletId("user_wallet_4".encodeToByteArray()),
+                    name = stringReference("Tangem 1.0"),
+                    information = stringReference("21 tokens"),
+                    balance = UserWalletItemUM.Balance.Loaded("1 496,34 \$", isFlickering = false),
+                    isEnabled = true,
+                    onClick = {},
+                ),
+            ),
+        )
+    }
+}

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/entity/WcAppInfoUM.kt

@@ -26,6 +26,7 @@ internal sealed class WcAppInfoUM : TangemBottomSheetConfigContent {
         val appSubtitle: String,
         val notification: WcAppInfoSecurityNotification?,
         val walletName: String,
+        val onWalletClick: () -> Unit,
         val networksInfo: WcNetworksInfo,
         override val connectButtonConfig: WcPrimaryButtonConfig,
         override val onDismiss: () -> Unit,

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/entity/WcAppInfoWalletUM.kt

@@ -0,0 +1,10 @@
+package com.tangem.features.walletconnect.connections.entity
+
+import com.tangem.common.ui.userwallet.state.UserWalletItemUM
+import com.tangem.domain.wallets.models.UserWallet
+import kotlinx.collections.immutable.ImmutableList
+
+internal data class WcAppInfoWalletUM(
+    val wallets: ImmutableList<UserWalletItemUM>,
+    val selectedUserWallet: UserWallet,
+)

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/model/WcAppInfoModel.kt

@@ -1,47 +1,98 @@
 package com.tangem.features.walletconnect.connections.model
 
 import androidx.compose.runtime.Stable
+import com.arkivanov.decompose.router.stack.StackNavigation
+import com.arkivanov.decompose.router.stack.pop
+import com.arkivanov.decompose.router.stack.pushNew
+import com.tangem.common.ui.userwallet.state.UserWalletItemUM
 import com.tangem.core.decompose.di.ModelScoped
 import com.tangem.core.decompose.model.Model
 import com.tangem.core.decompose.model.ParamsContainer
 import com.tangem.core.decompose.navigation.Router
+import com.tangem.core.decompose.ui.UiMessageSender
+import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
+import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
+import com.tangem.domain.tokens.GetWalletTotalBalanceUseCase
 import com.tangem.domain.walletconnect.model.WcPairRequest
 import com.tangem.domain.walletconnect.model.WcSessionApprove
 import com.tangem.domain.walletconnect.model.WcSessionProposal
 import com.tangem.domain.walletconnect.usecase.pair.WcPairState
 import com.tangem.domain.walletconnect.usecase.pair.WcPairUseCase
 import com.tangem.domain.wallets.models.UserWallet
+import com.tangem.domain.wallets.models.UserWalletId
+import com.tangem.domain.wallets.usecase.GetCardImageUseCase
+import com.tangem.domain.wallets.usecase.GetWalletsUseCase
 import com.tangem.features.walletconnect.connections.components.WcAppInfoContainerComponent
 import com.tangem.features.walletconnect.connections.entity.WcAppInfoUM
+import com.tangem.features.walletconnect.connections.entity.WcAppInfoWalletUM
 import com.tangem.features.walletconnect.connections.entity.WcPrimaryButtonConfig
 import com.tangem.features.walletconnect.connections.model.transformers.WcAppInfoTransformer
+import com.tangem.features.walletconnect.connections.model.transformers.WcAppInfoWalletChangedTransformer
 import com.tangem.features.walletconnect.connections.model.transformers.WcConnectButtonProgressTransformer
+import com.tangem.features.walletconnect.connections.routes.WcAppInfoRoutes
+import com.tangem.features.walletconnect.connections.utils.WcUserWalletsFetcher
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
 import kotlinx.coroutines.flow.*
 import javax.inject.Inject
 import kotlin.properties.Delegates
 import com.tangem.utils.transformer.update as transformerUpdate
 
+@Suppress("LongParameterList")
 @Stable
 @ModelScoped
 internal class WcAppInfoModel @Inject constructor(
+    private val router: Router,
     override val dispatchers: CoroutineDispatcherProvider,
     wcPairUseCaseFactory: WcPairUseCase.Factory,
-    private val router: Router,
+    getWalletsUseCase: GetWalletsUseCase,
+    getWalletTotalBalanceUseCase: GetWalletTotalBalanceUseCase,
+    getSelectedAppCurrencyUseCase: GetSelectedAppCurrencyUseCase,
+    getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
+    messageSender: UiMessageSender,
+    getCardImageUseCase: GetCardImageUseCase,
     paramsContainer: ParamsContainer,
 ) : Model() {
 
     private val params: WcAppInfoContainerComponent.Params = paramsContainer.require()
-    private val wcPairUseCase = wcPairUseCaseFactory.create(WcPairRequest(uri = params.wcUrl, source = params.source))
+    private val wcPairUseCase = wcPairUseCaseFactory.create(
+        WcPairRequest(
+            userWalletId = params.userWalletId,
+            uri = params.wcUrl,
+            source = params.source,
+        ),
+    )
+    private val userWalletsFetcher = WcUserWalletsFetcher(
+        getWalletsUseCase = getWalletsUseCase,
+        getWalletTotalBalanceUseCase = getWalletTotalBalanceUseCase,
+        getSelectedAppCurrencyUseCase = getSelectedAppCurrencyUseCase,
+        getBalanceHidingSettingsUseCase = getBalanceHidingSettingsUseCase,
+        messageSender = messageSender,
+        getCardImageUseCase = getCardImageUseCase,
+        onWalletSelected = ::onWalletSelected,
+    )
+
+    private val selectedUserWalletFlow =
+        MutableStateFlow(getWalletsUseCase.invokeSync().first { it.walletId == params.userWalletId })
+    // TODO(wc) Doston: Temp solution, will be fixed in next PR`s
+    private var proposalNetwork by Delegates.notNull<WcSessionProposal.ProposalNetwork>()
+    internal var sessionProposal by Delegates.notNull<WcSessionProposal>()
+
+    // UI states
+    internal val contentNavigation = StackNavigation<WcAppInfoRoutes>()
     val appInfoUiState: StateFlow<WcAppInfoUM>
     field = MutableStateFlow<WcAppInfoUM>(createLoadingState())
-
-    // TODO(wc) Doston: Temp solution, will be fixed in next PR`s
-    private var userWallet by Delegates.notNull<UserWallet>()
-    private var proposalNetwork by Delegates.notNull<WcSessionProposal.ProposalNetwork>()
+    val walletsUiState: StateFlow<WcAppInfoWalletUM>
+    field = MutableStateFlow(WcAppInfoWalletUM(persistentListOf(), selectedUserWalletFlow.value))
 
     init {
         loadDAppInfo()
+        combine(
+            flow = userWalletsFetcher.userWallets,
+            flow2 = selectedUserWalletFlow,
+            transform = ::updateWalletsState,
+        ).launchIn(modelScope)
     }
 
     private fun loadDAppInfo() {
@@ -62,14 +113,15 @@ internal class WcAppInfoModel @Inject constructor(
                     }
                     is WcPairState.Loading -> appInfoUiState.update { createLoadingState() }
                     is WcPairState.Proposal -> {
-                        userWallet = state.dAppSession.proposalNetwork.keys.first { !it.isLocked }
-                        proposalNetwork = state.dAppSession.proposalNetwork.getValue(userWallet)
+                        sessionProposal = state.dAppSession
+                        proposalNetwork = sessionProposal.proposalNetwork.getValue(selectedUserWalletFlow.value)
                         appInfoUiState.transformerUpdate(
                             WcAppInfoTransformer(
                                 dAppSession = state.dAppSession,
                                 onDismiss = ::dismiss,
                                 onConnect = ::onConnect,
-                                userWallet = userWallet,
+                                onWalletClick = { contentNavigation.pushNew(WcAppInfoRoutes.SelectWallet) },
+                                userWallet = selectedUserWalletFlow.value,
                                 proposalNetwork = proposalNetwork,
                             ),
                         )
@@ -87,13 +139,24 @@ internal class WcAppInfoModel @Inject constructor(
     private fun onConnect() {
         wcPairUseCase.approve(
             WcSessionApprove(
-                wallet = userWallet,
-                network =
-                proposalNetwork.required.plus(proposalNetwork.available).toList(),
+                wallet = selectedUserWalletFlow.value,
+                network = proposalNetwork.required.plus(proposalNetwork.available).toList(),
             ),
         )
     }
 
+    private fun onWalletSelected(userWalletId: UserWalletId) {
+        val selectedUserWallet = sessionProposal.proposalNetwork.keys.first { it.walletId == userWalletId }
+        selectedUserWalletFlow.update { selectedUserWallet }
+        proposalNetwork = sessionProposal.proposalNetwork.getValue(selectedUserWallet)
+        appInfoUiState.transformerUpdate(WcAppInfoWalletChangedTransformer(selectedUserWallet, proposalNetwork))
+        contentNavigation.pop()
+    }
+
+    private fun updateWalletsState(items: ImmutableList<UserWalletItemUM>, userWallet: UserWallet) {
+        walletsUiState.update { state -> state.copy(wallets = items, selectedUserWallet = userWallet) }
+    }
+
     private fun createLoadingState(): WcAppInfoUM.Loading {
         return WcAppInfoUM.Loading(
             onDismiss = ::dismiss,

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/model/WcConnectionsModel.kt

@@ -6,6 +6,7 @@ import com.arkivanov.decompose.router.slot.activate
 import com.tangem.common.routing.AppRoute
 import com.tangem.core.decompose.di.ModelScoped
 import com.tangem.core.decompose.model.Model
+import com.tangem.core.decompose.model.ParamsContainer
 import com.tangem.core.decompose.navigation.Router
 import com.tangem.core.decompose.ui.UiMessageSender
 import com.tangem.core.ui.components.appbar.models.TopAppBarButtonUM
@@ -16,11 +17,12 @@ import com.tangem.core.ui.message.EventMessageAction
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.domain.qrscanning.models.SourceType
 import com.tangem.domain.qrscanning.usecases.ListenToQrScanningUseCase
-import com.tangem.domain.walletconnect.model.WcSession
 import com.tangem.domain.walletconnect.WcPairService
 import com.tangem.domain.walletconnect.model.WcPairRequest
+import com.tangem.domain.walletconnect.model.WcSession
 import com.tangem.domain.walletconnect.usecase.WcSessionsUseCase
 import com.tangem.domain.walletconnect.usecase.disconnect.WcDisconnectUseCase
+import com.tangem.features.walletconnect.connections.components.ConnectionsComponent
 import com.tangem.features.walletconnect.connections.entity.WcConnectionsState
 import com.tangem.features.walletconnect.connections.entity.WcConnectionsTopAppBarConfig
 import com.tangem.features.walletconnect.connections.model.transformers.WcSessionsTransformer
@@ -44,8 +46,10 @@ internal class WcConnectionsModel @Inject constructor(
     private val wcDisconnectUseCase: WcDisconnectUseCase,
     private val wcPairService: WcPairService,
     override val dispatchers: CoroutineDispatcherProvider,
+    paramsContainer: ParamsContainer,
 ) : Model() {
 
+    private val params = paramsContainer.require<ConnectionsComponent.Params>()
     val uiState: StateFlow<WcConnectionsState>
     field = MutableStateFlow<WcConnectionsState>(getInitialState())
     val bottomSheetNavigation: SlotNavigation<WcConnectionsBottomSheetConfig> = SlotNavigation()
@@ -58,7 +62,15 @@ internal class WcConnectionsModel @Inject constructor(
     private fun listenQrUpdates() {
         listenToQrScanningUseCase(SourceType.WALLET_CONNECT)
             .getOrElse { emptyFlow() }
-            .onEach { wcUrl -> wcPairService.pair(WcPairRequest(wcUrl, WcPairRequest.Source.QR)) }
+            .onEach { wcUrl ->
+                wcPairService.pair(
+                    WcPairRequest(
+                        userWalletId = params.userWalletId,
+                        uri = wcUrl,
+                        source = WcPairRequest.Source.QR,
+                    ),
+                )
+            }
             .launchIn(modelScope)
     }
 

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/model/transformers/WcAppInfoTransformer.kt

@@ -1,17 +1,16 @@
 package com.tangem.features.walletconnect.connections.model.transformers
 
 import com.domain.blockaid.models.dapp.CheckDAppResult
-import com.tangem.core.ui.extensions.iconResId
 import com.tangem.domain.walletconnect.model.WcSessionProposal
 import com.tangem.domain.wallets.models.UserWallet
 import com.tangem.features.walletconnect.connections.entity.*
 import com.tangem.utils.transformer.Transformer
-import kotlinx.collections.immutable.toImmutableList
 
 internal class WcAppInfoTransformer(
     private val dAppSession: WcSessionProposal,
     private val onDismiss: () -> Unit,
     private val onConnect: () -> Unit,
+    private val onWalletClick: () -> Unit,
     private val userWallet: UserWallet,
     private val proposalNetwork: WcSessionProposal.ProposalNetwork,
 ) : Transformer<WcAppInfoUM> {
@@ -24,7 +23,8 @@ internal class WcAppInfoTransformer(
             appSubtitle = dAppSession.dAppMetaData.description,
             notification = createNotification(dAppSession.securityStatus),
             walletName = userWallet.name,
-            networksInfo = convertNetworksInfo(proposalNetwork),
+            onWalletClick = onWalletClick,
+            networksInfo = WcNetworksInfoConverter.convert(proposalNetwork),
             connectButtonConfig = WcPrimaryButtonConfig(
                 showProgress = false,
                 enabled = proposalNetwork.missingRequired.isEmpty(),
@@ -41,26 +41,4 @@ internal class WcAppInfoTransformer(
             CheckDAppResult.FAILED_TO_VERIFY -> WcAppInfoSecurityNotification.UnknownDomain
         }
     }
-
-    private fun convertNetworksInfo(proposalNetwork: WcSessionProposal.ProposalNetwork): WcNetworksInfo {
-        return if (proposalNetwork.missingRequired.isNotEmpty()) {
-            WcNetworksInfo.MissingRequiredNetworkInfo(
-                networks = proposalNetwork.missingRequired
-                    .joinToString { it.name },
-            )
-        } else {
-            WcNetworksInfo.ContainsAllRequiredNetworks(
-                items = (proposalNetwork.required + proposalNetwork.available)
-                    .map {
-                        WcNetworkInfoItem(
-                            id = it.id.value,
-                            icon = it.iconResId,
-                            name = it.name,
-                            symbol = it.currencySymbol,
-                        )
-                    }
-                    .toImmutableList(),
-            )
-        }
-    }
 }

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/model/transformers/WcAppInfoWalletChangedTransformer.kt

@@ -0,0 +1,22 @@
+package com.tangem.features.walletconnect.connections.model.transformers
+
+import com.tangem.domain.walletconnect.model.WcSessionProposal
+import com.tangem.domain.wallets.models.UserWallet
+import com.tangem.features.walletconnect.connections.entity.WcAppInfoUM
+import com.tangem.utils.transformer.Transformer
+
+internal class WcAppInfoWalletChangedTransformer(
+    private val selectedUserWallet: UserWallet,
+    private val proposalNetwork: WcSessionProposal.ProposalNetwork,
+) : Transformer<WcAppInfoUM> {
+    override fun transform(prevState: WcAppInfoUM): WcAppInfoUM {
+        val contentState = prevState as? WcAppInfoUM.Content ?: return prevState
+        return contentState.copy(
+            walletName = selectedUserWallet.name,
+            networksInfo = WcNetworksInfoConverter.convert(proposalNetwork),
+            connectButtonConfig = prevState.connectButtonConfig.copy(
+                enabled = proposalNetwork.missingRequired.isEmpty(),
+            ),
+        )
+    }
+}

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/model/transformers/WcNetworksInfoConverter.kt

@@ -0,0 +1,32 @@
+package com.tangem.features.walletconnect.connections.model.transformers
+
+import com.tangem.core.ui.extensions.iconResId
+import com.tangem.domain.walletconnect.model.WcSessionProposal
+import com.tangem.features.walletconnect.connections.entity.WcNetworkInfoItem
+import com.tangem.features.walletconnect.connections.entity.WcNetworksInfo
+import com.tangem.utils.converter.Converter
+import kotlinx.collections.immutable.toImmutableList
+
+internal object WcNetworksInfoConverter : Converter<WcSessionProposal.ProposalNetwork, WcNetworksInfo> {
+    override fun convert(value: WcSessionProposal.ProposalNetwork): WcNetworksInfo {
+        return if (value.missingRequired.isNotEmpty()) {
+            WcNetworksInfo.MissingRequiredNetworkInfo(
+                networks = value.missingRequired
+                    .joinToString { it.name },
+            )
+        } else {
+            WcNetworksInfo.ContainsAllRequiredNetworks(
+                items = (value.required + value.available)
+                    .map {
+                        WcNetworkInfoItem(
+                            id = it.id.value,
+                            icon = it.iconResId,
+                            name = it.name,
+                            symbol = it.currencySymbol,
+                        )
+                    }
+                    .toImmutableList(),
+            )
+        }
+    }
+}

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/routing/DefaultWcRoutingComponent.kt

@@ -61,7 +61,11 @@ internal class DefaultWcRoutingComponent @AssistedInject constructor(
             )
             is WcInnerRoute.Pair -> WcAppInfoContainerComponent(
                 childContext,
-                WcAppInfoContainerComponent.Params(config.request.uri, config.request.source),
+                WcAppInfoContainerComponent.Params(
+                    userWalletId = config.request.userWalletId,
+                    wcUrl = config.request.uri,
+                    source = config.request.source,
+                ),
             )
         }
     }

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/ui/WcAppInfoContent.kt

@@ -220,7 +220,12 @@ private fun WcAppInfoSecondBlock(state: WcAppInfoUM.Content, modifier: Modifier
         val itemsModifier = Modifier
             .fillMaxWidth()
             .padding(TangemTheme.dimens.spacing12)
-        WalletRowItem(modifier = itemsModifier, walletName = state.walletName)
+        WalletRowItem(
+            modifier = Modifier
+                .clickable(onClick = state.onWalletClick)
+                .then(itemsModifier),
+            walletName = state.walletName,
+        )
         HorizontalDivider(thickness = 1.dp, color = TangemTheme.colors.stroke.primary)
         SelectNetworksBlock(
             networksInfo = state.networksInfo,
@@ -565,6 +570,7 @@ private class WcAppInfoStateProvider : CollectionPreviewParameterProvider<WcAppI
             appSubtitle = "react-app.walletconnect.com",
             notification = WcAppInfoSecurityNotification.SecurityRisk,
             walletName = "Tangem 2.0",
+            onWalletClick = {},
             networksInfo = WcNetworksInfo.ContainsAllRequiredNetworks(
                 items = persistentListOf(
                     WcNetworkInfoItem(
@@ -604,6 +610,7 @@ private class WcAppInfoStateProvider : CollectionPreviewParameterProvider<WcAppI
             appSubtitle = "react-app.walletconnect.com",
             notification = WcAppInfoSecurityNotification.UnknownDomain,
             walletName = "Tangem 2.0",
+            onWalletClick = {},
             networksInfo = WcNetworksInfo.MissingRequiredNetworkInfo(networks = "Solana"),
             onDismiss = {},
             connectButtonConfig = WcPrimaryButtonConfig(showProgress = false, enabled = true, onClick = {}),

features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/utils/WcUserWalletsFetcher.kt

@@ -0,0 +1,137 @@
+package com.tangem.features.walletconnect.connections.utils
+
+import arrow.core.Either
+import com.tangem.common.ui.userwallet.converter.UserWalletItemUMConverter
+import com.tangem.common.ui.userwallet.state.UserWalletItemUM
+import com.tangem.core.decompose.di.ModelScoped
+import com.tangem.core.decompose.ui.UiMessageSender
+import com.tangem.core.ui.extensions.resourceReference
+import com.tangem.core.ui.message.SnackbarMessage
+import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
+import com.tangem.domain.appcurrency.error.SelectedAppCurrencyError
+import com.tangem.domain.appcurrency.model.AppCurrency
+import com.tangem.domain.balancehiding.BalanceHidingSettings
+import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
+import com.tangem.domain.core.lce.Lce
+import com.tangem.domain.core.lce.lce
+import com.tangem.domain.core.utils.getOrElse
+import com.tangem.domain.core.utils.toLce
+import com.tangem.domain.models.ArtworkModel
+import com.tangem.domain.tokens.GetWalletTotalBalanceUseCase
+import com.tangem.domain.tokens.error.TokenListError
+import com.tangem.domain.tokens.model.TotalFiatBalance
+import com.tangem.domain.wallets.models.UserWallet
+import com.tangem.domain.wallets.models.UserWalletId
+import com.tangem.domain.wallets.usecase.GetCardImageUseCase
+import com.tangem.domain.wallets.usecase.GetWalletsUseCase
+import com.tangem.features.walletconnect.impl.R
+import com.tangem.operations.attestation.ArtworkSize
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.*
+
+@Suppress("LongParameterList")
+@ModelScoped
+internal class WcUserWalletsFetcher(
+    getWalletsUseCase: GetWalletsUseCase,
+    private val getWalletTotalBalanceUseCase: GetWalletTotalBalanceUseCase,
+    private val getSelectedAppCurrencyUseCase: GetSelectedAppCurrencyUseCase,
+    private val getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
+    private val messageSender: UiMessageSender,
+    private val getCardImageUseCase: GetCardImageUseCase,
+    private val onWalletSelected: (UserWalletId) -> Unit,
+) {
+
+    private var loadedArtworks: HashMap<UserWalletId, ArtworkModel> = hashMapOf()
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    val userWallets: Flow<ImmutableList<UserWalletItemUM>> = getWalletsUseCase().transformLatest { wallets ->
+        val uiModels = UserWalletItemUMConverter(onClick = onWalletSelected)
+            .convertList(wallets)
+            .toImmutableList()
+
+        emit(uiModels)
+        combine(
+            flow = getSelectedAppCurrencyUseCase().distinctUntilChanged(),
+            flow2 = getBalanceHidingSettingsUseCase().distinctUntilChanged(),
+            flow3 = getWalletTotalBalanceUseCase(wallets.map(UserWallet::walletId)).distinctUntilChanged(),
+            flow4 = loadArtworks(wallets),
+        ) { maybeAppCurrency, balanceHidingSettings, maybeBalances, artworks ->
+            val models = createUiModels(
+                wallets = wallets,
+                maybeAppCurrency = maybeAppCurrency,
+                maybeBalances = maybeBalances,
+                balanceHidingSettings = balanceHidingSettings,
+                artworks = artworks,
+            ).getOrElse(
+                ifLoading = { return@combine },
+                ifError = {
+                    val message = resourceReference(R.string.common_unknown_error)
+                    messageSender.send(SnackbarMessage(message))
+
+                    return@combine
+                },
+            )
+
+            emit(models)
+        }.collect()
+    }
+
+    private fun loadArtworks(wallets: List<UserWallet>): Flow<HashMap<UserWalletId, ArtworkModel>> {
+        return flow {
+            emit(hashMapOf()) // emits right away so the transform doesn't wait for the images' loading to finish
+            wallets.forEach { wallet ->
+                val artwork = getCardImageUseCase(
+                    cardId = wallet.cardId,
+                    cardPublicKey = wallet.scanResponse.card.cardPublicKey,
+                    size = ArtworkSize.SMALL,
+                )
+                loadedArtworks[wallet.walletId] = artwork
+                emit(loadedArtworks)
+            }
+        }
+    }
+
+    private fun createUiModels(
+        wallets: List<UserWallet>,
+        maybeAppCurrency: Either<SelectedAppCurrencyError, AppCurrency>,
+        maybeBalances: Lce<TokenListError, Map<UserWalletId, TotalFiatBalance>>,
+        balanceHidingSettings: BalanceHidingSettings,
+        artworks: HashMap<UserWalletId, ArtworkModel>,
+    ): Lce<Error, ImmutableList<UserWalletItemUM>> = lce {
+        val balances = withError(
+            transform = { Error.UnableToGetBalances },
+            block = {
+                maybeBalances.bindOrNull().orEmpty()
+                    .filterKeys { userWalletId -> wallets.any { it.walletId == userWalletId } }
+                    .mapKeys { entry -> wallets.first { it.walletId == entry.key } }
+            },
+        )
+
+        val appCurrency = withError(
+            transform = { Error.UnableToGetAppCurrency },
+            block = { maybeAppCurrency.toLce().bind() },
+        )
+
+        balances
+            .map { (userWallet, balance) ->
+                UserWalletItemUMConverter(
+                    onClick = onWalletSelected,
+                    appCurrency = appCurrency,
+                    balance = balance,
+                    isBalanceHidden = balanceHidingSettings.isBalanceHidden,
+                    artwork = artworks[userWallet.walletId],
+                )
+                    .convert(userWallet)
+            }
+            .toImmutableList()
+    }
+
+    sealed class Error {
+
+        data object UnableToGetAppCurrency : Error()
+
+        data object UnableToGetBalances : Error()
+    }
+}