wallet-stack 1.0.0-alpha.121

package/src/walletConnect/saga.ts

@@ -0,0 +1,1159 @@
+import { formatJsonRpcError, formatJsonRpcResult, JsonRpcResult } from '@json-rpc-tools/utils'
+import { IWalletKit, WalletKit, WalletKitTypes } from '@reown/walletkit'
+import { Core } from '@walletconnect/core'
+import '@walletconnect/react-native-compat'
+import { SessionTypes } from '@walletconnect/types'
+import { buildApprovedNamespaces, getSdkError, parseUri } from '@walletconnect/utils'
+import { EventChannel, eventChannel } from 'redux-saga'
+import { showMessage } from 'src/alert/actions'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { WalletConnectEvents } from 'src/analytics/Events'
+import { WalletConnect2Properties } from 'src/analytics/Properties'
+import { DappRequestOrigin, WalletConnectPairingOrigin } from 'src/analytics/types'
+import { getDappRequestOrigin } from 'src/app/utils'
+import { getAppConfig } from 'src/appConfig'
+import { APP_NAME, DEEP_LINK_URL_SCHEME } from 'src/config'
+import { activeDappSelector } from 'src/dapps/selectors'
+import { ActiveDapp } from 'src/dapps/types'
+import i18n from 'src/i18n'
+import { isBottomSheetVisible, navigate, navigateBack } from 'src/navigator/NavigationService'
+import { Screens } from 'src/navigator/Screens'
+import { selectBatch } from 'src/sendCalls/selectors'
+import { pruneExpiredBatches as pruneExpiredSendCallsBatches } from 'src/sendCalls/slice'
+import { getDynamicConfigParams, getFeatureGate } from 'src/statsig'
+import { DynamicConfigs } from 'src/statsig/constants'
+import { StatsigDynamicConfigs, StatsigFeatureGates } from 'src/statsig/types'
+import { feeCurrenciesSelector } from 'src/tokens/selectors'
+import { Network } from 'src/transactions/types'
+import { ensureError } from 'src/utils/ensureError'
+import Logger from 'src/utils/Logger'
+import { safely } from 'src/utils/safely'
+import { appendPath } from 'src/utils/string'
+import { publicClient } from 'src/viem'
+import {
+  getSerializablePreparedTransaction,
+  SerializableTransactionRequest,
+} from 'src/viem/preparedTransactionSerialization'
+import {
+  PreparedTransactionsResult,
+  prepareTransactions,
+  TransactionRequest,
+} from 'src/viem/prepareTransactions'
+import {
+  acceptRequest,
+  AcceptRequest,
+  AcceptSession,
+  Actions,
+  clientInitialised,
+  CloseSession,
+  DenyRequest,
+  denyRequest,
+  DenySession,
+  initialiseClient,
+  InitialisePairing,
+  initialisePairing,
+  removeExpiredSessions,
+  sessionCreated,
+  sessionDeleted,
+  SessionPayload,
+  sessionPayload,
+  sessionProposal,
+  SessionProposal,
+  WalletConnectActions,
+} from 'src/walletConnect/actions'
+import {
+  getDefaultRequestTrackedProperties,
+  getDefaultSessionTrackedProperties as getDefaultSessionTrackedPropertiesAnalytics,
+} from 'src/walletConnect/analytics'
+import {
+  getAtomicCapabilityByWalletConnectChainId,
+  getWalletCapabilitiesByHexChainId,
+  getWalletCapabilitiesByWalletConnectChainId,
+  validateRequestedCapabilities,
+} from 'src/walletConnect/capabilities'
+import { isSupportedAction, SupportedActions, SupportedEvents } from 'src/walletConnect/constants'
+import { handleRequest } from 'src/walletConnect/request'
+import {
+  selectHasPendingState,
+  selectPendingActions,
+  selectSessions,
+} from 'src/walletConnect/selectors'
+import {
+  isMessageMethod,
+  isSendCallsMethod,
+  isTransactionMethod,
+  PreparedTransactionResult,
+  WalletConnectRequestResult,
+  WalletConnectRequestType,
+} from 'src/walletConnect/types'
+import networkConfig, {
+  networkIdToWalletConnectChainId,
+  walletConnectChainIdToNetwork,
+  walletConnectChainIdToNetworkId,
+} from 'src/web3/networkConfig'
+import { getWalletAddress } from 'src/web3/saga'
+import { demoModeEnabledSelector, walletAddressSelector } from 'src/web3/selectors'
+import { getSupportedNetworkIds } from 'src/web3/utils'
+import type { SagaGenerator } from 'typed-redux-saga'
+import {
+  call,
+  delay,
+  put,
+  race,
+  select,
+  spawn,
+  take,
+  takeEvery,
+  takeLeading,
+} from 'typed-redux-saga'
+import {
+  Address,
+  BaseError,
+  getAddress,
+  GetTransactionCountParameters,
+  hexToBigInt,
+  isHex,
+} from 'viem'
+import { getTransactionCount } from 'viem/actions'
+import { rpcError } from './constants'
+
+let client: IWalletKit | null = null
+
+export function _setClientForTesting(newClient: IWalletKit | null) {
+  client = newClient
+}
+
+const TAG = 'WalletConnect/saga'
+
+const GET_SESSION_TIMEOUT = 10_000
+
+export function* getDefaultSessionTrackedProperties(
+  session: WalletKitTypes.EventArguments['session_proposal'] | SessionTypes.Struct
+) {
+  const activeDapp: ActiveDapp | null = yield* select(activeDappSelector)
+  return getDefaultSessionTrackedPropertiesAnalytics(session, activeDapp)
+}
+
+function* handleInitialiseWalletConnect() {
+  const walletConnectChannel = yield* call(createWalletConnectChannel)
+  while (true) {
+    const message: WalletConnectActions = yield* take(walletConnectChannel)
+    yield* put(message)
+  }
+}
+
+// Though the WC types say `icons` is string[], we've seen buggy clients with no `icons` property
+// so to avoid crashing the code depending on this, we fix it here
+// Note: this method mutates the session
+function applyIconFixIfNeeded(
+  session: WalletKitTypes.EventArguments['session_proposal'] | SessionTypes.Struct
+) {
+  const peer = 'params' in session ? session.params.proposer : session.peer
+  const { icons } = peer?.metadata || {}
+  if (peer?.metadata && (!Array.isArray(icons) || typeof icons[0] !== 'string' || !icons[0])) {
+    peer.metadata.icons = []
+  }
+}
+
+// Export for testing
+export const _applyIconFixIfNeeded = applyIconFixIfNeeded
+
+function* createWalletConnectChannel() {
+  if (!client) {
+    Logger.debug(TAG + '@createWalletConnectChannel', `init start`)
+    const { links } = getDynamicConfigParams(DynamicConfigs[StatsigDynamicConfigs.APP_CONFIG])
+    const appConfig = yield* call(getAppConfig)
+    client = yield* call([WalletKit, 'init'], {
+      core: new Core({
+        projectId: appConfig.features?.walletConnect?.projectId,
+        relayUrl: networkConfig.walletConnectEndpoint,
+      }),
+      metadata: {
+        name: APP_NAME,
+        description: i18n.t('appDescription'),
+        url: links.web,
+        icons: [appendPath(links.web, 'favicon.ico')],
+        redirect: {
+          native: `${DEEP_LINK_URL_SCHEME}://wallet/wc`,
+          universal: 'https://valoraapp.com/wc',
+        },
+      },
+    })
+
+    Logger.debug(TAG + '@createWalletConnectChannel', `init end`)
+    yield* put(clientInitialised())
+  }
+
+  return eventChannel((emit) => {
+    const onSessionProposal = (session: WalletKitTypes.EventArguments['session_proposal']) => {
+      applyIconFixIfNeeded(session)
+      emit(sessionProposal(session))
+    }
+
+    const onSessionDeleted = (session: WalletKitTypes.EventArguments['session_delete']) => {
+      emit(sessionDeleted(session))
+    }
+    const onSessionRequest = (request: WalletKitTypes.EventArguments['session_request']) => {
+      emit(sessionPayload(request))
+    }
+
+    if (!client) {
+      return () => {
+        Logger.debug(TAG + '@createWalletConnectChannel', 'missing client clean up')
+      }
+    }
+
+    client.on('session_proposal', onSessionProposal)
+    client.on('session_delete', onSessionDeleted)
+    client.on('session_request', onSessionRequest)
+
+    return async () => {
+      if (!client) {
+        Logger.debug(TAG + '@createWalletConnectChannel', 'clean up but missing client')
+        return
+      }
+
+      Logger.debug(TAG + '@createWalletConnectChannel', 'clean up')
+
+      client.off('session_proposal', onSessionProposal)
+      client.off('session_delete', onSessionDeleted)
+      client.off('session_request', onSessionRequest)
+
+      const connections = client.getActiveSessions()
+      await Promise.all(
+        Object.keys(connections).map((topic) =>
+          client!.disconnectSession({ topic, reason: getSdkError('USER_DISCONNECTED') })
+        )
+      )
+
+      client = null
+    }
+  }) as EventChannel<WalletConnectActions>
+}
+
+function* handleInitialisePairing({ uri, origin }: InitialisePairing) {
+  const activeDapp: ActiveDapp | null = yield* select(activeDappSelector)
+  try {
+    AppAnalytics.track(WalletConnectEvents.wc_pairing_start, {
+      dappRequestOrigin: getDappRequestOrigin(activeDapp),
+      origin,
+    })
+
+    if (!client) {
+      throw new Error('missing client')
+    }
+
+    Logger.debug(TAG + '@handleInitialisePairing', 'pair start')
+    yield* call([client, 'pair'], { uri })
+    Logger.debug(TAG + '@handleInitialisePairing', 'pair end')
+  } catch (err) {
+    const error = ensureError(err)
+    Logger.debug(TAG + '@handleInitialisePairing', error.message)
+    AppAnalytics.track(WalletConnectEvents.wc_pairing_error, {
+      dappRequestOrigin: getDappRequestOrigin(activeDapp),
+      error: error.message,
+    })
+  }
+}
+
+/**
+ * When handling incoming requests (actions or sessions) we need to handle
+ * them in order. That means if a request comes in, and we already have a
+ * pending one, ignore it. Once a request is dealt with we handle the new
+ * requests accordingly.
+ */
+
+function* handleIncomingSessionRequest({ session }: SessionProposal) {
+  const { pending }: { pending: WalletKitTypes.EventArguments['session_proposal'][] } =
+    yield* select(selectSessions)
+  if (pending.length > 1) {
+    return
+  }
+
+  yield* call(showSessionRequest, session)
+}
+
+function* handleIncomingActionRequest({ request }: SessionPayload) {
+  const pendingActions: WalletKitTypes.EventArguments['session_request'][] =
+    yield* select(selectPendingActions)
+  if (pendingActions.length > 1) {
+    return
+  }
+
+  yield* call(showActionRequest, request)
+}
+
+function* showSessionRequest(session: WalletKitTypes.EventArguments['session_proposal']) {
+  const activeDapp = yield* select(activeDappSelector)
+  AppAnalytics.track(WalletConnectEvents.wc_pairing_success, {
+    dappRequestOrigin: activeDapp ? DappRequestOrigin.InAppWebView : DappRequestOrigin.External,
+  })
+
+  const defaultSessionTrackedProperties: WalletConnect2Properties = yield* call(
+    getDefaultSessionTrackedProperties,
+    session
+  )
+  AppAnalytics.track(WalletConnectEvents.wc_session_propose, {
+    ...defaultSessionTrackedProperties,
+  })
+
+  const address = yield* call(getWalletAddress)
+  const { requiredNamespaces } = session.params
+
+  // Here we approve all required namespaces, but only for EVM chains.
+  // This is so we don't break existing dapps which don't specify the Celo chain as required.
+  // As of writing this, Curve, Toucan and Cred Protocol do that.
+  // We also add the chains that we support to the list if it's not already there.
+  // The goal is to be more flexible and allow the initial connection to succeed, no matter what (EVM) chain is specified.
+  // If later the dapp actually requests an action on an unsupported chain, we will show an error.
+  // See SessionRequest and ActionRequest for more details.
+  const requiredEip155Chains = requiredNamespaces.eip155?.chains ?? []
+  const supportedEip155Chains = yield* call(getSupportedChains)
+  const approvedEip155Chains = [
+    ...supportedEip155Chains,
+    ...requiredEip155Chains.filter((chainId) => !supportedEip155Chains.includes(chainId)),
+  ]
+
+  // Here we approve all required methods, but only for EVM chains.
+  // Again, this is to be more flexible and allow the initial connection to succeed.
+  // If later an unsupported method is requested, we will show an error.
+  const requiredEip155Methods = requiredNamespaces.eip155?.methods ?? []
+  const supportedEip155Methods = Object.values(SupportedActions) as string[]
+  const approvedEip155Methods = [
+    ...supportedEip155Methods,
+    ...requiredEip155Methods.filter((method) => !supportedEip155Methods.includes(method)),
+  ]
+
+  // And similar for events
+  const requiredEip155Events = requiredNamespaces.eip155?.events ?? []
+  const supportedEip155Events = Object.values(SupportedEvents) as string[]
+  const approvedEip155Events = [
+    ...supportedEip155Events,
+    ...requiredEip155Events.filter((event) => !supportedEip155Events.includes(event)),
+  ]
+
+  let namespacesToApprove: SessionTypes.Namespaces | null = null
+  try {
+    // Important: this still throws if the required namespaces don't overlap with the supported ones
+    namespacesToApprove = buildApprovedNamespaces({
+      proposal: session.params,
+      supportedNamespaces: {
+        eip155: {
+          chains: approvedEip155Chains,
+          methods: approvedEip155Methods,
+          events: approvedEip155Events,
+          accounts: approvedEip155Chains.map((chain) => `${chain}:${address}`),
+        },
+      },
+    })
+  } catch (e) {
+    // Right now the only way this can happen is if the required chain isn't an EVM chain
+    // since we've approved all EVM chains/methods/events above.
+    Logger.warn(TAG + '@showSessionRequest', 'Failed to build approved namespaces', e)
+  }
+
+  // Supply capabilities within session approval to avoid an extra `wallet_getCapabilities` request
+
+  // Recommended method
+  // https://docs.walletconnect.network/wallet-sdk/react-native/eip5792#wallet-response
+  const scopedProperties = yield* call(
+    getWalletCapabilitiesByWalletConnectChainId,
+    address as Address
+  )
+
+  // Legacy method for compatibility
+  // https://github.com/WalletConnect/walletconnect-monorepo/blob/1e6d7793d0a30d2bf684cd3811ba120b4cdc0498/providers/universal-provider/src/providers/eip155.ts#L219-L223
+  const sessionProperties = {
+    capabilities: {
+      [getAddress(address)]: yield* call(getWalletCapabilitiesByHexChainId, address as Address),
+    },
+  } as any
+
+  navigate(Screens.WalletConnectRequest, {
+    type: WalletConnectRequestType.Session,
+    pendingSession: session,
+    namespacesToApprove,
+    supportedChains: supportedEip155Chains,
+    sessionProperties,
+    scopedProperties,
+    version: 2,
+  })
+}
+
+// Export for testing
+export const _showSessionRequest = showSessionRequest
+
+function getSupportedChains() {
+  const supportedNetworkIdsForWalletConnect = getSupportedNetworkIds()
+  return supportedNetworkIdsForWalletConnect.map((networkId) => {
+    return networkIdToWalletConnectChainId[networkId]
+  })
+}
+
+function convertToBigInt(value: any) {
+  return isHex(value)
+    ? hexToBigInt(value)
+    : // make sure that we can safely parse the value as a BigInt
+      typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint'
+      ? BigInt(value)
+      : undefined
+}
+
+function convertToNumber(value: any) {
+  const bigValue = convertToBigInt(value)
+  return bigValue !== undefined ? Number(bigValue) : undefined
+}
+
+// Normalize the raw request into a usable format (bigint, etc) for viem
+// Note: the raw request should be in RPC format (fields in hex string)
+// but sometimes we've seen fields with numbers instead of hex strings
+// i.e. don't trust the raw request to be in the correct format, since it comes from the dapp
+export function* normalizeTransactions(rawTxs: any[], network: Network) {
+  const normalizedTransactions: TransactionRequest[] = []
+
+  const walletAddress = yield* select(walletAddressSelector)
+  if (!walletAddress) {
+    // this should never happen
+    throw new Error('no wallet address found')
+  }
+
+  const txCountParams: GetTransactionCountParameters = {
+    address: walletAddress as Address,
+    blockTag: 'pending',
+  }
+  const nonce = rawTxs[0]?.nonce
+    ? parseInt(rawTxs[0].nonce)
+    : yield* call(getTransactionCount, publicClient[network], txCountParams)
+
+  for (let i = 0; i < rawTxs.length; i++) {
+    const rawTx = rawTxs[i]
+
+    const tx: TransactionRequest = {
+      ...rawTx,
+      gas: convertToBigInt(rawTx.gas),
+      gasPrice: convertToBigInt(rawTx.gasPrice),
+      maxFeePerGas: convertToBigInt(rawTx.maxFeePerGas),
+      maxPriorityFeePerGas: convertToBigInt(rawTx.maxPriorityFeePerGas),
+      nonce: convertToNumber(rawTx.nonce),
+      value: convertToBigInt(rawTx.value),
+    }
+
+    if (!tx.from) {
+      tx.from = walletAddress as Address
+    }
+
+    // Handle `gasLimit` as a misnomer for `gas`, it usually comes through in hex format
+    if ('gasLimit' in tx && tx.gas === undefined) {
+      tx.gas = convertToBigInt(tx.gasLimit)
+      delete tx.gasLimit
+    }
+
+    // On Celo, re-calculate the feeCurrency and gas since it is not possible to tell from
+    // the request payload if the feeCurrency is set to undefined (native
+    // currency) explicitly or due to lack of feeCurrency support
+    if (network === Network.Celo) {
+      delete tx.gas
+      if ('feeCurrency' in tx) {
+        delete tx.feeCurrency
+      }
+    }
+
+    // Force upgrade legacy tx to EIP-1559/CIP-42/CIP-64
+    if (tx.gasPrice !== undefined) {
+      delete tx.gasPrice
+    }
+
+    tx.nonce = nonce + i
+
+    if ('chainId' in tx) {
+      // Strip chainId as viem on Celo currently doesn't serialize it to a string
+      // and it causes the following RPC node error during gas estimation:
+      // `Gas estimation failed: Could not decode transaction failure reason or Error: invalid argument 0: json: cannot unmarshal non-string into Go struct field TransactionArgs.chainId of type *hexutil.Big`
+      // The right chainId will be set by the viem client anyway when signing the transaction
+      delete tx.chainId
+    }
+
+    // Strip undefined keys, just to avoid noise in the logs or tests
+    for (const key of Object.keys(tx) as Array<keyof TransactionRequest>) {
+      if (tx[key] === undefined) {
+        delete tx[key]
+      }
+    }
+
+    normalizedTransactions.push(tx)
+  }
+
+  return normalizedTransactions
+}
+
+function prepareNormalizedTransactions(
+  rawTxs: unknown[],
+  walletConnectChainId: string
+): SagaGenerator<{
+  hasInsufficientGasFunds: boolean
+  feeCurrenciesSymbols: string[]
+  result: PreparedTransactionResult<SerializableTransactionRequest[]>
+}>
+function prepareNormalizedTransactions(
+  rawTx: unknown,
+  walletConnectChainId: string
+): SagaGenerator<{
+  hasInsufficientGasFunds: boolean
+  feeCurrenciesSymbols: string[]
+  result: PreparedTransactionResult<SerializableTransactionRequest>
+}>
+function* prepareNormalizedTransactions(
+  rawTxOrTxs: unknown[] | unknown,
+  walletConnectChainId: string
+): SagaGenerator<{
+  hasInsufficientGasFunds: boolean
+  feeCurrenciesSymbols: string[]
+  result:
+    | PreparedTransactionResult<SerializableTransactionRequest>
+    | PreparedTransactionResult<SerializableTransactionRequest[]>
+}> {
+  const networkId = walletConnectChainIdToNetworkId[walletConnectChainId]
+  const network = walletConnectChainIdToNetwork[walletConnectChainId]
+  const feeCurrencies = yield* select((state) => feeCurrenciesSelector(state, networkId))
+
+  let result: PreparedTransactionsResult | undefined
+  let errorMessage: string | undefined
+
+  Logger.debug(TAG + '@prepareNormalizedTransactions', 'Received transactions', rawTxOrTxs)
+
+  try {
+    const rawTxs = Array.isArray(rawTxOrTxs) ? rawTxOrTxs : [rawTxOrTxs]
+    const normalizedTxs = yield* call(normalizeTransactions, rawTxs, network)
+    result = yield* call(prepareTransactions, {
+      feeCurrencies,
+      decreasedAmountGasFeeMultiplier: 1,
+      baseTransactions: normalizedTxs,
+      origin: 'wallet-connect' as const,
+    })
+  } catch (err) {
+    Logger.warn(TAG + '@showActionRequest', 'Failed to prepare transactions', err)
+    const e = ensureError(err)
+    // Viem has short user-friendly error messages
+    errorMessage = e instanceof BaseError ? e.shortMessage : e.message
+  }
+
+  const hasInsufficientGasFunds = result?.type === 'not-enough-balance-for-gas'
+  const feeCurrenciesSymbols = feeCurrencies.map((token) => token.symbol)
+
+  Logger.debug(
+    TAG + '@prepareNormalizedTransactions',
+    'Prepared transactions',
+    result?.type,
+    result?.type === 'possible' && result.transactions
+  )
+
+  if (result?.type === 'possible') {
+    const serializableTransactions = result.transactions.map((tx) =>
+      getSerializablePreparedTransaction(tx)
+    )
+
+    if (!Array.isArray(rawTxOrTxs)) {
+      return {
+        hasInsufficientGasFunds,
+        feeCurrenciesSymbols,
+        result: { success: true, data: serializableTransactions[0] },
+      }
+    }
+
+    return {
+      hasInsufficientGasFunds,
+      feeCurrenciesSymbols,
+      result: { success: true, data: serializableTransactions },
+    }
+  }
+
+  return {
+    hasInsufficientGasFunds,
+    feeCurrenciesSymbols,
+    result: {
+      success: false,
+      errorMessage,
+    },
+  }
+}
+
+function* showActionRequest(request: WalletKitTypes.EventArguments['session_request']) {
+  if (!client) {
+    throw new Error('missing client')
+  }
+
+  const demoModeEnabled = yield* select(demoModeEnabledSelector)
+  if (demoModeEnabled) {
+    navigate(Screens.DemoModeAuthBlock)
+    yield* put(denyRequest(request, getSdkError('USER_REJECTED')))
+    return
+  }
+
+  const method = request.params.request.method
+  if (!isSupportedAction(method)) {
+    // Directly deny unsupported requests
+    yield* put(denyRequest(request, getSdkError('WC_METHOD_UNSUPPORTED')))
+    return
+  }
+
+  const session: SessionTypes.Struct = yield* call(getSessionFromRequest, request)
+  const defaultSessionTrackedProperties: WalletConnect2Properties = yield* call(
+    getDefaultSessionTrackedProperties,
+    session
+  )
+  AppAnalytics.track(WalletConnectEvents.wc_request_propose, {
+    ...defaultSessionTrackedProperties,
+    ...getDefaultRequestTrackedProperties(request),
+  })
+
+  const activeSessions = yield* call([client, 'getActiveSessions'])
+  const activeSession = activeSessions[session.topic]
+  if (!activeSession) {
+    yield* put(denyRequest(request, getSdkError('UNAUTHORIZED_EVENT')))
+    return
+  }
+
+  if (method === SupportedActions.wallet_getCapabilities) {
+    const [address, requestedChainIds] = request.params.request.params
+    if (!address) {
+      yield* put(denyRequest(request, rpcError.INVALID_PARAMS))
+      return
+    }
+
+    const walletAddress = yield* call(getWalletAddress)
+    if (address.toLowerCase() !== walletAddress.toLowerCase()) {
+      yield* put(denyRequest(request, rpcError.UNAUTHORIZED))
+      return
+    }
+
+    if (requestedChainIds) {
+      if (!Array.isArray(requestedChainIds)) {
+        yield* put(denyRequest(request, rpcError.INVALID_PARAMS))
+        return
+      }
+
+      if (requestedChainIds.length === 0) {
+        yield* put(denyRequest(request, rpcError.INVALID_PARAMS))
+        return
+      }
+
+      if (requestedChainIds.some((chainId: unknown) => !isHex(chainId))) {
+        yield* put(denyRequest(request, rpcError.INVALID_PARAMS))
+        return
+      }
+    }
+  }
+
+  if (method === SupportedActions.wallet_sendCalls) {
+    const walletAddress = yield* call(getWalletAddress)
+
+    // check for duplicate id
+    const id = request.params.request.params[0].id
+    if (id) {
+      const batch = yield* select(selectBatch, id, Date.now())
+      if (batch) {
+        yield* put(denyRequest(request, rpcError.DUPLICATE_ID))
+        return
+      }
+    }
+
+    // check support for atomic execution
+    const atomic = yield* call(
+      getAtomicCapabilityByWalletConnectChainId,
+      walletAddress as Address,
+      request.params.chainId
+    )
+    if (request.params.request.params[0].atomicRequired && atomic === 'unsupported') {
+      yield* put(denyRequest(request, rpcError.ATOMICITY_NOT_SUPPORTED))
+      return
+    }
+
+    // check global capabilities
+    const requestedCapabilities = request.params.request.params[0].capabilities ?? {}
+    const requestedCapabilitiesSupported = yield* call(
+      validateRequestedCapabilities,
+      walletAddress as Address,
+      request.params.chainId,
+      requestedCapabilities
+    )
+    if (!requestedCapabilitiesSupported) {
+      yield* put(denyRequest(request, rpcError.UNSUPPORTED_NON_OPTIONAL_CAPABILITY))
+      return
+    }
+
+    // check per-call capabilities
+    for (const requestCall of request.params.request.params[0].calls) {
+      const callCapabilities = requestCall.capabilities ?? {}
+      const callCapabilitiesSupported = yield* call(
+        validateRequestedCapabilities,
+        walletAddress as Address,
+        request.params.chainId,
+        callCapabilities
+      )
+      if (!callCapabilitiesSupported) {
+        yield* put(denyRequest(request, rpcError.UNSUPPORTED_NON_OPTIONAL_CAPABILITY))
+        return
+      }
+    }
+
+    if (atomic === 'ready') {
+      // TODO: suggest user to enable atomic operations
+      // NOTE: deny if atomicRequired is true, and user didn't enable atomic operations
+    }
+  }
+
+  if (method === SupportedActions.wallet_getCallsStatus) {
+    const [id] = request.params.request.params
+    if (!id) {
+      yield* put(denyRequest(request, rpcError.INVALID_PARAMS))
+      return
+    }
+
+    const batch = yield* select(selectBatch, id, Date.now())
+    if (!batch) {
+      yield* put(denyRequest(request, rpcError.UNKNOWN_BUNDLE_ID))
+      return
+    }
+
+    yield* put(acceptRequest({ method, request, id, batch }))
+    return
+  }
+
+  if (method === SupportedActions.wallet_getCapabilities) {
+    yield* put(acceptRequest({ method, request }))
+    return
+  }
+
+  // since there are some network requests needed to prepare the transactions,
+  // add a loading state
+  navigate(Screens.WalletConnectRequest, {
+    type: WalletConnectRequestType.Loading,
+    origin: WalletConnectPairingOrigin.Deeplink,
+  })
+
+  const supportedChains = yield* call(getSupportedChains)
+
+  if (isMessageMethod(method)) {
+    navigate(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Action,
+      method,
+      request,
+      supportedChains,
+      version: 2,
+    })
+  }
+
+  if (isTransactionMethod(method)) {
+    const rawTx: unknown = request.params.request.params[0]
+    const {
+      hasInsufficientGasFunds,
+      feeCurrenciesSymbols,
+      result: preparedRequest,
+    } = yield* prepareNormalizedTransactions(rawTx, request.params.chainId)
+
+    navigate(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Action,
+      method,
+      request,
+      supportedChains,
+      version: 2,
+      hasInsufficientGasFunds,
+      feeCurrenciesSymbols,
+      preparedRequest,
+    })
+  }
+
+  if (isSendCallsMethod(method)) {
+    const rawTxs: unknown[] = request.params.request.params[0].calls
+    const {
+      hasInsufficientGasFunds,
+      feeCurrenciesSymbols,
+      result: preparedRequest,
+    } = yield* prepareNormalizedTransactions(rawTxs, request.params.chainId)
+
+    const walletAddress = yield* call(getWalletAddress)
+    const atomic = yield* call(
+      getAtomicCapabilityByWalletConnectChainId,
+      walletAddress as Address,
+      request.params.chainId
+    )
+
+    navigate(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Action,
+      method,
+      request,
+      supportedChains,
+      version: 2,
+      hasInsufficientGasFunds,
+      feeCurrenciesSymbols,
+      preparedRequest,
+      atomic: atomic === 'supported',
+    })
+  }
+}
+
+// Export for testing
+export const _showActionRequest = showActionRequest
+
+function* acceptSession({
+  session,
+  approvedNamespaces,
+  sessionProperties,
+  scopedProperties,
+}: AcceptSession) {
+  const defaultTrackedProperties: WalletConnect2Properties = yield* call(
+    getDefaultSessionTrackedProperties,
+    session
+  )
+  try {
+    AppAnalytics.track(WalletConnectEvents.wc_session_approve_start, defaultTrackedProperties)
+
+    if (!client) {
+      throw new Error('missing client')
+    }
+
+    const { relays, proposer } = session.params
+
+    yield* call([client, 'approveSession'], {
+      id: session.id,
+      relayProtocol: relays[0].protocol,
+      namespaces: approvedNamespaces,
+      ...(sessionProperties && { sessionProperties }),
+      ...(scopedProperties && { scopedProperties }),
+    })
+
+    AppAnalytics.track(WalletConnectEvents.wc_session_approve_success, defaultTrackedProperties)
+
+    // the Client does not emit any events when a new session value is
+    // available, so if no matching session could be found we can wait and try again.
+    const { timedOut, newSession } = yield* race({
+      timedOut: delay(GET_SESSION_TIMEOUT),
+      newSession: call(getSessionFromClient, session),
+    })
+
+    if (!newSession || timedOut) {
+      throw new Error('No corresponding session could not be found on the client')
+    }
+
+    yield* put(sessionCreated(newSession))
+    yield* call(showWalletConnectionSuccessMessage, proposer.metadata.name)
+  } catch (err) {
+    const e = ensureError(err)
+    Logger.debug(TAG + '@acceptSession', e.message)
+    AppAnalytics.track(WalletConnectEvents.wc_session_approve_error, {
+      ...defaultTrackedProperties,
+      error: e.message,
+    })
+  }
+
+  yield* call(handlePendingStateOrNavigateBack)
+}
+
+// Export for testing
+export const _acceptSession = acceptSession
+
+function* getSessionFromClient(session: WalletKitTypes.EventArguments['session_proposal']) {
+  if (!client) {
+    // should not happen
+    throw new Error('missing client')
+  }
+
+  let sessionValue: null | SessionTypes.Struct = null
+  while (!sessionValue) {
+    const sessions: Record<string, SessionTypes.Struct> = yield* call([client, 'getActiveSessions'])
+    Object.values(sessions).forEach((entry) => {
+      if (entry.pairingTopic === session.params.pairingTopic) {
+        sessionValue = entry
+      }
+    })
+
+    if (!sessionValue) {
+      yield* delay(500)
+    }
+  }
+
+  applyIconFixIfNeeded(sessionValue)
+  return sessionValue as SessionTypes.Struct
+}
+
+function* denySession({ session, reason }: DenySession) {
+  const defaultSessionTrackedProperties: WalletConnect2Properties = yield* call(
+    getDefaultSessionTrackedProperties,
+    session
+  )
+  const defaultTrackedProperties = {
+    ...defaultSessionTrackedProperties,
+    rejectReason: reason.message,
+  }
+
+  try {
+    AppAnalytics.track(WalletConnectEvents.wc_session_reject_start, defaultTrackedProperties)
+
+    if (!client) {
+      throw new Error('missing client')
+    }
+
+    yield* call([client, 'rejectSession'], {
+      id: session.id,
+      reason,
+    })
+
+    AppAnalytics.track(WalletConnectEvents.wc_session_reject_success, defaultTrackedProperties)
+  } catch (err) {
+    const e = ensureError(err)
+    Logger.debug(TAG + '@denySession', e.message)
+    AppAnalytics.track(WalletConnectEvents.wc_session_reject_error, {
+      ...defaultTrackedProperties,
+      error: e.message,
+    })
+  }
+
+  yield* call(handlePendingStateOrNavigateBack)
+}
+
+export function* getSessionFromRequest(request: WalletKitTypes.EventArguments['session_request']) {
+  if (!client) {
+    // should not happen
+    throw new Error('missing client')
+  }
+  // Active Sessions is an object with keys that are uuids
+  const activeSessions = yield* call([client, 'getActiveSessions'])
+  const session = activeSessions[request.topic]
+
+  if (!session) {
+    // This should never happen
+    throw new Error(`Unable to find WalletConnect session matching topic ${request.topic}`)
+  }
+
+  return session
+}
+
+function* handleAcceptRequest({ actionableRequest }: AcceptRequest) {
+  const request = actionableRequest.request
+  const session: SessionTypes.Struct = yield* call(getSessionFromRequest, request)
+  const defaultSessionTrackedProperties: WalletConnect2Properties = yield* call(
+    getDefaultSessionTrackedProperties,
+    session
+  )
+  const defaultTrackedProperties = {
+    ...defaultSessionTrackedProperties,
+    ...getDefaultRequestTrackedProperties(request),
+  }
+
+  try {
+    AppAnalytics.track(WalletConnectEvents.wc_request_accept_start, defaultTrackedProperties)
+
+    if (!client) {
+      throw new Error('Missing client')
+    }
+
+    const { topic, id } = request
+    const activeSessions = yield* call([client, 'getActiveSessions'])
+    const activeSession = activeSessions[topic]
+
+    if (!activeSession) {
+      throw new Error(`Missing active session for topic ${topic}`)
+    }
+
+    const result = yield* call(handleRequest, actionableRequest)
+    const response: JsonRpcResult<WalletConnectRequestResult> = formatJsonRpcResult(id, result)
+    yield* call([client, 'respondSessionRequest'], { topic, response })
+
+    AppAnalytics.track(WalletConnectEvents.wc_request_accept_success, defaultTrackedProperties)
+    yield* call(showWalletConnectionSuccessMessage, activeSession.peer.metadata.name)
+
+    yield* put(pruneExpiredSendCallsBatches({ now: Date.now() }))
+  } catch (err) {
+    const e = ensureError(err)
+    Logger.debug(TAG + '@acceptRequest', e.message)
+    AppAnalytics.track(WalletConnectEvents.wc_request_accept_error, {
+      ...defaultTrackedProperties,
+      error: e.message,
+    })
+
+    // Notify the client about the error if possible
+    try {
+      const { topic, id } = request
+      if (client && topic && id) {
+        const response = formatJsonRpcResult(id, { error: e })
+        yield* call([client, 'respondSessionRequest'], { topic, response })
+      }
+    } catch (error) {
+      const e = ensureError(err)
+      Logger.debug(TAG + '@acceptRequest', e.message)
+      AppAnalytics.track(WalletConnectEvents.wc_request_accept_error, {
+        ...defaultTrackedProperties,
+        error: e.message,
+      })
+    }
+  }
+
+  yield* call(handlePendingStateOrNavigateBack)
+}
+
+function* handleDenyRequest({ request, reason }: DenyRequest) {
+  const session: SessionTypes.Struct = yield* call(getSessionFromRequest, request)
+  const defaultSessionTrackedProperties: WalletConnect2Properties = yield* call(
+    getDefaultSessionTrackedProperties,
+    session
+  )
+  const defaultTrackedProperties = {
+    ...defaultSessionTrackedProperties,
+    ...getDefaultRequestTrackedProperties(request),
+    denyReason: reason.message,
+  }
+
+  try {
+    AppAnalytics.track(WalletConnectEvents.wc_request_deny_start, defaultTrackedProperties)
+
+    if (!client) {
+      throw new Error('Missing client')
+    }
+
+    const { topic, id } = request
+    const response = formatJsonRpcError(id, reason.message)
+    yield* call([client, 'respondSessionRequest'], { topic, response })
+    AppAnalytics.track(WalletConnectEvents.wc_request_deny_success, defaultTrackedProperties)
+  } catch (err) {
+    const e = ensureError(err)
+    Logger.debug(TAG + '@denyRequest', e.message)
+    AppAnalytics.track(WalletConnectEvents.wc_request_deny_error, {
+      ...defaultTrackedProperties,
+      error: e.message,
+    })
+  }
+
+  yield* call(handlePendingStateOrNavigateBack)
+}
+
+function* closeSession({ session }: CloseSession) {
+  const defaultTrackedProperties: WalletConnect2Properties = yield* call(
+    getDefaultSessionTrackedProperties,
+    session
+  )
+
+  try {
+    AppAnalytics.track(WalletConnectEvents.wc_session_remove_start, defaultTrackedProperties)
+
+    if (!client) {
+      throw new Error('missing client')
+    }
+
+    yield* call([client, 'disconnectSession'], {
+      topic: session.topic,
+      reason: getSdkError('USER_DISCONNECTED'),
+    })
+
+    AppAnalytics.track(WalletConnectEvents.wc_session_remove_success, defaultTrackedProperties)
+  } catch (err) {
+    const e = ensureError(err)
+    Logger.debug(TAG + '@closeSession', e.message)
+    AppAnalytics.track(WalletConnectEvents.wc_session_remove_error, {
+      ...defaultTrackedProperties,
+      error: e.message,
+    })
+  }
+}
+
+function* handlePendingStateOrNavigateBack() {
+  const hasPendingState: boolean = yield* select(selectHasPendingState)
+
+  if (hasPendingState) {
+    yield* call(handlePendingState)
+  } else if (yield* call(isBottomSheetVisible, Screens.WalletConnectRequest)) {
+    navigateBack()
+  }
+}
+
+export function* handlePendingState() {
+  const {
+    pending: [pendingSession],
+  }: { pending: WalletKitTypes.EventArguments['session_proposal'][] } =
+    yield* select(selectSessions)
+  if (pendingSession) {
+    yield* call(showSessionRequest, pendingSession)
+    return
+  }
+
+  const [pendingRequest]: WalletKitTypes.EventArguments['session_request'][] =
+    yield* select(selectPendingActions)
+  if (pendingRequest) {
+    yield* call(showActionRequest, pendingRequest)
+  }
+}
+
+function* checkPersistedState() {
+  yield* put(removeExpiredSessions(Date.now() / 1000))
+
+  const hasPendingState = yield* select(selectHasPendingState)
+  if (hasPendingState) {
+    yield* put(initialiseClient())
+    yield* take(Actions.CLIENT_INITIALISED)
+    yield* call(handlePendingState)
+    return
+  }
+
+  const { sessions }: { sessions: SessionTypes.Struct[] } = yield* select(selectSessions)
+  if (sessions.length) {
+    yield* put(initialiseClient())
+  }
+}
+
+export function* walletConnectSaga() {
+  yield* takeLeading(Actions.INITIALISE_CLIENT, safely(handleInitialiseWalletConnect))
+  yield* takeEvery(Actions.INITIALISE_PAIRING, safely(handleInitialisePairing))
+  yield* takeEvery(Actions.CLOSE_SESSION, safely(closeSession))
+
+  yield* takeEvery(Actions.SESSION_PROPOSAL, safely(handleIncomingSessionRequest))
+  yield* takeEvery(Actions.ACCEPT_SESSION, safely(acceptSession))
+  yield* takeEvery(Actions.DENY_SESSION, safely(denySession))
+
+  yield* takeEvery(Actions.SESSION_PAYLOAD, safely(handleIncomingActionRequest))
+  yield* takeEvery(Actions.ACCEPT_REQUEST, safely(handleAcceptRequest))
+  yield* takeEvery(Actions.DENY_REQUEST, safely(handleDenyRequest))
+
+  yield* spawn(checkPersistedState)
+}
+
+export function* initialiseWalletConnectV2(uri: string, origin: WalletConnectPairingOrigin) {
+  if (!client) {
+    yield* put(initialiseClient())
+    yield* take(Actions.CLIENT_INITIALISED)
+  }
+  yield* put(initialisePairing(uri, origin))
+}
+
+export function isWalletConnectEnabled(uri: string) {
+  const { version } = parseUri(uri)
+  const walletConnectV2Disabled = getFeatureGate(StatsigFeatureGates.DISABLE_WALLET_CONNECT_V2)
+  const walletConnectProjectId = getAppConfig().features?.walletConnect?.projectId
+
+  return !!walletConnectProjectId && !walletConnectV2Disabled && version === 2
+}
+
+export function* initialiseWalletConnect(uri: string, origin: WalletConnectPairingOrigin) {
+  const walletConnectEnabled = yield* call(isWalletConnectEnabled, uri)
+
+  const { version } = parseUri(uri)
+  if (!walletConnectEnabled) {
+    Logger.debug('initialiseWalletConnect', `v${version} is disabled, ignoring`)
+    return
+  }
+
+  switch (version) {
+    case 2:
+      yield* call(initialiseWalletConnectV2, uri, origin)
+      break
+    case 1:
+    default:
+      throw new Error(`Unsupported WalletConnect version '${version}'`)
+  }
+}
+
+export function* showWalletConnectionSuccessMessage(dappName: string) {
+  const activeDapp = yield* select(activeDappSelector)
+  const successMessage = activeDapp
+    ? i18n.t('inAppConnectionSuccess', { dappName })
+    : i18n.t('connectionSuccess', { dappName })
+  yield* put(showMessage(successMessage))
+}