Updated on 2026-08-14

2025-05-06 12:59:42 +03:00 · 2025-05-06 12:59:42 +03:00 · 91bcf5d117
commit 91bcf5d117
parent 5e58fca478 bc3e0b799c
50 changed files with 887 additions and 198 deletions
--- a/features/details/impl/src/main/kotlin/com/tangem/features/details/component/preview/PreviewDetailsComponent.kt
+++ b/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(
--- a/features/details/impl/src/main/kotlin/com/tangem/features/details/model/DetailsModel.kt
+++ b/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,
            ),
--- a/features/details/impl/src/main/kotlin/com/tangem/features/details/utils/ItemsBuilder.kt
+++ b/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
--- a/features/walletconnect/api/src/main/kotlin/com/tangem/features/walletconnect/components/WalletConnectEntryComponent.kt
+++ b/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>
 }
--- a/features/walletconnect/impl/build.gradle.kts
+++ b/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)
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/components/ConnectionsComponent.kt
+++ b/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)
 }
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/components/DefaultWalletConnectEntryComponent.kt
+++ b/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
    }
 }
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/components/WcAppInfoContainerComponent.kt
+++ b/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)
 }
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/components/WcSelectWalletComponent.kt
+++ b/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 = {},
+                ),
+            ),
+        )
+    }
+}
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/entity/WcAppInfoUM.kt
+++ b/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,
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/entity/WcAppInfoWalletUM.kt
+++ b/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,
+)
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/model/WcAppInfoModel.kt
+++ b/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,
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/model/WcConnectionsModel.kt
+++ b/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)
    }

--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/model/transformers/WcAppInfoTransformer.kt
+++ b/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(),
-            )
-        }
-    }
 }
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/model/transformers/WcAppInfoWalletChangedTransformer.kt
+++ b/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(),
+            ),
+        )
+    }
+}
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/model/transformers/WcNetworksInfoConverter.kt
+++ b/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(),
+            )
+        }
+    }
+}
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/routing/DefaultWcRoutingComponent.kt
+++ b/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,
+                ),
            )
        }
    }
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/ui/WcAppInfoContent.kt
+++ b/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 = {}),
--- a/features/walletconnect/impl/src/main/kotlin/com/tangem/features/walletconnect/connections/utils/WcUserWalletsFetcher.kt
+++ b/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()
+    }
+}