wallet-stack 1.0.0-alpha.121

package/src/walletConnect/saga.test.ts

@@ -0,0 +1,1875 @@
+import { WalletKitTypes } from '@reown/walletkit'
+import { CoreTypes, SessionTypes } from '@walletconnect/types'
+import { buildApprovedNamespaces } from '@walletconnect/utils'
+import { expectSaga } from 'redux-saga-test-plan'
+import { call, select } from 'redux-saga-test-plan/matchers'
+import { EffectProviders, StaticProvider, throwError } from 'redux-saga-test-plan/providers'
+import { showMessage } from 'src/alert/actions'
+import { DappRequestOrigin, WalletConnectPairingOrigin } from 'src/analytics/types'
+import { getAppConfig } from 'src/appConfig'
+import { activeDappSelector } from 'src/dapps/selectors'
+import i18n from 'src/i18n'
+import { isBottomSheetVisible, navigate } from 'src/navigator/NavigationService'
+import { Screens } from 'src/navigator/Screens'
+import { getFeatureGate } from 'src/statsig'
+import { StatsigFeatureGates } from 'src/statsig/types'
+import { Network, NetworkId } from 'src/transactions/types'
+import { publicClient } from 'src/viem'
+import { getLockableViemSmartWallet } from 'src/viem/getLockableWallet'
+import { prepareTransactions } from 'src/viem/prepareTransactions'
+import {
+  Actions,
+  acceptRequest,
+  acceptSession as acceptSessionAction,
+  denyRequest,
+  sessionProposal as sessionProposalAction,
+} from 'src/walletConnect/actions'
+import { SupportedActions, SupportedEvents, rpcError } from 'src/walletConnect/constants'
+import {
+  _acceptSession,
+  _applyIconFixIfNeeded,
+  _setClientForTesting,
+  _showActionRequest,
+  _showSessionRequest,
+  getDefaultSessionTrackedProperties,
+  getSessionFromRequest,
+  handlePendingState,
+  initialiseWalletConnect,
+  initialiseWalletConnectV2,
+  normalizeTransactions,
+  walletConnectSaga,
+} from 'src/walletConnect/saga'
+import { WalletConnectRequestType } from 'src/walletConnect/types'
+import { demoModeEnabledSelector, walletAddressSelector } from 'src/web3/selectors'
+import { getSupportedNetworkIds } from 'src/web3/utils'
+import { createMockStore } from 'test/utils'
+import { mockAccount } from 'test/values'
+import { BaseError } from 'viem'
+import { getTransactionCount } from 'viem/actions'
+
+jest.mock('src/statsig')
+jest.mock('src/web3/utils', () => ({
+  ...jest.requireActual('src/web3/utils'),
+  getSupportedNetworkIds: jest.fn(),
+}))
+jest.mock('src/viem/getLockableWallet', () => ({
+  ...jest.requireActual('src/viem/getLockableWallet'),
+  getLockableViemSmartWallet: jest.fn(),
+}))
+
+function createSessionProposal(
+  proposerMetadata: CoreTypes.Metadata
+): WalletKitTypes.EventArguments['session_proposal'] {
+  return {
+    id: 1669989187506938,
+    params: {
+      expiryTimestamp: 1669989496,
+      proposer: {
+        publicKey: 'f4284dc764da82e9b62d625f4dfea4088142f477c0d7420cdec2a0f49959c233',
+        metadata: proposerMetadata,
+      },
+      optionalNamespaces: {},
+      requiredNamespaces: {
+        eip155: {
+          events: ['chainChanged', 'accountsChanged'],
+          chains: ['eip155:44787'],
+          methods: ['eth_sendTransaction', 'eth_signTypedData'],
+        },
+      },
+      id: 1669989187506938,
+      relays: [
+        {
+          protocol: 'irn',
+        },
+      ],
+      pairingTopic: 'ab7c79764b6838abd24669ab735f6ce40bb26ca4d54cf948daca8e80a2eb6db1',
+    },
+    verifyContext: {
+      verified: {
+        origin: '',
+        validation: 'UNKNOWN',
+        verifyUrl: '',
+      },
+    },
+  }
+}
+
+function createSession(proposerMetadata: CoreTypes.Metadata): SessionTypes.Struct {
+  return {
+    expiry: 1671006057,
+    self: {
+      metadata: {
+        icons: ['https://example.com/favicon.ico'],
+        description: 'A mobile payments wallet that works worldwide',
+        name: 'App Name',
+        url: 'https://example.com/',
+      },
+      publicKey: '61a2616b6d7394ed7dd430ea5921d1c32289b300ccd2d588af9e25c21f239612',
+    },
+    relay: {
+      protocol: 'irn',
+    },
+    controller: '61a2616b6d7394ed7dd430ea5921d1c32289b300ccd2d588af9e25c21f239612',
+    peer: {
+      metadata: proposerMetadata,
+      publicKey: '91c2e7baeade1d3d46a51e20746cf1c294ea3f9c017d4d72b08db3e87a74f50a',
+    },
+    namespaces: {
+      eip155: {
+        accounts: ['eip155:44787:0x6131a6d616a4be3737b38988847270a64bc10caa'],
+        events: ['chainChanged', 'accountsChanged'],
+        methods: ['eth_sendTransaction', 'eth_signTypedData'],
+      },
+    },
+    acknowledged: true,
+    topic: '243b33442b6190b97055201b5a8817f4e604e3f37b5376e78ee0b3715cc6211c',
+    pairingTopic: '98339e3d81179f61656592154af78d308ba7f8d01498772320d2d87c90cafb85',
+    requiredNamespaces: {
+      eip155: {
+        events: ['chainChanged', 'accountsChanged'],
+        chains: ['eip155:44787'],
+        methods: ['eth_sendTransaction', 'eth_signTypedData'],
+      },
+    },
+    optionalNamespaces: {},
+  }
+}
+
+beforeEach(() => {
+  jest.clearAllMocks()
+  jest.mocked(getSupportedNetworkIds).mockReturnValue([NetworkId['celo-alfajores']])
+  jest.mocked(getLockableViemSmartWallet).mockResolvedValue({
+    account: {
+      isDeployed: jest.fn().mockResolvedValue(true),
+    },
+  } as any)
+  jest.mocked(getFeatureGate).mockImplementation((featureGate) => {
+    switch (featureGate) {
+      case StatsigFeatureGates.DISABLE_WALLET_CONNECT_V2:
+        return false
+      case StatsigFeatureGates.USE_SMART_ACCOUNT_CAPABILITIES:
+        return false
+      default:
+        throw new Error(`Unexpected feature gate: ${featureGate}`)
+    }
+  })
+})
+
+describe('getDefaultSessionTrackedProperties', () => {
+  const proposerMetadata = {
+    url: 'someUrl',
+    icons: ['someIcon'],
+    description: 'someDescription',
+    name: 'someName',
+  }
+  const sessionProposal = createSessionProposal(proposerMetadata)
+  const session = createSession(proposerMetadata)
+
+  it.each`
+    sessionType          | sessionInfo
+    ${'sessionProposal'} | ${sessionProposal}
+    ${'session'}         | ${session}
+  `('returns the correct properties for $sessionType', async ({ sessionInfo }) => {
+    await expectSaga(getDefaultSessionTrackedProperties, sessionInfo)
+      .provide([[select(activeDappSelector), null]])
+      .returns({
+        version: 2,
+        dappRequestOrigin: DappRequestOrigin.External,
+        dappName: 'someName',
+        dappUrl: 'someUrl',
+        dappDescription: 'someDescription',
+        dappIcon: 'someIcon',
+        relayProtocol: 'irn',
+        eip155Events: ['chainChanged', 'accountsChanged'],
+        eip155Chains: ['eip155:44787'],
+        eip155Methods: ['eth_sendTransaction', 'eth_signTypedData'],
+      })
+      .run()
+  })
+})
+
+describe('applyIconFixIfNeeded', () => {
+  const eachMetadata = it.each`
+    metadata                    | expected
+    ${undefined}                | ${undefined}
+    ${{}}                       | ${[]}
+    ${{ icons: {} }}            | ${[]}
+    ${{ icons: [7] }}           | ${[]}
+    ${{ icons: [null] }}        | ${[]}
+    ${{ icons: [undefined] }}   | ${[]}
+    ${{ icons: [''] }}          | ${[]}
+    ${{ icons: ['something'] }} | ${['something']}
+  `
+
+  describe('with a session proposal', () => {
+    eachMetadata(
+      'fixes the `icons` property when the metadata is $metadata',
+      async ({ metadata, expected }) => {
+        const sessionProposal = createSessionProposal(metadata as WalletKitTypes.Metadata)
+        _applyIconFixIfNeeded(sessionProposal)
+        // eslint-disable-next-line jest/no-standalone-expect
+        expect(sessionProposal.params.proposer.metadata?.icons).toStrictEqual(expected)
+      }
+    )
+  })
+
+  describe('with a session', () => {
+    eachMetadata(
+      'fixes the `icons` property when the metadata is $metadata',
+      async ({ metadata, expected }) => {
+        const session = createSession(metadata as WalletKitTypes.Metadata)
+        _applyIconFixIfNeeded(session)
+        // eslint-disable-next-line jest/no-standalone-expect
+        expect(session.peer.metadata?.icons).toStrictEqual(expected)
+      }
+    )
+  })
+})
+
+// See also our comprehensive E2E tests for WalletConnect
+// The tests here are mainly to check things that are more difficult to cover from the E2E test
+describe(walletConnectSaga, () => {
+  beforeAll(() => {
+    jest.useRealTimers()
+  })
+
+  const sessionProposal = createSessionProposal({
+    url: 'someUrl',
+    icons: ['someIcon'],
+    description: 'someDescription',
+    name: 'someName',
+  })
+
+  // Sanity check to ensure `safely` does its job
+  it('continues to handle actions even when handlers previously failed unexpectedly', async () => {
+    jest.mocked(navigate).mockImplementationOnce(() => {
+      throw new Error('An unexpected failure')
+    })
+    const state = createMockStore({}).getState()
+    await expectSaga(walletConnectSaga)
+      .withState(state)
+      // This one will fail internally
+      .dispatch(sessionProposalAction(sessionProposal))
+      // This one will still succeed (previous one didn't crash the whole saga thanks to `safely`)
+      .dispatch(sessionProposalAction(sessionProposal))
+      .silentRun()
+
+    expect(navigate).toHaveBeenCalledTimes(2)
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Session,
+      pendingSession: sessionProposal,
+      namespacesToApprove: expect.anything(),
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      sessionProperties: expect.anything(),
+      scopedProperties: expect.anything(),
+    })
+  })
+
+  it('does nothing when pending length is greater than 1', async () => {
+    const sessionProposal = createSessionProposal({
+      url: 'someUrl',
+      icons: ['someIcon'],
+      description: 'someDescription',
+      name: 'someName',
+    })
+    const state = createMockStore({
+      walletConnect: {
+        pendingActions: [],
+        pendingSessions: [sessionProposal, sessionProposal],
+        sessions: [],
+      },
+    }).getState()
+
+    await expectSaga(walletConnectSaga)
+      .withState(state)
+      .dispatch(sessionProposalAction(sessionProposal))
+      .not.call(_showActionRequest, sessionProposal)
+      .run()
+  })
+})
+
+describe('showSessionRequest', () => {
+  const sessionProposal = createSessionProposal({
+    url: 'someUrl',
+    icons: ['someIcon'],
+    description: 'someDescription',
+    name: 'someName',
+  })
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.mocked(getSupportedNetworkIds).mockReturnValue([NetworkId['celo-alfajores']])
+    jest.mocked(getLockableViemSmartWallet).mockResolvedValue({
+      account: {
+        isDeployed: jest.fn().mockResolvedValue(true),
+      },
+    } as any)
+    jest.mocked(getFeatureGate).mockImplementation((gate) => {
+      if (gate === StatsigFeatureGates.DISABLE_WALLET_CONNECT_V2) {
+        return false
+      }
+      if (gate === StatsigFeatureGates.USE_SMART_ACCOUNT_CAPABILITIES) {
+        return true
+      }
+      return false
+    })
+  })
+
+  it('navigates to the screen to approve the session', async () => {
+    const state = createMockStore({}).getState()
+    await expectSaga(_showSessionRequest, sessionProposal)
+      .withState(state)
+      .provide([[select(activeDappSelector), null]])
+      .run()
+
+    expect(navigate).toHaveBeenCalledTimes(1)
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Session,
+      pendingSession: sessionProposal,
+      namespacesToApprove: expect.anything(),
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      sessionProperties: expect.anything(),
+      scopedProperties: expect.anything(),
+    })
+
+    // Check the namespaces to approve are correct
+    expect((navigate as jest.Mock).mock.calls[0][1].namespacesToApprove).toMatchInlineSnapshot(`
+      {
+        "eip155": {
+          "accounts": [
+            "eip155:44787:0x0000000000000000000000000000000000007e57",
+          ],
+          "chains": [
+            "eip155:44787",
+          ],
+          "events": [
+            "accountsChanged",
+            "chainChanged",
+          ],
+          "methods": [
+            "eth_sendTransaction",
+            "eth_signTypedData",
+          ],
+        },
+      }
+    `)
+  })
+
+  it('includes all supported chains for session approval', async () => {
+    jest
+      .mocked(getSupportedNetworkIds)
+      .mockReturnValue([NetworkId['celo-alfajores'], NetworkId['ethereum-sepolia']])
+    const state = createMockStore({}).getState()
+    await expectSaga(_showSessionRequest, sessionProposal)
+      .withState(state)
+      .provide([[select(activeDappSelector), null]])
+      .run()
+
+    expect(navigate).toHaveBeenCalledTimes(1)
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Session,
+      pendingSession: sessionProposal,
+      namespacesToApprove: expect.objectContaining({
+        eip155: expect.objectContaining({
+          // matches the chains requested by the dapp
+          chains: ['eip155:44787'],
+          accounts: ['eip155:44787:0x0000000000000000000000000000000000007e57'],
+        }),
+      }),
+      supportedChains: ['eip155:44787', 'eip155:11155111'], // matches the chains supported by the wallet
+      version: 2,
+      sessionProperties: expect.anything(),
+      scopedProperties: expect.anything(),
+    })
+  })
+
+  it('includes the session properties and scoped properties', async () => {
+    const state = createMockStore({}).getState()
+    await expectSaga(_showSessionRequest, sessionProposal)
+      .withState(state)
+      .provide([[select(activeDappSelector), null]])
+      .run()
+
+    expect(navigate).toHaveBeenCalledTimes(1)
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Session,
+      pendingSession: sessionProposal,
+      namespacesToApprove: expect.anything(),
+      supportedChains: expect.anything(),
+      version: expect.anything(),
+      scopedProperties: {
+        'eip155:44787': {
+          atomic: {
+            status: 'supported',
+          },
+          paymasterService: {
+            supported: false,
+          },
+        },
+      },
+      sessionProperties: {
+        capabilities: {
+          '0x0000000000000000000000000000000000007e57': {
+            '0xaef3': {
+              atomic: {
+                status: 'supported',
+              },
+              paymasterService: {
+                supported: false,
+              },
+            },
+          },
+        },
+      },
+    })
+  })
+
+  it('navigates to the screen to approve the session when requiring an EIP155 namespace with unsupported chains/methods/events', async () => {
+    const state = createMockStore({}).getState()
+    const session = {
+      ...sessionProposal,
+      params: {
+        ...sessionProposal.params,
+        requiredNamespaces: {
+          ...sessionProposal.params.requiredNamespaces,
+          eip155: {
+            ...sessionProposal.params.requiredNamespaces.eip155,
+            chains: ['eip155:1'], // unsupported chain
+            methods: ['eth_signTransaction', 'some_unsupported_method'],
+            events: ['accountsChanged', 'some_unsupported_event'],
+          },
+        },
+        optionalNamespaces: {
+          eip155: {
+            chains: ['eip155:44787'], // this optional chain is supported and will be added to the approved namespaces
+            methods: ['eth_signTransaction', 'some_optional_unsupported_method'],
+            events: ['accountsChanged', 'some_optional_unsupported_event'],
+          },
+        },
+      },
+    }
+    await expectSaga(_showSessionRequest, session)
+      .withState(state)
+      .provide([[select(activeDappSelector), null]])
+      .run()
+
+    expect(navigate).toHaveBeenCalledTimes(1)
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Session,
+      pendingSession: session,
+      namespacesToApprove: expect.anything(),
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      sessionProperties: expect.anything(),
+      scopedProperties: expect.anything(),
+    })
+
+    // Check the namespaces to approve are correct
+    // Note that it includes the unsupported eip155 chains/methods/events
+    // + the optional eip155 chain (because it's supported)
+    expect((navigate as jest.Mock).mock.calls[0][1].namespacesToApprove).toMatchInlineSnapshot(`
+      {
+        "eip155": {
+          "accounts": [
+            "eip155:1:0x0000000000000000000000000000000000007e57",
+            "eip155:44787:0x0000000000000000000000000000000000007e57",
+          ],
+          "chains": [
+            "eip155:1",
+            "eip155:44787",
+          ],
+          "events": [
+            "accountsChanged",
+            "some_unsupported_event",
+          ],
+          "methods": [
+            "eth_signTransaction",
+            "some_unsupported_method",
+          ],
+        },
+      }
+    `)
+  })
+
+  it('navigates to the screen to reject the session when requiring a non EIP155 namespace', async () => {
+    const state = createMockStore({}).getState()
+    const session = {
+      ...sessionProposal,
+      params: {
+        ...sessionProposal.params,
+        requiredNamespaces: {
+          solana: {
+            methods: ['solana_signTransaction', 'solana_signMessage'],
+            chains: ['solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ'],
+            events: ['some_event'],
+          },
+        },
+      },
+    }
+    await expectSaga(_showSessionRequest, session)
+      .withState(state)
+      .provide([[select(activeDappSelector), null]])
+      .run()
+
+    expect(navigate).toHaveBeenCalledTimes(1)
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Session,
+      pendingSession: session,
+      namespacesToApprove: null,
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      sessionProperties: expect.anything(),
+      scopedProperties: expect.anything(),
+    })
+  })
+
+  it('falls back to default capabilities when feature gate is disabled', async () => {
+    jest.mocked(getFeatureGate).mockImplementation((gate) => {
+      if (gate === StatsigFeatureGates.DISABLE_WALLET_CONNECT_V2) {
+        return false
+      }
+      if (gate === StatsigFeatureGates.USE_SMART_ACCOUNT_CAPABILITIES) {
+        return false
+      }
+      return false
+    })
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showSessionRequest, sessionProposal)
+      .withState(state)
+      .provide([[select(activeDappSelector), null]])
+      .run()
+
+    expect(navigate).toHaveBeenCalledTimes(1)
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Session,
+      pendingSession: sessionProposal,
+      namespacesToApprove: expect.anything(),
+      supportedChains: expect.anything(),
+      version: expect.anything(),
+      scopedProperties: {
+        'eip155:44787': {
+          atomic: {
+            status: 'unsupported',
+          },
+          paymasterService: {
+            supported: false,
+          },
+        },
+      },
+      sessionProperties: {
+        capabilities: {
+          '0x0000000000000000000000000000000000007e57': {
+            '0xaef3': {
+              atomic: {
+                status: 'unsupported',
+              },
+              paymasterService: {
+                supported: false,
+              },
+            },
+          },
+        },
+      },
+    })
+  })
+})
+
+describe('acceptSession', () => {
+  const sessionProposal = createSessionProposal({
+    url: 'someUrl',
+    icons: ['someIcon'],
+    description: 'someDescription',
+    name: 'someName',
+  })
+  let mockClient: any
+
+  beforeEach(() => {
+    mockClient = {
+      approveSession: jest.fn(),
+      getActiveSessions: jest.fn(() => {
+        return Promise.resolve({
+          x: {
+            pairingTopic: sessionProposal.params.pairingTopic,
+          },
+        })
+      }),
+    }
+    _setClientForTesting(mockClient as any)
+  })
+
+  it('successfully accepts the session', async () => {
+    const state = createMockStore({}).getState()
+
+    const approvedNamespaces = buildApprovedNamespaces({
+      proposal: sessionProposal.params,
+      supportedNamespaces: {
+        eip155: {
+          chains: ['eip155:44787'],
+          methods: Object.values(SupportedActions) as string[],
+          events: Object.values(SupportedEvents) as string[],
+          accounts: [`eip155:44787:${mockAccount}`],
+        },
+      },
+    })
+
+    await expectSaga(_acceptSession, acceptSessionAction(sessionProposal, approvedNamespaces))
+      .withState(state)
+      .provide([[call(isBottomSheetVisible, Screens.WalletConnectRequest), false]])
+      .put.actionType(Actions.SESSION_CREATED)
+      .put(showMessage(i18n.t('connectionSuccess', { dappName: 'someName' })))
+      .run()
+
+    expect(mockClient.approveSession).toHaveBeenCalledTimes(1)
+    expect(mockClient.approveSession.mock.calls[0]).toMatchInlineSnapshot(`
+      [
+        {
+          "id": 1669989187506938,
+          "namespaces": {
+            "eip155": {
+              "accounts": [
+                "eip155:44787:0x0000000000000000000000000000000000007E57",
+              ],
+              "chains": [
+                "eip155:44787",
+              ],
+              "events": [
+                "accountsChanged",
+                "chainChanged",
+              ],
+              "methods": [
+                "eth_sendTransaction",
+                "eth_signTypedData",
+              ],
+            },
+          },
+          "relayProtocol": "irn",
+        },
+      ]
+    `)
+  })
+})
+
+describe('showActionRequest', () => {
+  const actionRequest: WalletKitTypes.EventArguments['session_request'] = {
+    id: 1707297778331031,
+    topic: '243b33442b6190b97055201b5a8817f4e604e3f37b5376e78ee0b3715cc6211c',
+    params: {
+      request: {
+        method: 'eth_sendTransaction',
+        params: [
+          {
+            data: '0x580d747a0000000000000000000000007194dfe766a92308880a943fd70f31c8e7c50e66000000000000000000000000000000000000000000000000002386f26fc100000000000000000000000000007c75b0b81a54359e9dccda9cb663ca2e3de6b71000000000000000000000000089d5bd54c43ddd10905a030de6ff02ebb6c51654',
+            from: '0xccc9576F841de93Cd32bEe7B98fE8B9BD3070e3D',
+            to: '0x8D6677192144292870907E3Fa8A5527fE55A7ff6',
+          },
+        ],
+      },
+      chainId: 'eip155:42220',
+    },
+    verifyContext: {
+      verified: {
+        verifyUrl: 'https://verify.walletconnect.com',
+        validation: 'UNKNOWN',
+        origin: 'https://churrito.fi',
+      },
+    },
+  }
+  const session = createSession({
+    url: 'someUrl',
+    icons: ['someIcon'],
+    description: 'someDescription',
+    name: 'someName',
+  })
+
+  let mockClient: any
+
+  beforeEach(() => {
+    mockClient = {
+      approveSession: jest.fn(),
+      getActiveSessions: jest.fn(() => {
+        return Promise.resolve({
+          [actionRequest.topic]: session,
+        })
+      }),
+    }
+    _setClientForTesting(mockClient as any)
+  })
+
+  it('navigates to the screen to approve the request', async () => {
+    const mockPreparedTransactions = {
+      type: 'possible',
+      transactions: [
+        {
+          from: '0xfrom',
+          to: '0xto',
+          data: '0xdata',
+        },
+      ],
+    }
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, actionRequest)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [
+          call(getTransactionCount, publicClient[Network.Celo], {
+            address: mockAccount,
+            blockTag: 'pending',
+          }),
+          123,
+        ],
+        [call.fn(prepareTransactions), mockPreparedTransactions],
+      ])
+      .run()
+
+    // 2 calls, one in loading state and one in the action request state
+    expect(navigate).toHaveBeenCalledTimes(2)
+    expect(navigate).toHaveBeenNthCalledWith(1, Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Loading,
+      origin: WalletConnectPairingOrigin.Deeplink,
+    })
+    expect(navigate).toHaveBeenNthCalledWith(2, Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Action,
+      method: SupportedActions.eth_sendTransaction,
+      request: actionRequest,
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      hasInsufficientGasFunds: false,
+      feeCurrenciesSymbols: [],
+      preparedRequest: {
+        success: true,
+        data: mockPreparedTransactions.transactions[0],
+      },
+    })
+  })
+
+  it('navigates to the screen to reject the request when the transaction preparation fails', async () => {
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, actionRequest)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [
+          call(getTransactionCount, publicClient[Network.Celo], {
+            address: mockAccount,
+            blockTag: 'pending',
+          }),
+          123,
+        ],
+        [call.fn(prepareTransactions), throwError(new Error('Some error'))],
+      ])
+      .run()
+
+    // 2 calls, one in loading state and one in the action request state
+    expect(navigate).toHaveBeenCalledTimes(2)
+    expect(navigate).toHaveBeenNthCalledWith(1, Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Loading,
+      origin: WalletConnectPairingOrigin.Deeplink,
+    })
+    expect(navigate).toHaveBeenNthCalledWith(2, Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Action,
+      method: SupportedActions.eth_sendTransaction,
+      request: actionRequest,
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      hasInsufficientGasFunds: false,
+      feeCurrenciesSymbols: [],
+      preparedRequest: {
+        success: false,
+        errorMessage: 'Some error',
+      },
+    })
+  })
+
+  it('navigates to the screen to reject the request when the transaction preparation fails with a viem error', async () => {
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, actionRequest)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [
+          call(getTransactionCount, publicClient[Network.Celo], {
+            address: mockAccount,
+            blockTag: 'pending',
+          }),
+          123,
+        ],
+        [call.fn(prepareTransactions), throwError(new BaseError('viem short message', {}))],
+      ])
+      .run()
+
+    // 2 calls, one in loading state and one in the action request state
+    expect(navigate).toHaveBeenCalledTimes(2)
+    expect(navigate).toHaveBeenNthCalledWith(1, Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Loading,
+      origin: WalletConnectPairingOrigin.Deeplink,
+    })
+    expect(navigate).toHaveBeenNthCalledWith(2, Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Action,
+      method: SupportedActions.eth_sendTransaction,
+      request: actionRequest,
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      hasInsufficientGasFunds: false,
+      feeCurrenciesSymbols: [],
+      preparedRequest: {
+        success: false,
+        errorMessage: 'viem short message',
+      },
+    })
+  })
+
+  it('accepts non-interactive requests immediately without navigation', async () => {
+    const nonInteractiveRequest: WalletKitTypes.EventArguments['session_request'] = {
+      ...actionRequest,
+      params: {
+        ...actionRequest.params,
+        request: {
+          method: 'wallet_getCapabilities',
+          params: [mockAccount],
+        },
+      },
+    }
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, nonInteractiveRequest)
+      .withState(state)
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .put(
+        acceptRequest({
+          method: SupportedActions.wallet_getCapabilities,
+          request: nonInteractiveRequest,
+        })
+      )
+      .run()
+
+    // Should not navigate to any screen
+    expect(navigate).not.toHaveBeenCalled()
+  })
+
+  it('denies wallet_getCapabilities when address param is missing', async () => {
+    const req: WalletKitTypes.EventArguments['session_request'] = {
+      ...actionRequest,
+      params: {
+        ...actionRequest.params,
+        request: {
+          method: 'wallet_getCapabilities',
+          params: [],
+        },
+      },
+    }
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, req)
+      .withState(state)
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .put(denyRequest(req, { code: -32602, message: 'Invalid params' }))
+      .run()
+  })
+
+  it('denies wallet_getCapabilities when address does not match wallet address', async () => {
+    const req: WalletKitTypes.EventArguments['session_request'] = {
+      ...actionRequest,
+      params: {
+        ...actionRequest.params,
+        request: {
+          method: 'wallet_getCapabilities',
+          params: ['0x0000000000000000000000000000000000000000'],
+        },
+      },
+    }
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, req)
+      .withState(state)
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .put(denyRequest(req, { code: 4100, message: 'Unauthorized' }))
+      .run()
+  })
+
+  it('denies wallet_getCapabilities when requestedChainIds is not an array', async () => {
+    const req: WalletKitTypes.EventArguments['session_request'] = {
+      ...actionRequest,
+      params: {
+        ...actionRequest.params,
+        request: {
+          method: 'wallet_getCapabilities',
+          params: [mockAccount, 'not_an_array' as any],
+        },
+      },
+    }
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, req)
+      .withState(state)
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .put(denyRequest(req, { code: -32602, message: 'Invalid params' }))
+      .run()
+  })
+
+  it('denies wallet_getCapabilities when requestedChainIds is an empty array', async () => {
+    const req: WalletKitTypes.EventArguments['session_request'] = {
+      ...actionRequest,
+      params: {
+        ...actionRequest.params,
+        request: {
+          method: 'wallet_getCapabilities',
+          params: [mockAccount, []],
+        },
+      },
+    }
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, req)
+      .withState(state)
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .put(denyRequest(req, { code: -32602, message: 'Invalid params' }))
+      .run()
+  })
+
+  it('denies wallet_getCapabilities when requestedChainIds contains non-hex values', async () => {
+    const req: WalletKitTypes.EventArguments['session_request'] = {
+      ...actionRequest,
+      params: {
+        ...actionRequest.params,
+        request: {
+          method: 'wallet_getCapabilities',
+          params: [mockAccount, ['0xaa36a7', 'invalid_chain_id', '0x66eee']],
+        },
+      },
+    }
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, req)
+      .withState(state)
+      .provide([[select(walletAddressSelector), mockAccount]])
+      .put(denyRequest(req, { code: -32602, message: 'Invalid params' }))
+      .run()
+  })
+
+  it('denies wallet_getCallsStatus when id param is missing', async () => {
+    const req: WalletKitTypes.EventArguments['session_request'] = {
+      ...actionRequest,
+      params: {
+        ...actionRequest.params,
+        request: {
+          method: 'wallet_getCallsStatus',
+          params: [],
+        },
+      },
+    }
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, req)
+      .withState(state)
+      .put(denyRequest(req, rpcError.INVALID_PARAMS))
+      .run()
+
+    expect(navigate).not.toHaveBeenCalled()
+  })
+
+  it('denies wallet_getCallsStatus when batch id is unknown', async () => {
+    const req: WalletKitTypes.EventArguments['session_request'] = {
+      ...actionRequest,
+      params: {
+        ...actionRequest.params,
+        request: {
+          method: 'wallet_getCallsStatus',
+          params: ['0xabc'],
+        },
+      },
+    }
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, req)
+      .withState(state)
+      .put(denyRequest(req, rpcError.UNKNOWN_BUNDLE_ID))
+      .run()
+
+    expect(navigate).not.toHaveBeenCalled()
+  })
+
+  it('accepts wallet_getCallsStatus when batch id exists and is valid', async () => {
+    const batchId = '0x123'
+    const mockBatch = {
+      transactionHashes: ['0x1' as const, '0x2' as const],
+      atomic: false,
+      expiresAt: Date.now() + 5000,
+    }
+
+    const req: WalletKitTypes.EventArguments['session_request'] = {
+      ...actionRequest,
+      params: {
+        ...actionRequest.params,
+        request: {
+          method: 'wallet_getCallsStatus',
+          params: [batchId],
+        },
+      },
+    }
+
+    const state = createMockStore({
+      sendCalls: {
+        batchById: {
+          [batchId]: mockBatch,
+        },
+      },
+    }).getState()
+
+    await expectSaga(_showActionRequest, req)
+      .withState(state)
+      .put(
+        acceptRequest({
+          method: SupportedActions.wallet_getCallsStatus,
+          request: req,
+          id: batchId,
+          batch: mockBatch,
+        })
+      )
+      .run()
+
+    expect(navigate).not.toHaveBeenCalled()
+  })
+
+  it('throws an error when client is missing', () => {
+    _setClientForTesting(null)
+
+    return expect(expectSaga(_showActionRequest, mockRequest).run()).rejects.toThrow(
+      'missing client'
+    )
+  })
+})
+
+const v2ConnectionString =
+  'wc:79a02f869d0f921e435a5e0643304548ebfa4a0430f9c66fe8b1a9254db7ef77@2?relay-protocol=irn&symKey=f661b0a9316a4ce0b6892bdce42bea0f45037f2c1bee9e118a3a4bc868a32a39'
+
+describe('initialiseWalletConnect', () => {
+  const origin = WalletConnectPairingOrigin.Deeplink
+  it('initializes v2 if enabled and there is a wallet connect project id', async () => {
+    jest.mocked(getAppConfig).mockReturnValue({
+      displayName: 'Test App',
+      deepLinkUrlScheme: 'testapp',
+      registryName: 'test',
+      features: {
+        walletConnect: {
+          projectId: '123',
+        },
+      },
+    })
+    await expectSaga(initialiseWalletConnect, v2ConnectionString, origin)
+      .provide([[call(initialiseWalletConnectV2, v2ConnectionString, origin), {}]])
+      .call(initialiseWalletConnectV2, v2ConnectionString, origin)
+      .run()
+  })
+
+  it('doesnt initialize v2 if disabled', async () => {
+    jest.mocked(getFeatureGate).mockImplementation((featureGate) => {
+      if (featureGate === StatsigFeatureGates.DISABLE_WALLET_CONNECT_V2) {
+        return true
+      }
+      throw new Error(`Unexpected feature gate: ${featureGate}`)
+    })
+    await expectSaga(initialiseWalletConnect, v2ConnectionString, origin)
+      .not.call(initialiseWalletConnectV2, v2ConnectionString, origin)
+      .run()
+  })
+
+  it('doesnt initialize v2 if there is no wallet connect project id', async () => {
+    jest.mocked(getAppConfig).mockReturnValue({
+      displayName: 'Test App',
+      deepLinkUrlScheme: 'testapp',
+      registryName: 'test',
+    })
+    jest.mocked(getFeatureGate).mockImplementation((featureGate) => {
+      if (featureGate === StatsigFeatureGates.DISABLE_WALLET_CONNECT_V2) {
+        return false
+      }
+      throw new Error(`Unexpected feature gate: ${featureGate}`)
+    })
+    await expectSaga(initialiseWalletConnect, v2ConnectionString, origin)
+      .not.call(initialiseWalletConnectV2, v2ConnectionString, origin)
+      .run()
+  })
+})
+
+describe('normalizeTransactions', () => {
+  function createDefaultProviders(network: Network) {
+    const defaultProviders: (EffectProviders | StaticProvider)[] = [
+      [select(walletAddressSelector), mockAccount],
+      [
+        call(getTransactionCount, publicClient[network], {
+          address: mockAccount,
+          blockTag: 'pending',
+        }),
+        123,
+      ],
+    ]
+
+    return defaultProviders
+  }
+
+  function callNormalizeTransactions(transaction: any, network: Network) {
+    return expectSaga(normalizeTransactions, [transaction], network)
+      .provide(createDefaultProviders(network))
+      .run()
+      .then((result) => result.returnValue[0])
+  }
+
+  it('ensures `gasLimit` value is removed and used as `gas` instead', async () => {
+    expect(
+      await callNormalizeTransactions(
+        {
+          from: '0xTEST',
+          data: '0xABC',
+          gasLimit: '0x5208',
+        },
+        Network.Ethereum
+      )
+    ).toStrictEqual({
+      data: '0xABC',
+      from: '0xTEST',
+      gas: BigInt(21000),
+      nonce: 123,
+    })
+  })
+
+  it('ensures `gasPrice` is stripped away', async () => {
+    expect(
+      await callNormalizeTransactions(
+        { from: '0xTEST', data: '0xABC', gasPrice: '0x5208' },
+        Network.Celo
+      )
+    ).toStrictEqual({
+      data: '0xABC',
+      from: '0xTEST',
+      nonce: 123,
+    })
+  })
+
+  it('ensures `gas` and `feeCurrency` is stripped away for a Celo transaction request', async () => {
+    expect(
+      await callNormalizeTransactions(
+        { from: '0xTEST', data: '0xABC', gas: '0x5208', feeCurrency: '0xabcd' },
+        Network.Celo
+      )
+    ).toStrictEqual({
+      data: '0xABC',
+      from: '0xTEST',
+      nonce: 123,
+    })
+  })
+
+  it('does not strip away `gas` for non-Celo transaction request', async () => {
+    expect(
+      await callNormalizeTransactions(
+        { from: '0xTEST', data: '0xABC', gas: '0x5208' },
+        Network.Ethereum
+      )
+    ).toStrictEqual({
+      data: '0xABC',
+      from: '0xTEST',
+      gas: BigInt(21000),
+      nonce: 123,
+    })
+  })
+
+  it('accepts `nonce` as a hex string', async () => {
+    expect(
+      await callNormalizeTransactions(
+        { from: '0xTEST', data: '0xABC', nonce: '0x19' },
+        Network.Ethereum
+      )
+    ).toStrictEqual({
+      data: '0xABC',
+      from: '0xTEST',
+      nonce: 25,
+    })
+  })
+
+  it('accepts `nonce` as a string containing a number', async () => {
+    expect(
+      await callNormalizeTransactions(
+        { from: '0xTEST', data: '0xABC', nonce: '19' },
+        Network.Ethereum
+      )
+    ).toStrictEqual({
+      data: '0xABC',
+      from: '0xTEST',
+      nonce: 19,
+    })
+  })
+
+  it('accepts `nonce` as a number', async () => {
+    expect(
+      await callNormalizeTransactions(
+        { from: '0xTEST', data: '0xABC', nonce: 19 },
+        Network.Ethereum
+      )
+    ).toStrictEqual({
+      data: '0xABC',
+      from: '0xTEST',
+      nonce: 19,
+    })
+  })
+
+  it('strips `chainId` if present', async () => {
+    expect(
+      await callNormalizeTransactions(
+        { from: '0xTEST', data: '0xABC', chainId: 1 },
+        Network.Ethereum
+      )
+    ).toStrictEqual({
+      data: '0xABC',
+      from: '0xTEST',
+      nonce: 123,
+    })
+  })
+
+  for (const bigIntKey of ['gas', 'maxFeePerGas', 'maxPriorityFeePerGas', 'value']) {
+    it(`accepts \`${bigIntKey}\` as a hex string`, async () => {
+      expect(
+        await callNormalizeTransactions(
+          { from: '0xTEST', data: '0xABC', [bigIntKey]: '0x19' },
+          Network.Ethereum
+        )
+      ).toStrictEqual({
+        data: '0xABC',
+        from: '0xTEST',
+        nonce: 123,
+        [bigIntKey]: BigInt('0x19'),
+      })
+    })
+
+    it(`accepts \`${bigIntKey}\` as a string containing a number`, async () => {
+      expect(
+        await callNormalizeTransactions(
+          { from: '0xTEST', data: '0xABC', [bigIntKey]: '19' },
+          Network.Ethereum
+        )
+      ).toStrictEqual({
+        data: '0xABC',
+        from: '0xTEST',
+        nonce: 123,
+        [bigIntKey]: BigInt(19),
+      })
+    })
+
+    it(`accepts \`${bigIntKey}\` as a number`, async () => {
+      expect(
+        await callNormalizeTransactions(
+          { from: '0xTEST', data: '0xABC', [bigIntKey]: 19 },
+          Network.Ethereum
+        )
+      ).toStrictEqual({
+        data: '0xABC',
+        from: '0xTEST',
+        nonce: 123,
+        [bigIntKey]: BigInt(19),
+      })
+    })
+  }
+
+  it('assigns consecutive nonces to transactions when nonce is not provided for the first transaction', async () => {
+    await expectSaga(
+      normalizeTransactions,
+      [
+        { from: '0xTEST', data: '0xABC' },
+        { from: '0xTEST', data: '0xABC' },
+      ],
+      Network.Ethereum
+    )
+      .provide(createDefaultProviders(Network.Ethereum))
+      .returns([
+        {
+          data: '0xABC',
+          from: '0xTEST',
+          nonce: 123,
+        },
+        {
+          data: '0xABC',
+          from: '0xTEST',
+          nonce: 124,
+        },
+      ])
+      .run()
+  })
+
+  it('assigns consecutive nonces to transactions when nonce is provided for the first transaction', async () => {
+    await expectSaga(
+      normalizeTransactions,
+      [
+        { from: '0xTEST', data: '0xABC', nonce: '0x0' },
+        { from: '0xTEST', data: '0xABC', nonce: '0xF' },
+      ],
+      Network.Ethereum
+    )
+      .provide(createDefaultProviders(Network.Ethereum))
+      .returns([
+        {
+          data: '0xABC',
+          from: '0xTEST',
+          nonce: 0,
+        },
+        {
+          data: '0xABC',
+          from: '0xTEST',
+          nonce: 1,
+        },
+      ])
+      .run()
+  })
+
+  it('ensures `from` is set to the wallet address', async () => {
+    const result = await expectSaga(normalizeTransactions, [{ data: '0xABC' }], Network.Ethereum)
+      .provide(createDefaultProviders(Network.Ethereum))
+      .run()
+
+    expect(result.returnValue[0]).toMatchObject({
+      from: mockAccount,
+    })
+  })
+})
+
+const mockRequest = {
+  id: 1,
+  topic: 'topic',
+  params: {
+    request: { method: 'eth_sendTransaction', params: [] },
+    chainId: 'eip155:1',
+  },
+  verifyContext: {
+    verified: { origin: '', validation: 'UNKNOWN', verifyUrl: '' },
+  },
+} as any
+
+describe('handleIncomingActionRequest', () => {
+  beforeEach(() => {
+    _setClientForTesting(null)
+  })
+
+  it('throws an error when client is missing', () => {
+    return expect(expectSaga(_showActionRequest, mockRequest).run()).rejects.toThrow(
+      'missing client'
+    )
+  })
+})
+
+describe('getSessionFromRequest', () => {
+  beforeEach(() => {
+    _setClientForTesting(null)
+  })
+
+  it('throws an error when client is missing', () => {
+    return expect(expectSaga(getSessionFromRequest, mockRequest).run()).rejects.toThrow(
+      'missing client'
+    )
+  })
+})
+
+describe('wallet_sendCalls', () => {
+  const topic = '243b33442b6190b97055201b5a8817f4e604e3f37b5376e78ee0b3715cc6211c'
+  const createSendCallsRequest = (overrides: any = {}) => ({
+    id: 1707297778331031,
+    topic,
+    params: {
+      request: {
+        method: 'wallet_sendCalls',
+        params: [
+          {
+            id: '0xabc',
+            calls: [
+              {
+                to: '0x8D6677192144292870907E3Fa8A5527fE55A7ff6',
+                data: '0x580d747a0000000000000000000000007194dfe766a92308880a943fd70f31c8e7c50e66000000000000000000000000000000000000000000000000002386f26fc100000000000000000000000000007c75b0b81a54359e9dccda9cb663ca2e3de6b71000000000000000000000000089d5bd54c43ddd10905a030de6ff02ebb6c51654',
+                value: '0x0',
+              },
+            ],
+            capabilities: {},
+            atomicRequired: false,
+          },
+        ],
+      },
+      chainId: 'eip155:44787',
+    },
+    verifyContext: {
+      verified: {
+        verifyUrl: 'https://verify.walletconnect.com',
+        validation: 'UNKNOWN',
+        origin: 'https://churrito.fi',
+      },
+    },
+    ...overrides,
+  })
+
+  const session = createSession({
+    url: 'someUrl',
+    icons: ['someIcon'],
+    description: 'someDescription',
+    name: 'someName',
+  })
+
+  const mockPreparedTransactions = {
+    type: 'possible',
+    transactions: [{ from: '0xfrom', to: '0xto', data: '0xdata' }],
+  }
+
+  let mockClient: any
+
+  beforeEach(() => {
+    mockClient = {
+      approveSession: jest.fn(),
+      getActiveSessions: jest.fn(() => {
+        return Promise.resolve({
+          [topic]: session,
+        })
+      }),
+    }
+    _setClientForTesting(mockClient as any)
+  })
+
+  afterEach(() => {
+    _setClientForTesting(null)
+  })
+
+  it('denies request when required global capabilities are not supported', async () => {
+    const request = createSendCallsRequest({
+      params: {
+        request: {
+          method: 'wallet_sendCalls',
+          params: [
+            {
+              id: '0xabc',
+              calls: [{ to: '0xTEST', data: '0x' }],
+              capabilities: {
+                paymasterService: { optional: false }, // required
+              },
+              atomicRequired: false,
+            },
+          ],
+        },
+        chainId: 'eip155:44787',
+      },
+    })
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, request)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [select(demoModeEnabledSelector), false],
+        [
+          call(getTransactionCount, publicClient[Network.Celo], {
+            address: mockAccount,
+            blockTag: 'pending',
+          }),
+          123,
+        ],
+      ])
+      .put(denyRequest(request, rpcError.UNSUPPORTED_NON_OPTIONAL_CAPABILITY))
+      .run()
+
+    expect(navigate).not.toHaveBeenCalled()
+  })
+
+  it('allows request when global capabilities are optional and not supported', async () => {
+    const request = createSendCallsRequest({
+      params: {
+        request: {
+          method: 'wallet_sendCalls',
+          params: [
+            {
+              id: '0xabc',
+              calls: [{ to: '0xTEST', data: '0x' }],
+              capabilities: {
+                paymasterService: { optional: true }, // optional
+              },
+              atomicRequired: false,
+            },
+          ],
+        },
+        chainId: 'eip155:44787',
+      },
+    })
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, request)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [select(demoModeEnabledSelector), false],
+        [
+          call(getTransactionCount, publicClient[Network.Celo], {
+            address: mockAccount,
+            blockTag: 'pending',
+          }),
+          123,
+        ],
+        [call.fn(prepareTransactions), mockPreparedTransactions],
+      ])
+      .run()
+
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Action,
+      method: SupportedActions.wallet_sendCalls,
+      request,
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      hasInsufficientGasFunds: false,
+      feeCurrenciesSymbols: ['CELO', 'cEUR', 'cUSD'],
+      preparedRequest: {
+        success: true,
+        data: mockPreparedTransactions.transactions,
+      },
+      atomic: false,
+    })
+  })
+
+  it('denies request when per-call required capabilities are not supported', async () => {
+    const request = createSendCallsRequest({
+      params: {
+        request: {
+          method: 'wallet_sendCalls',
+          params: [
+            {
+              id: '0xabc',
+              calls: [
+                {
+                  to: '0xTEST',
+                  data: '0x',
+                  capabilities: {
+                    paymasterService: { optional: false }, // required
+                  },
+                },
+              ],
+              capabilities: {},
+              atomicRequired: false,
+            },
+          ],
+        },
+        chainId: 'eip155:44787',
+      },
+    })
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, request)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [select(demoModeEnabledSelector), false],
+        [
+          call(getTransactionCount, publicClient[Network.Celo], {
+            address: mockAccount,
+            blockTag: 'pending',
+          }),
+          123,
+        ],
+      ])
+      .put(denyRequest(request, rpcError.UNSUPPORTED_NON_OPTIONAL_CAPABILITY))
+      .run()
+
+    expect(navigate).not.toHaveBeenCalled()
+  })
+
+  it('allows request when per-call capabilities are optional and not supported', async () => {
+    const request = createSendCallsRequest({
+      params: {
+        request: {
+          method: 'wallet_sendCalls',
+          params: [
+            {
+              id: '0xabc',
+              calls: [
+                {
+                  to: '0xTEST',
+                  data: '0x',
+                  capabilities: {
+                    atomic: { optional: true }, // optional
+                  },
+                },
+              ],
+              capabilities: {},
+              atomicRequired: false,
+            },
+          ],
+        },
+        chainId: 'eip155:44787',
+      },
+    })
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, request)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [select(demoModeEnabledSelector), false],
+        [
+          call(getTransactionCount, publicClient[Network.Celo], {
+            address: mockAccount,
+            blockTag: 'pending',
+          }),
+          123,
+        ],
+        [call.fn(prepareTransactions), mockPreparedTransactions],
+      ])
+      .run()
+
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Action,
+      method: SupportedActions.wallet_sendCalls,
+      request,
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      hasInsufficientGasFunds: false,
+      feeCurrenciesSymbols: ['CELO', 'cEUR', 'cUSD'],
+      preparedRequest: {
+        success: true,
+        data: mockPreparedTransactions.transactions,
+      },
+      atomic: false,
+    })
+  })
+
+  it('denies request when atomic execution is required but not supported', async () => {
+    const request = createSendCallsRequest({
+      params: {
+        request: {
+          method: 'wallet_sendCalls',
+          params: [
+            {
+              id: '0xabc',
+              calls: [{ to: '0xTEST', data: '0x' }],
+              capabilities: {},
+              atomicRequired: true, // required
+            },
+          ],
+        },
+        chainId: 'eip155:44787',
+      },
+    })
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, request)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [select(demoModeEnabledSelector), false],
+        [
+          call(getTransactionCount, publicClient[Network.Celo], {
+            address: mockAccount,
+            blockTag: 'pending',
+          }),
+          123,
+        ],
+      ])
+      .put(denyRequest(request, rpcError.ATOMICITY_NOT_SUPPORTED))
+      .run()
+
+    expect(navigate).not.toHaveBeenCalled()
+  })
+
+  it('allows request when atomic execution is not required', async () => {
+    const request = createSendCallsRequest({
+      params: {
+        request: {
+          method: 'wallet_sendCalls',
+          params: [
+            {
+              id: '0xabc',
+              calls: [{ to: '0xTEST', data: '0x' }],
+              capabilities: {},
+              atomicRequired: false, // not required
+            },
+          ],
+        },
+        chainId: 'eip155:44787',
+      },
+    })
+
+    const state = createMockStore({}).getState()
+    await expectSaga(_showActionRequest, request)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [select(demoModeEnabledSelector), false],
+        [
+          call(getTransactionCount, publicClient[Network.Celo], {
+            address: mockAccount,
+            blockTag: 'pending',
+          }),
+          123,
+        ],
+        [call.fn(prepareTransactions), mockPreparedTransactions],
+      ])
+      .run()
+
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Action,
+      method: SupportedActions.wallet_sendCalls,
+      request,
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      hasInsufficientGasFunds: false,
+      feeCurrenciesSymbols: ['CELO', 'cEUR', 'cUSD'],
+      preparedRequest: {
+        success: true,
+        data: mockPreparedTransactions.transactions,
+      },
+      atomic: false,
+    })
+  })
+
+  it('denies request when ID is already known', async () => {
+    const duplicateId = '0xduplicate123'
+    const request = createSendCallsRequest({
+      params: {
+        request: {
+          method: 'wallet_sendCalls',
+          params: [
+            {
+              id: duplicateId,
+              calls: [{ to: '0xTEST', data: '0x' }],
+              capabilities: {},
+              atomicRequired: false,
+            },
+          ],
+        },
+        chainId: 'eip155:44787',
+      },
+    })
+
+    const state = createMockStore({
+      sendCalls: {
+        batchById: {
+          // an existing batch that has the same ID
+          [duplicateId]: {
+            transactionHashes: ['0xhash1' as const, '0xhash2' as const],
+            atomic: false,
+            expiresAt: Date.now() + 1000,
+          },
+        },
+      },
+    }).getState()
+
+    await expectSaga(_showActionRequest, request)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [select(demoModeEnabledSelector), false],
+      ])
+      .put(denyRequest(request, rpcError.DUPLICATE_ID))
+      .run()
+
+    expect(navigate).not.toHaveBeenCalled()
+  })
+})
+
+describe('handlePendingState', () => {
+  let mockClient: any
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.mocked(getFeatureGate).mockImplementation((featureGate) => {
+      if (featureGate === StatsigFeatureGates.USE_SMART_ACCOUNT_CAPABILITIES) {
+        return false
+      }
+      throw new Error(`Unexpected feature gate: ${featureGate}`)
+    })
+    mockClient = {
+      approveSession: jest.fn(),
+      getActiveSessions: jest.fn(() => {
+        return Promise.resolve({})
+      }),
+    }
+    _setClientForTesting(mockClient as any)
+  })
+
+  afterEach(() => {
+    _setClientForTesting(null)
+  })
+
+  it('shows session request when pending session exists', async () => {
+    const sessionProposal = createSessionProposal({
+      url: 'someUrl',
+      icons: ['someIcon'],
+      description: 'someDescription',
+      name: 'someName',
+    })
+    const state = createMockStore({
+      walletConnect: {
+        pendingActions: [],
+        pendingSessions: [sessionProposal],
+        sessions: [],
+      },
+    }).getState()
+
+    await expectSaga(handlePendingState)
+      .withState(state)
+      .provide([[select(activeDappSelector), null]])
+      .call(_showSessionRequest, sessionProposal)
+      .run()
+
+    expect(navigate).toHaveBeenCalledWith(Screens.WalletConnectRequest, {
+      type: WalletConnectRequestType.Session,
+      pendingSession: sessionProposal,
+      namespacesToApprove: expect.anything(),
+      supportedChains: ['eip155:44787'],
+      version: 2,
+      sessionProperties: expect.anything(),
+      scopedProperties: expect.anything(),
+    })
+  })
+
+  it('shows action request when pending action exists', async () => {
+    mockClient.getActiveSessions.mockReturnValue(
+      Promise.resolve({
+        [mockRequest.topic]: createSession({
+          url: 'someUrl',
+          icons: ['someIcon'],
+          description: 'someDescription',
+          name: 'someName',
+        }),
+      })
+    )
+
+    const state = createMockStore({
+      walletConnect: {
+        pendingActions: [mockRequest],
+        pendingSessions: [],
+        sessions: [],
+      },
+    }).getState()
+
+    await expectSaga(handlePendingState)
+      .withState(state)
+      .provide([
+        [select(walletAddressSelector), mockAccount],
+        [select(demoModeEnabledSelector), false],
+        [
+          call(getTransactionCount, publicClient[Network.Ethereum], {
+            address: mockAccount,
+            blockTag: 'pending',
+          }),
+          123,
+        ],
+      ])
+      .call(_showActionRequest, mockRequest)
+      .run()
+  })
+
+  it('does nothing when no pending sessions or actions exist', async () => {
+    const state = createMockStore({
+      walletConnect: {
+        pendingActions: [],
+        pendingSessions: [],
+        sessions: [],
+      },
+    }).getState()
+
+    await expectSaga(handlePendingState).withState(state).run()
+
+    expect(navigate).not.toHaveBeenCalled()
+  })
+})