Updated on 2026-08-14

2023-03-02 00:22:28 +04:00 · 2023-03-02 00:22:28 +04:00 · 92064843db
commit 92064843db
parent e77eff8935
67 changed files with 2232 additions and 337 deletions
--- a/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectAction.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectAction.kt
@ -4,6 +4,10 @@ import com.tangem.blockchain.common.Blockchain
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.tap.common.redux.NotificationAction
 import com.tangem.tap.domain.TapError
+import com.tangem.tap.domain.walletconnect.Topic
+import com.tangem.tap.domain.walletconnect2.domain.WcPreparedRequest
+import com.tangem.tap.domain.walletconnect2.domain.models.WalletConnectError
+import com.tangem.tap.features.details.ui.walletconnect.WcSessionForScreen
 import com.tangem.wallet.R
 import com.trustwallet.walletconnect.models.binance.WCBinanceTradeOrder
 import com.trustwallet.walletconnect.models.binance.WCBinanceTransferOrder
@ -58,7 +62,7 @@ sealed class WalletConnectAction : Action {
    data class SetSessionsRestored(val sessions: List<WalletConnectSession>) :
        WalletConnectAction()

-    data class DisconnectSession(val session: WCSession) : WalletConnectAction()
+    data class DisconnectSession(val topic: String, val session: WCSession?) : WalletConnectAction()

    data class RemoveSession(val session: WCSession) : WalletConnectAction()

@ -66,7 +70,7 @@ sealed class WalletConnectAction : Action {
        val transaction: WCEthereumTransaction,
        val session: WalletConnectSession,
        val id: Long,
-        val type: WcTransactionType,
+        val type: WcEthTransactionType,
    ) :
        WalletConnectAction()

@ -78,11 +82,11 @@ sealed class WalletConnectAction : Action {
        val id: Long,
    ) : WalletConnectAction()

-    data class SendTransaction(val session: WCSession) : WalletConnectAction()
+    data class SendTransaction(val topic: Topic) : WalletConnectAction()

-    data class SignMessage(val session: WCSession) : WalletConnectAction()
+    data class SignMessage(val topic: Topic) : WalletConnectAction()

-    data class RejectRequest(val session: WCSession, val id: Long) : WalletConnectAction()
+    data class RejectRequest(val topic: Topic, val id: Long) : WalletConnectAction()

    object NotEnoughFunds : WalletConnectAction(), NotificationAction {
        override val messageResource = R.string.wallet_connect_create_tx_not_enough_funds
@ -108,7 +112,22 @@ sealed class WalletConnectAction : Action {
        data class Sign(
            val id: Long,
            val data: ByteArray,
-            val sessionData: WCSession,
+            val topic: Topic,
        ) : WalletConnectAction()
    }
+
+    //region WalletConnect 2.0
+    object ApproveProposal : WalletConnectAction()
+    object RejectProposal : WalletConnectAction()
+
+    object SessionEstablished : WalletConnectAction()
+    data class SessionRejected(val error: WalletConnectError) : WalletConnectAction()
+    data class SessionListUpdated(val sessions: List<WcSessionForScreen>) : WalletConnectAction()
+
+    data class ShowSessionRequest(val sessionRequest: WcPreparedRequest) : WalletConnectAction()
+
+    object RejectUnsupportedRequest : WalletConnectAction()
+
+    data class PerformRequestedAction(val sessionRequest: WcPreparedRequest) : WalletConnectAction()
+    //endregion WalletConnect 2.0
 }
--- a/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectMiddleware.kt
@ -5,8 +5,10 @@ import com.tangem.blockchain.common.DerivationStyle
 import com.tangem.blockchain.common.WalletManager
 import com.tangem.common.extensions.guard
 import com.tangem.domain.common.TapWorkarounds.derivationStyle
-import com.tangem.domain.common.util.cardTypesResolver
+import com.tangem.domain.common.extensions.fromNetworkId
+import com.tangem.domain.common.extensions.toNetworkId
 import com.tangem.domain.common.extensions.withMainContext
+import com.tangem.domain.common.util.cardTypesResolver
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.tap.common.extensions.dispatchOnMain
@ -19,8 +21,16 @@ import com.tangem.tap.domain.tokens.models.BlockchainNetwork
 import com.tangem.tap.domain.walletconnect.BnbHelper
 import com.tangem.tap.domain.walletconnect.WalletConnectManager
 import com.tangem.tap.domain.walletconnect.WalletConnectNetworkUtils
+import com.tangem.tap.domain.walletconnect.extensions.toWcEthTransaction
+import com.tangem.tap.domain.walletconnect2.domain.WalletConnectInteractor
+import com.tangem.tap.domain.walletconnect2.domain.WalletConnectRepository
+import com.tangem.tap.domain.walletconnect2.domain.WcPreparedRequest
+import com.tangem.tap.domain.walletconnect2.domain.models.Account
+import com.tangem.tap.domain.walletconnect2.domain.models.BnbData
+import com.tangem.tap.domain.walletconnect2.domain.models.WalletConnectError
 import com.tangem.tap.features.demo.DemoHelper
 import com.tangem.tap.features.wallet.redux.WalletState
+import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.wallet.R
@ -29,8 +39,14 @@ import org.rekotlin.Action
 import org.rekotlin.Middleware
 import timber.log.Timber

+@Suppress("LargeClass")
 class WalletConnectMiddleware {
    private var walletConnectManager = WalletConnectManager()
+    private val walletConnectInteractor: WalletConnectInteractor
+        get() = store.state.daggerGraphState.get(DaggerGraphState::walletConnectInteractor)
+    private val walletConnectRepository: WalletConnectRepository
+        get() = store.state.daggerGraphState.get(DaggerGraphState::walletConnectRepository)
+
    val walletConnectMiddleware: Middleware<AppState> = { dispatch, state ->
        { next ->
            { action ->
@ -115,9 +131,13 @@ class WalletConnectMiddleware {
                store.dispatchOnMain(GlobalAction.ShowDialog(WalletConnectDialog.UnsupportedCard))
            }
            is WalletConnectAction.OpenSession -> {
-                walletConnectManager.connect(
-                    wcUri = action.wcUri,
-                )
+                val index = action.wcUri.indexOf("@")
+                when (action.wcUri[index + 1]) {
+                    '1' -> {
+                        walletConnectManager.connect(wcUri = action.wcUri)
+                    }
+                    '2' -> walletConnectRepository.pair(uri = action.wcUri)
+                }
            }
            is WalletConnectAction.RefuseOpeningSession -> {
                store.dispatch(
@ -134,11 +154,15 @@ class WalletConnectMiddleware {
                walletConnectManager.approve(action.session)
            }
            is WalletConnectAction.DisconnectSession -> {
-                walletConnectManager.disconnect(action.session)
+                if (action.session != null) {
+                    walletConnectManager.disconnect(action.session)
+                } else {
+                    walletConnectInteractor.disconnectSession(action.topic)
+                }
            }
            is WalletConnectAction.HandleTransactionRequest -> {
                walletConnectManager.handleTransactionRequest(
-                    transaction = action.transaction,
+                    transaction = action.transaction.toWcEthTransaction(),
                    session = action.session,
                    id = action.id,
                    type = action.type,
@ -152,23 +176,31 @@ class WalletConnectMiddleware {
                )
            }
            is WalletConnectAction.RejectRequest -> {
-                walletConnectManager.rejectRequest(action.session, action.id)
+                walletConnectManager.rejectRequest(action.topic, action.id)
+                walletConnectInteractor.rejectRequest(action.topic, action.id)
            }
            is WalletConnectAction.SendTransaction -> {
-                walletConnectManager.completeTransaction(action.session)
+                walletConnectManager.completeTransaction(action.topic)
            }
            is WalletConnectAction.SignMessage -> {
-                walletConnectManager.sendSignedMessage(action.session)
+                walletConnectManager.sendSignedMessage(action.topic)
            }
            is WalletConnectAction.BinanceTransaction.Trade -> {
                val messageData = BnbHelper.createMessageData(action.order)
                store.dispatchOnMain(
                    GlobalAction.ShowDialog(
                        WalletConnectDialog.BnbTransactionDialog(
-                            data = messageData,
-                            session = action.sessionData.session,
-                            sessionId = action.id,
-                            dAppName = action.sessionData.peerMeta.name,
+                            WcPreparedRequest.BnbTransaction(
+                                preparedRequestData = BnbData(
+                                    data = messageData,
+                                    topic = action.sessionData.session.topic,
+                                    requestId = action.id,
+                                    dAppName = action.sessionData.peerMeta.name,
+                                ),
+                                topic = action.sessionData.session.topic,
+                                requestId = action.id,
+                                derivationPath = action.sessionData.wallet.derivationPath?.rawPath,
+                            ),
                        ),
                    ),
                )
@ -178,10 +210,17 @@ class WalletConnectMiddleware {
                store.dispatchOnMain(
                    GlobalAction.ShowDialog(
                        WalletConnectDialog.BnbTransactionDialog(
-                            data = messageData,
-                            session = action.sessionData.session,
-                            sessionId = action.id,
-                            dAppName = action.sessionData.peerMeta.name,
+                            WcPreparedRequest.BnbTransaction(
+                                preparedRequestData = BnbData(
+                                    data = messageData,
+                                    topic = action.sessionData.session.topic,
+                                    requestId = action.id,
+                                    dAppName = action.sessionData.peerMeta.name,
+                                ),
+                                topic = action.sessionData.session.topic,
+                                requestId = action.id,
+                                derivationPath = action.sessionData.wallet.derivationPath?.rawPath,
+                            ),
                        ),
                    ),
                )
@ -190,7 +229,7 @@ class WalletConnectMiddleware {
                walletConnectManager.signBnb(
                    id = action.id,
                    data = action.data,
-                    sessionData = action.sessionData,
+                    topic = action.topic,
                )
            }
            is WalletConnectAction.SwitchBlockchain -> {
@ -226,6 +265,70 @@ class WalletConnectMiddleware {
            is WalletConnectAction.UpdateBlockchain -> {
                walletConnectManager.updateBlockchain(action.updatedSession)
            }
+            is WalletConnectAction.ApproveProposal -> {
+                val accounts = store.state.walletState.walletManagers
+                    .mapNotNull {
+                        val wallet = it.wallet
+                        val chainId = walletConnectInteractor.blockchainHelper.networkIdToChainIdOrNull(
+                            wallet.blockchain.toNetworkId(),
+                        )
+                        chainId?.let {
+                            Account(
+                                chainId,
+                                wallet.address,
+                                wallet.publicKey.derivationPath?.rawPath,
+                            )
+                        }
+                    }
+
+                walletConnectInteractor.approveSessionProposal(accounts)
+            }
+            is WalletConnectAction.RejectProposal -> {
+                walletConnectInteractor.rejectSessionProposal()
+            }
+            is WalletConnectAction.SessionEstablished -> {
+            }
+            is WalletConnectAction.SessionRejected -> {
+                when (action.error) {
+                    is WalletConnectError.ApprovalErrorAddNetwork -> {
+                        val blockchains = action.error.networks.mapNotNull { Blockchain.fromNetworkId(it)?.fullName }
+                        store.dispatchOnMain(
+                            GlobalAction.ShowDialog(
+                                WalletConnectDialog.AddNetwork(blockchains.toString()),
+                            ),
+                        )
+                    }
+
+                    WalletConnectError.ApprovalErrorUnsupportedNetwork -> {
+                        store.dispatchOnMain(GlobalAction.ShowDialog(WalletConnectDialog.UnsupportedNetwork))
+                    }
+                    is WalletConnectError.ExternalApprovalError -> {
+                        store.dispatchOnMain(
+                            GlobalAction.ShowDialog(
+                                AppDialog.SimpleOkWarningDialog(
+                                    message = action.error.message ?: "",
+                                ),
+                            ),
+                        )
+                    }
+                    else -> Unit
+                }
+            }
+
+            is WalletConnectAction.ShowSessionRequest -> {
+                val dialog: WalletConnectDialog = when (val request = action.sessionRequest) {
+                    is WcPreparedRequest.BnbTransaction -> WalletConnectDialog.BnbTransactionDialog(request)
+                    is WcPreparedRequest.EthTransaction -> WalletConnectDialog.RequestTransaction(request)
+                    is WcPreparedRequest.EthSign -> WalletConnectDialog.PersonalSign(request)
+                }
+                store.dispatch(GlobalAction.ShowDialog(dialog))
+            }
+            is WalletConnectAction.PerformRequestedAction -> {
+                scope.launch { walletConnectInteractor.continueWithRequest(action.sessionRequest) }
+            }
+            is WalletConnectAction.RejectUnsupportedRequest -> {
+                store.dispatchOnMain(GlobalAction.ShowDialog(WalletConnectDialog.UnsupportedNetwork))
+            }
        }
    }

--- a/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectReducer.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectReducer.kt
@ -27,15 +27,23 @@ object WalletConnectReducer {
                    state.sessions.filterNot { it.session.toUri() == action.session.toUri() }
                state.copy(sessions = sessions)
            }
-            is WalletConnectAction.UnsupportedCard -> state.copy(loading = false)
-            is WalletConnectAction.RefuseOpeningSession -> state.copy(loading = false)
-            is WalletConnectAction.OpeningSessionTimeout -> state.copy(loading = false)
-            is WalletConnectAction.FailureEstablishingSession -> state.copy(loading = false)
+            is WalletConnectAction.UnsupportedCard,
+            is WalletConnectAction.RefuseOpeningSession,
+            is WalletConnectAction.OpeningSessionTimeout,
+            is WalletConnectAction.FailureEstablishingSession,
+            -> state.copy(loading = false)
            is WalletConnectAction.UpdateBlockchain -> state.copy(
                sessions = state.sessions
                    .filterNot { it.peerId == action.updatedSession.peerId } + action.updatedSession,
            )
-
+            is WalletConnectAction.ApproveProposal -> state.copy(loading = true)
+            is WalletConnectAction.RejectProposal,
+            is WalletConnectAction.SessionEstablished,
+            is WalletConnectAction.SessionRejected,
+            -> state.copy(loading = false)
+            is WalletConnectAction.SessionListUpdated -> state.copy(
+                wc2Sessions = action.sessions,
+            )
            else -> state
        }
    }
--- a/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectState.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/redux/walletconnect/WalletConnectState.kt
@ -8,6 +8,10 @@ import com.tangem.blockchain.common.WalletManager
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.tap.common.redux.StateDialog
+import com.tangem.tap.domain.walletconnect2.domain.WcEthereumSignMessage
+import com.tangem.tap.domain.walletconnect2.domain.WcPreparedRequest
+import com.tangem.tap.domain.walletconnect2.domain.models.WalletConnectEvents
+import com.tangem.tap.features.details.ui.walletconnect.WcSessionForScreen
 import com.tangem.tap.features.details.ui.walletconnect.dialogs.PersonalSignDialogData
 import com.tangem.tap.features.details.ui.walletconnect.dialogs.TransactionRequestDialogData
 import com.trustwallet.walletconnect.models.WCPeerMeta
@ -16,6 +20,7 @@ import com.trustwallet.walletconnect.models.session.WCSession
 data class WalletConnectState(
    val loading: Boolean = false,
    val sessions: List<WalletConnectSession> = listOf(),
+    val wc2Sessions: List<WcSessionForScreen> = listOf(),
    val newSessionData: NewWcSessionData? = null,
 )

@ -95,43 +100,47 @@ sealed class WalletConnectDialog : StateDialog {
        val networks: List<Blockchain>,
    ) : WalletConnectDialog()

+    data class SessionProposalDialog(
+        val sessionProposal: WalletConnectEvents.SessionProposal,
+        val networks: String,
+        val onApprove: () -> Unit,
+        val onReject: () -> Unit,
+    ) : WalletConnectDialog()
+
    data class ChooseNetwork(
        val session: WalletConnectSession,
        val networks: List<Blockchain>,
    ) : WalletConnectDialog()

-    data class RequestTransaction(val dialogData: TransactionRequestDialogData) :
+    data class RequestTransaction(val data: WcPreparedRequest.EthTransaction) :
        WalletConnectDialog()

-    data class PersonalSign(val data: PersonalSignDialogData) : WalletConnectDialog()
+    data class PersonalSign(val data: WcPreparedRequest.EthSign) : WalletConnectDialog()
    data class BnbTransactionDialog(
-        val data: BinanceMessageData,
-        val session: WCSession,
-        val sessionId: Long,
-        val dAppName: String,
+        val data: WcPreparedRequest.BnbTransaction,
    ) : WalletConnectDialog()
 }

 data class WcTransactionData(
-    val type: WcTransactionType,
+    val type: WcEthTransactionType,
    val transaction: TransactionData,
-    val session: WalletConnectSession,
+    val topic: String,
    val id: Long,
    val walletManager: WalletManager,
    val dialogData: TransactionRequestDialogData,
 )

-enum class WcTransactionType {
+enum class WcEthTransactionType {
    EthSignTransaction,
    EthSendTransaction,
 }

 data class WcPersonalSignData(
    val hash: ByteArray,
-    val session: WalletConnectSession,
+    val topic: String,
    val id: Long,
    val dialogData: PersonalSignDialogData,
-
+    val type: WcEthereumSignMessage.WCSignType,
 )

 sealed class BinanceMessageData(
--- a/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/WalletConnectScreen.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/WalletConnectScreen.kt
@ -1,24 +1,11 @@
 package com.tangem.tap.features.details.ui.walletconnect

 import androidx.compose.foundation.Image
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.FloatingActionButton
-import androidx.compose.material.Icon
-import androidx.compose.material.IconButton
-import androidx.compose.material.LinearProgressIndicator
-import androidx.compose.material.Text
+import androidx.compose.material.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@ -36,6 +23,7 @@ import com.tangem.tap.common.analytics.events.Settings
 import com.tangem.tap.common.extensions.getFromClipboard
 import com.tangem.tap.features.details.ui.common.SettingsScreensScaffold
 import com.tangem.wallet.R
+import kotlinx.collections.immutable.persistentListOf

@Composable
 fun WalletConnectScreen(state: WalletConnectScreenState, onBackClick: () -> Unit) {
@ -164,7 +152,7 @@ private fun WalletConnectSessions(state: WalletConnectScreenState) {
 private fun WalletConnectScreenPreview() {
    WalletConnectScreen(
        state = WalletConnectScreenState(
-            sessions = listOf(
+            sessions = persistentListOf(
                WcSessionForScreen(
                    description = "session from some dApp",
                    sessionId = "",
--- a/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/WalletConnectScreenState.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/WalletConnectScreenState.kt
@ -1,9 +1,10 @@
 package com.tangem.tap.features.details.ui.walletconnect

 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectSession
+import kotlinx.collections.immutable.ImmutableList

 data class WalletConnectScreenState(
-    val sessions: List<WcSessionForScreen>,
+    val sessions: ImmutableList<WcSessionForScreen>,
    val isLoading: Boolean = false,
    val onRemoveSession: (String) -> Unit = {},
    val onAddSession: (String?) -> Unit = {},
--- a/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/WalletConnectViewModel.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/WalletConnectViewModel.kt
@ -4,23 +4,35 @@ import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectAction
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectSession
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectState
+import kotlinx.collections.immutable.toImmutableList
 import org.rekotlin.Store
+import timber.log.Timber

 class WalletConnectViewModel(private val store: Store<AppState>) {
    fun updateState(state: WalletConnectState): WalletConnectScreenState {
+        Timber.d("WC2 Sessions: ${state.wc2Sessions}")
+        val sessions = state.sessions.map { wcSession -> WcSessionForScreen.fromSession(wcSession) } + state.wc2Sessions
        return WalletConnectScreenState(
-            state.sessions.map { wcSession -> WcSessionForScreen.fromSession(wcSession) },
+            sessions.toImmutableList(),
            isLoading = state.loading,
-            onRemoveSession = { sessionUri -> onRemoveSession(sessionUri, state.sessions) },
+            onRemoveSession = { sessionUri -> onRemoveSession(sessionUri, state.sessions, state.wc2Sessions) },
            onAddSession = { copiedUri -> store.dispatch(WalletConnectAction.StartWalletConnect(copiedUri)) },
        )
    }

-    private fun onRemoveSession(sessionUri: String, sessions: List<WalletConnectSession>) {
+    private fun onRemoveSession(
+        sessionUri: String,
+        sessions: List<WalletConnectSession>,
+        wc2sessions: List<WcSessionForScreen>,
+    ) {
        sessions
            .firstOrNull { it.session.toUri() == sessionUri }
            ?.let { baseSession ->
-                store.dispatch(WalletConnectAction.DisconnectSession(baseSession.session))
+                store.dispatch(WalletConnectAction.DisconnectSession(baseSession.session.topic, baseSession.session))
+                return
            }
+        wc2sessions.firstOrNull { it.sessionId == sessionUri }?.let {
+            store.dispatch(WalletConnectAction.DisconnectSession(sessionUri, null))
+        }
    }
 }
--- a/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/dialogs/BnbTransactionDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/dialogs/BnbTransactionDialog.kt
@ -3,20 +3,15 @@ package com.tangem.tap.features.details.ui.walletconnect.dialogs
 import android.content.Context
 import androidx.appcompat.app.AlertDialog
 import com.tangem.tap.common.redux.global.GlobalAction
+import com.tangem.tap.domain.walletconnect2.domain.WcPreparedRequest
 import com.tangem.tap.features.details.redux.walletconnect.BinanceMessageData
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectAction
 import com.tangem.tap.store
 import com.tangem.wallet.R
-import com.trustwallet.walletconnect.models.session.WCSession

 object BnbTransactionDialog {
-    fun create(
-        data: BinanceMessageData,
-        session: WCSession,
-        sessionId: Long,
-        dAppName: String,
-        context: Context,
-    ): AlertDialog {
+    fun create(preparedData: WcPreparedRequest.BnbTransaction, context: Context): AlertDialog {
+        val data = preparedData.preparedRequestData.data
        val message = when (data) {
            is BinanceMessageData.Trade -> data.tradeData.map {
                context.getString(
@ -37,7 +32,7 @@ object BnbTransactionDialog {

        val fullMessage = context.getString(
            R.string.wallet_connect_bnb_sign_message,
-            dAppName,
+            preparedData.preparedRequestData.dAppName,
            message,
        )
        val positiveButtonTitle = context.getText(R.string.common_sign)
@ -48,14 +43,15 @@ object BnbTransactionDialog {
            setPositiveButton(positiveButtonTitle) { _, _ ->
                store.dispatch(
                    WalletConnectAction.BinanceTransaction.Sign(
-                        id = sessionId,
+                        id = preparedData.requestId,
                        data = data.data,
-                        sessionData = session,
+                        topic = preparedData.topic,
                    ),
                )
+                store.dispatch(WalletConnectAction.PerformRequestedAction(preparedData))
            }
            setNegativeButton(context.getText(R.string.common_reject)) { _, _ ->
-                store.dispatch(WalletConnectAction.RejectRequest(session, sessionId))
+                store.dispatch(WalletConnectAction.RejectRequest(preparedData.topic, preparedData.requestId))
            }
            setOnDismissListener {
                store.dispatch(GlobalAction.HideDialog)
--- a/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/dialogs/PersonalSignDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/dialogs/PersonalSignDialog.kt
@ -3,22 +3,24 @@ package com.tangem.tap.features.details.ui.walletconnect.dialogs
 import android.content.Context
 import androidx.appcompat.app.AlertDialog
 import com.tangem.tap.common.redux.global.GlobalAction
+import com.tangem.tap.domain.walletconnect2.domain.WcPreparedRequest
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectAction
 import com.tangem.tap.store
 import com.tangem.wallet.R
-import com.trustwallet.walletconnect.models.session.WCSession

 object PersonalSignDialog {
-    fun create(data: PersonalSignDialogData, context: Context): AlertDialog {
+    fun create(preparedData: WcPreparedRequest.EthSign, context: Context): AlertDialog {
+        val data = preparedData.preparedRequestData.dialogData
        val message = context.getString(R.string.wallet_connect_alert_sign_message, data.message)
        return AlertDialog.Builder(context).apply {
            setTitle(context.getString(R.string.wallet_connect_title))
            setMessage(message)
            setPositiveButton(context.getText(R.string.common_sign)) { _, _ ->
-                store.dispatch(WalletConnectAction.SignMessage(data.session))
+                store.dispatch(WalletConnectAction.SignMessage(data.topic))
+                store.dispatch(WalletConnectAction.PerformRequestedAction(preparedData))
            }
            setNegativeButton(context.getText(R.string.common_reject)) { _, _ ->
-                store.dispatch(WalletConnectAction.RejectRequest(data.session, data.id))
+                store.dispatch(WalletConnectAction.RejectRequest(data.topic, data.id))
            }
            setOnDismissListener {
                store.dispatch(GlobalAction.HideDialog)
@ -30,6 +32,6 @@ object PersonalSignDialog {
 data class PersonalSignDialogData(
    val dAppName: String,
    val message: String,
-    val session: WCSession,
+    val topic: String,
    val id: Long,
 )
--- a/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/dialogs/SessionProposalDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/dialogs/SessionProposalDialog.kt
@ -0,0 +1,41 @@
+package com.tangem.tap.features.details.ui.walletconnect.dialogs
+
+import android.content.Context
+import androidx.appcompat.app.AlertDialog
+import com.tangem.tap.common.redux.global.GlobalAction
+import com.tangem.tap.domain.walletconnect2.domain.models.WalletConnectEvents
+import com.tangem.tap.store
+import com.tangem.wallet.R
+
+object SessionProposalDialog {
+    fun create(
+        sessionProposal: WalletConnectEvents.SessionProposal,
+        networks: String,
+        context: Context,
+        onApprove: () -> Unit,
+        onReject: () -> Unit,
+    ): AlertDialog {
+        val message = context.getString(
+            R.string.wallet_connect_request_session_start,
+            sessionProposal.name,
+            networks,
+            sessionProposal.url,
+        )
+        return AlertDialog.Builder(context).apply {
+            setTitle(context.getString(R.string.wallet_connect_title))
+            setMessage(message)
+            setPositiveButton(context.getText(R.string.common_start)) { _, _ ->
+                store.dispatch(GlobalAction.HideDialog)
+                onApprove()
+            }
+            setNegativeButton(context.getText(R.string.common_reject)) { _, _ ->
+                store.dispatch(GlobalAction.HideDialog)
+                onReject()
+            }
+            setOnCancelListener {
+                store.dispatch(GlobalAction.HideDialog)
+                onReject()
+            }
+        }.create()
+    }
+}
--- a/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/dialogs/TransactionDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/walletconnect/dialogs/TransactionDialog.kt
@ -3,14 +3,15 @@ package com.tangem.tap.features.details.ui.walletconnect.dialogs
 import android.content.Context
 import androidx.appcompat.app.AlertDialog
 import com.tangem.tap.common.redux.global.GlobalAction
+import com.tangem.tap.domain.walletconnect2.domain.WcPreparedRequest
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectAction
-import com.tangem.tap.features.details.redux.walletconnect.WcTransactionType
+import com.tangem.tap.features.details.redux.walletconnect.WcEthTransactionType
 import com.tangem.tap.store
 import com.tangem.wallet.R
-import com.trustwallet.walletconnect.models.session.WCSession

 object TransactionDialog {
-    fun create(data: TransactionRequestDialogData, context: Context): AlertDialog {
+    fun create(preparedData: WcPreparedRequest.EthTransaction, context: Context): AlertDialog {
+        val data = preparedData.preparedRequestData.dialogData
        val message = context.getString(
            R.string.wallet_connect_create_tx_message,
            data.dAppName,
@ -22,22 +23,23 @@ object TransactionDialog {
        )

        val positiveButtonTitle = when (data.type) {
-            WcTransactionType.EthSignTransaction -> context.getText(R.string.common_sign)
-            WcTransactionType.EthSendTransaction -> context.getText(R.string.common_sign_and_send)
+            WcEthTransactionType.EthSignTransaction -> context.getText(R.string.common_sign)
+            WcEthTransactionType.EthSendTransaction -> context.getText(R.string.common_sign_and_send)
        }
        return AlertDialog.Builder(context).apply {
            setTitle(context.getString(R.string.wallet_connect_title))
            setMessage(message)
            setPositiveButton(positiveButtonTitle) { _, _ ->
                if (data.isEnoughFundsToSend) {
-                    store.dispatch(WalletConnectAction.SendTransaction(data.session))
+                    store.dispatch(WalletConnectAction.SendTransaction(data.topic))
+                    store.dispatch(WalletConnectAction.PerformRequestedAction(preparedData))
                } else {
-                    store.dispatch(WalletConnectAction.RejectRequest(data.session, data.id))
+                    store.dispatch(WalletConnectAction.RejectRequest(data.topic, data.id))
                    store.dispatch(WalletConnectAction.NotEnoughFunds)
                }
            }
            setNegativeButton(context.getText(R.string.common_reject)) { _, _ ->
-                store.dispatch(WalletConnectAction.RejectRequest(data.session, data.id))
+                store.dispatch(WalletConnectAction.RejectRequest(data.topic, data.id))
            }
            setOnDismissListener {
                store.dispatch(GlobalAction.HideDialog)
@ -54,7 +56,7 @@ data class TransactionRequestDialogData(
    val totalAmount: String,
    val balance: String,
    val isEnoughFundsToSend: Boolean,
-    val session: WCSession,
+    val topic: String,
    val id: Long,
-    val type: WcTransactionType,
+    val type: WcEthTransactionType,
 )
--- a/app/src/main/java/com/tangem/tap/features/wallet/ui/dialogs/SimpleOkDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/dialogs/SimpleOkDialog.kt
@ -53,4 +53,17 @@ object SimpleOkDialog {
        ),
        context = context,
    )
+
+    fun create(dialog: AppDialog.OkCancelDialogRes, context: Context): AlertDialog {
+        return AlertDialog.Builder(context).apply {
+            setTitle(context.getString(dialog.headerId))
+            setMessage(dialog.messageId)
+            setPositiveButton(dialog.okButton.title) { _, _ -> dialog.okButton.action?.invoke() }
+            setNegativeButton(dialog.cancelButton.title) { _, _ -> dialog.cancelButton.action?.invoke() }
+            setOnDismissListener {
+                store.dispatchDialogHide()
+                dialog.cancelButton.action?.invoke()
+            }
+        }.create()
+    }
 }