@0xsequence/wallet-wdk 0.0.0-20250520201059

package/test/constants.ts

@@ -0,0 +1,62 @@
+import { config as dotenvConfig } from 'dotenv'
+import { Abi, Address } from 'ox'
+import { Manager, ManagerOptions, ManagerOptionsDefaults } from '../src/sequence'
+import { mockEthereum } from './setup'
+import { Signers as CoreSigners } from '@0xsequence/wallet-core'
+import * as Db from '../src/dbs'
+
+const envFile = process.env.CI ? '.env.test' : '.env.test.local'
+dotenvConfig({ path: envFile })
+
+export const EMITTER_ADDRESS: Address.Address = '0x7F6e420Ed3017A36bE6e1DA8e3AFE61569eb4840'
+export const EMITTER_ABI = Abi.from(['function explicitEmit()', 'function implicitEmit()'])
+
+// Environment variables
+export const { RPC_URL, PRIVATE_KEY } = process.env
+export const CAN_RUN_LIVE = !!RPC_URL && !!PRIVATE_KEY
+export const LOCAL_RPC_URL = process.env.LOCAL_RPC_URL || 'http://localhost:8545'
+
+let testIdCounter = 0
+
+export function newManager(options?: ManagerOptions, noEthereumMock?: boolean, tag?: string) {
+  if (!noEthereumMock) {
+    mockEthereum()
+  }
+
+  testIdCounter++
+  const dbSuffix = tag ? `_${tag}_testrun_${testIdCounter}` : `_testrun_${testIdCounter}`
+
+  // Ensure options and its identity sub-object exist for easier merging
+  const effectiveOptions = {
+    ...options,
+    identity: { ...ManagerOptionsDefaults.identity, ...options?.identity },
+  }
+
+  return new Manager({
+    networks: [
+      {
+        name: 'Arbitrum (local fork)',
+        rpc: LOCAL_RPC_URL,
+        chainId: 42161n,
+        explorer: 'https://arbiscan.io/',
+        nativeCurrency: {
+          name: 'Ether',
+          symbol: 'ETH',
+          decimals: 18,
+        },
+      },
+    ],
+    // Override DBs with unique names if not provided in options,
+    // otherwise, use the provided DB instance.
+    // This assumes options?.someDb is either undefined or a fully constructed DB instance.
+    encryptedPksDb: effectiveOptions.encryptedPksDb || new CoreSigners.Pk.Encrypted.EncryptedPksDb('pk-db' + dbSuffix),
+    managerDb: effectiveOptions.managerDb || new Db.Wallets('sequence-manager' + dbSuffix),
+    transactionsDb: effectiveOptions.transactionsDb || new Db.Transactions('sequence-transactions' + dbSuffix),
+    signaturesDb: effectiveOptions.signaturesDb || new Db.Signatures('sequence-signature-requests' + dbSuffix),
+    authCommitmentsDb:
+      effectiveOptions.authCommitmentsDb || new Db.AuthCommitments('sequence-auth-commitments' + dbSuffix),
+    authKeysDb: effectiveOptions.authKeysDb || new Db.AuthKeys('sequence-auth-keys' + dbSuffix),
+    recoveryDb: effectiveOptions.recoveryDb || new Db.Recovery('sequence-recovery' + dbSuffix),
+    ...effectiveOptions,
+  })
+}

package/test/recovery.test.ts

@@ -0,0 +1,211 @@
+import { describe, expect, it } from 'vitest'
+import { Manager, QueuedRecoveryPayload, SignerReady, TransactionDefined } from '../src/sequence'
+import { Bytes, Hex, Mnemonic, Provider, RpcTransport } from 'ox'
+import { Payload } from '@0xsequence/wallet-primitives'
+import { LOCAL_RPC_URL, newManager } from './constants'
+
+describe('Recovery', () => {
+  it('Should execute a recovery', async () => {
+    const manager = newManager({
+      defaultRecoverySettings: {
+        requiredDeltaTime: 2n, // 2 seconds
+        minTimestamp: 0n,
+      },
+    })
+
+    const mnemonic = Mnemonic.random(Mnemonic.english)
+    const wallet = await manager.signUp({ mnemonic, kind: 'mnemonic', noGuard: true })
+    expect(wallet).toBeDefined()
+
+    // Add recovery mnemonic
+    const mnemonic2 = Mnemonic.random(Mnemonic.english)
+    const requestId1 = await manager.addRecoveryMnemonic(wallet!, mnemonic2)
+
+    expect(requestId1).toBeDefined()
+
+    // Sign add recovery mnemonic
+    const request1 = await manager.getSignatureRequest(requestId1)
+    expect(request1).toBeDefined()
+
+    // Device must be the only ready signer now
+    const device = request1.signers.find((s) => s.status === 'ready')
+    expect(device).toBeDefined()
+
+    const result1 = await device?.handle()
+    expect(result1).toBeDefined()
+    expect(result1).toBeTruthy()
+
+    // Complete the add of the recovery mnemonic
+    await manager.completeRecoveryUpdate(requestId1)
+
+    // Get the recovery signers, there should be two one
+    // and one should not be the device address
+    const recoverySigners = await manager.getRecoverySigners(wallet!)
+    expect(recoverySigners).toBeDefined()
+    expect(recoverySigners!.length).toBe(2)
+    const nonDeviceSigner = recoverySigners!.find((s) => s.address !== device?.address)
+    expect(nonDeviceSigner).toBeDefined()
+
+    // Transfer 1 wei to the wallet
+    const provider = Provider.from(RpcTransport.fromHttp(LOCAL_RPC_URL))
+    await provider.request({
+      method: 'anvil_setBalance',
+      params: [wallet!, '0x1'],
+    })
+
+    // Create a new recovery payload
+    const requestId2 = await manager.queueRecoveryPayload(wallet!, 42161n, {
+      type: 'call',
+      space: Bytes.toBigInt(Bytes.random(20)),
+      nonce: 0n,
+      calls: [
+        {
+          to: Hex.from(Bytes.random(20)),
+          value: 1n,
+          data: '0x',
+          gasLimit: 1000000n,
+          delegateCall: false,
+          onlyFallback: false,
+          behaviorOnError: 'revert',
+        },
+      ],
+    })
+
+    // Needs to be signed using the recovery mnemonic
+    // for this we need to define a handler for it
+    let handledMnemonic2 = 0
+    const unregisterHandler = manager.registerMnemonicUI(async (respond) => {
+      handledMnemonic2++
+      await respond(mnemonic2)
+    })
+
+    // Sign the queue recovery payload
+    const request2 = await manager.getSignatureRequest(requestId2)
+    expect(request2).toBeDefined()
+
+    // Complete the queue recovery payload
+    // the only signer available should be the device and the recovery mnemonic
+    // the both recovery deviecs that we have
+    expect(request2.signers.length).toBe(2)
+    expect(request2.signers.some((s) => s.handler?.kind === 'local-device')).toBeTruthy()
+    expect(request2.signers.some((s) => s.handler?.kind === 'login-mnemonic')).toBeTruthy()
+
+    // Handle the login-mnemonic signer
+    const request2Signer = request2.signers.find((s) => s.handler?.kind === 'login-mnemonic')
+    expect(request2Signer).toBeDefined()
+    const result2 = await (request2Signer as SignerReady).handle()
+    expect(result2).toBeDefined()
+    expect(result2).toBeTruthy()
+    expect(handledMnemonic2).toBe(1)
+    unregisterHandler()
+
+    // Complete the recovery payload
+    const { to, data } = await manager.completeRecoveryPayload(requestId2)
+
+    // Send this transaction to anvil so we queue the payload
+    await provider.request({
+      method: 'eth_sendTransaction',
+      params: [
+        {
+          to,
+          data,
+        },
+      ],
+    })
+
+    // Wait 3 seconds for the payload to become valid
+    await new Promise((resolve) => setTimeout(resolve, 3000))
+    await manager.updateQueuedRecoveryPayloads()
+
+    // Get the recovery payloads
+    const recoveryPayloads = await new Promise<QueuedRecoveryPayload[]>((resolve) => {
+      const unsubscribe = manager.onQueuedRecoveryPayloadsUpdate(
+        wallet!,
+        (payloads) => {
+          unsubscribe()
+          resolve(payloads)
+        },
+        true,
+      )
+    })
+
+    expect(recoveryPayloads).toBeDefined()
+    expect(recoveryPayloads.length).toBe(1)
+    const recoveryPayload = recoveryPayloads![0]
+    expect(recoveryPayload).toBeDefined()
+    expect(Payload.isCalls(recoveryPayload!.payload!)).toBeTruthy()
+    expect((recoveryPayload!.payload as Payload.Calls).calls.length).toBe(1)
+
+    // Send this transaction as any other regular transaction
+    const requestId3 = await manager.requestTransaction(
+      wallet!,
+      42161n,
+      (recoveryPayload!.payload as Payload.Calls).calls,
+      {
+        noConfigUpdate: true,
+      },
+    )
+    expect(requestId3).toBeDefined()
+
+    // Define the same nonce and space for the recovery payload
+    await manager.defineTransaction(requestId3, {
+      nonce: (recoveryPayload!.payload as Payload.Calls).nonce,
+      space: (recoveryPayload!.payload as Payload.Calls).space,
+    })
+
+    // Complete the transaction
+    const tx = await manager.getTransaction(requestId3)
+    expect(tx).toBeDefined()
+    expect(tx.status).toBe('defined')
+    expect((tx as TransactionDefined).relayerOptions.length).toBe(1)
+
+    const localRelayer = (tx as TransactionDefined).relayerOptions[0]
+    expect(localRelayer).toBeDefined()
+    expect(localRelayer.relayerId).toBe('local')
+
+    // Define the relayer
+    const requestId4 = await manager.selectTransactionRelayer(requestId3, localRelayer.id)
+    expect(requestId4).toBeDefined()
+
+    // Now we sign using the recovery module
+    const request4 = await manager.getSignatureRequest(requestId4)
+
+    // Find the signer that is the recovery module handler
+    const recoverySigner = request4.signers.find((s) => s.handler?.kind === 'recovery-extension')
+    expect(recoverySigner).toBeDefined()
+    expect(recoverySigner!.status).toBe('ready')
+    1
+    // Handle the recovery signer
+    const result4 = await (recoverySigner as SignerReady).handle()
+    expect(result4).toBeDefined()
+    expect(result4).toBeTruthy()
+
+    // Complete the transaction
+    const txHash = await manager.relayTransaction(requestId4)
+    expect(txHash).toBeDefined()
+
+    // The balance of the wallet should be 0 wei
+    const balance = await provider.request({
+      method: 'eth_getBalance',
+      params: [wallet!, 'latest'],
+    })
+    expect(balance).toBeDefined()
+    expect(balance).toBe('0x0')
+
+    // Refresh the queued recovery payloads, the executed one
+    // should be removed
+    await manager.updateQueuedRecoveryPayloads()
+    const recoveryPayloads2 = await new Promise<QueuedRecoveryPayload[]>((resolve) => {
+      const unsubscribe = manager.onQueuedRecoveryPayloadsUpdate(
+        wallet!,
+        (payloads) => {
+          unsubscribe()
+          resolve(payloads)
+        },
+        true,
+      )
+    })
+    expect(recoveryPayloads2).toBeDefined()
+    expect(recoveryPayloads2.length).toBe(0)
+  }, 30000)
+})

package/test/sessions.test.ts

@@ -0,0 +1,324 @@
+import { AbiFunction, Address, Bytes, Hex, Mnemonic, Provider, RpcTransport } from 'ox'
+import { beforeEach, describe, it, vi } from 'vitest'
+import { Signers as CoreSigners, Wallet as CoreWallet, Envelope, Relayer, State } from '../../core/src/index.js'
+import { Attestation, Constants, Payload, Permission } from '../../primitives/src/index.js'
+import { Sequence } from '../src/index.js'
+import { CAN_RUN_LIVE, EMITTER_ABI, EMITTER_ADDRESS, PRIVATE_KEY, RPC_URL } from './constants'
+
+describe('Sessions (via Manager)', () => {
+  // Shared components
+  let provider: Provider.Provider
+  let chainId: bigint
+  let stateProvider: State.Provider
+
+  // Wallet webapp components
+  let wdk: {
+    identitySignerAddress: Address.Address
+    manager: Sequence.Manager
+  }
+
+  // Dapp components
+  let dapp: {
+    pkStore: CoreSigners.Pk.Encrypted.EncryptedPksDb
+    wallet: CoreWallet
+    sessionManager: CoreSigners.SessionManager
+  }
+
+  beforeEach(async () => {
+    // Create provider or use arbitrum sepolia
+    if (RPC_URL) {
+      provider = Provider.from(
+        RpcTransport.fromHttp(RPC_URL, {
+          fetchOptions: {
+            headers: {
+              'x-requested-with': 'XMLHttpRequest',
+            },
+          },
+        }),
+      )
+      chainId = BigInt(await provider.request({ method: 'eth_chainId' }))
+    } else {
+      provider = vi.mocked<Provider.Provider>({
+        request: vi.fn(),
+        on: vi.fn(),
+        removeListener: vi.fn(),
+      })
+      chainId = 1n
+    }
+
+    // Create state provider
+    stateProvider = new State.Local.Provider()
+
+    // Create manager
+    const opts = Sequence.applyManagerOptionsDefaults({
+      stateProvider,
+      relayers: [], // No relayers needed for testing
+      networks: [
+        {
+          chainId,
+          rpc: RPC_URL ?? 'XXX',
+          name: 'XXX',
+          explorer: 'XXX',
+          nativeCurrency: {
+            name: 'Ether',
+            symbol: 'ETH',
+            decimals: 18,
+          },
+        },
+      ],
+    })
+
+    // Create manager
+    const manager = new Sequence.Manager(opts)
+
+    // Use a mnemonic to create the wallet
+    const identitySignerMnemonic = Mnemonic.random(Mnemonic.english)
+    const identitySignerPk = Mnemonic.toPrivateKey(identitySignerMnemonic, { as: 'Hex' })
+    const identitySignerAddress = new CoreSigners.Pk.Pk(identitySignerPk).address
+    const walletAddress = await manager.signUp({
+      kind: 'mnemonic',
+      mnemonic: identitySignerMnemonic,
+      noGuard: true,
+      noSessionManager: false,
+    })
+    if (!walletAddress) {
+      throw new Error('Failed to create wallet')
+    }
+
+    // Initialize the wdk components
+    wdk = {
+      identitySignerAddress,
+      manager,
+    }
+    manager.registerMnemonicUI(async (respond) => {
+      await respond(identitySignerMnemonic)
+    })
+
+    // Create the pk store and pk
+    const pkStore = new CoreSigners.Pk.Encrypted.EncryptedPksDb()
+
+    // Create wallet in core
+    const coreWallet = new CoreWallet(walletAddress, {
+      context: opts.context,
+      guest: opts.guest,
+      // Share the state provider with wdk. In practice this will be the key machine.
+      stateProvider,
+    })
+
+    dapp = {
+      pkStore,
+      wallet: coreWallet,
+      sessionManager: new CoreSigners.SessionManager(coreWallet, {
+        provider,
+      }),
+    }
+  })
+
+  const signAndSend = async (call: Payload.Call) => {
+    const envelope = await dapp.wallet.prepareTransaction(provider, [call], { noConfigUpdate: true })
+    const parentedEnvelope: Payload.Parented = {
+      ...envelope.payload,
+      parentWallets: [dapp.wallet.address],
+    }
+
+    // Sign the envelope
+    const sessionImageHash = await dapp.sessionManager.imageHash
+    if (!sessionImageHash) {
+      throw new Error('Session image hash not found')
+    }
+    const signature = await dapp.sessionManager.signSapient(
+      dapp.wallet.address,
+      chainId ?? 1n,
+      parentedEnvelope,
+      sessionImageHash,
+    )
+    const sapientSignature: Envelope.SapientSignature = {
+      imageHash: sessionImageHash,
+      signature,
+    }
+    const signedEnvelope = Envelope.toSigned(envelope, [sapientSignature])
+
+    // Build the transaction
+    const transaction = await dapp.wallet.buildTransaction(provider, signedEnvelope)
+    console.log('tx', transaction)
+
+    // Send the transaction
+    if (CAN_RUN_LIVE && PRIVATE_KEY) {
+      // Load the sender
+      const senderPk = Hex.from(PRIVATE_KEY as `0x${string}`)
+      const pkRelayer = new Relayer.Pk.PkRelayer(senderPk, provider)
+      const tx = await pkRelayer.relay(transaction.to, transaction.data, chainId, undefined)
+      console.log('Transaction sent', tx)
+      await new Promise((resolve) => setTimeout(resolve, 3000))
+      const receipt = await provider.request({ method: 'eth_getTransactionReceipt', params: [tx.opHash] })
+      console.log('Transaction receipt', receipt)
+      return tx.opHash
+    }
+  }
+
+  it(
+    'should create and sign with an explicit session',
+    async () => {
+      // Create the explicit session signer
+      const e = await dapp.pkStore.generateAndStore()
+      const s = await dapp.pkStore.getEncryptedPkStore(e.address)
+      if (!s) {
+        throw new Error('Failed to create pk store')
+      }
+      const permission: Permission.SessionPermissions = {
+        signer: e.address,
+        valueLimit: 0n,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 3600), // 1 hour from now
+        permissions: [
+          {
+            target: EMITTER_ADDRESS,
+            rules: [
+              {
+                // Require the explicitEmit selector
+                cumulative: false,
+                operation: Permission.ParameterOperation.EQUAL,
+                value: Bytes.padRight(Bytes.fromHex(AbiFunction.getSelector(EMITTER_ABI[0])), 32),
+                offset: 0n,
+                mask: Bytes.padRight(Bytes.fromHex('0xffffffff'), 32),
+              },
+            ],
+          },
+        ],
+      }
+      const explicitSigner = new CoreSigners.Session.Explicit(s, permission)
+      // Add to manager
+      dapp.sessionManager = dapp.sessionManager.withExplicitSigner(explicitSigner)
+
+      // Request the session permissions from the WDK
+      const requestId = await wdk.manager.addExplicitSession(dapp.wallet.address, explicitSigner.address, permission)
+
+      // Sign and complete the request
+      const sigRequest = await wdk.manager.getSignatureRequest(requestId)
+      const identitySigner = sigRequest.signers.find((s) => s.address === wdk.identitySignerAddress)
+      if (!identitySigner || (identitySigner.status !== 'actionable' && identitySigner.status !== 'ready')) {
+        throw new Error(`Identity signer not found or not ready/actionable: ${identitySigner?.status}`)
+      }
+      const handled = await identitySigner.handle()
+      if (!handled) {
+        throw new Error('Failed to handle identity signer')
+      }
+      await wdk.manager.completeSessionUpdate(requestId)
+
+      // Create a call payload
+      const call: Payload.Call = {
+        to: EMITTER_ADDRESS,
+        value: 0n,
+        data: AbiFunction.encodeData(EMITTER_ABI[0]),
+        gasLimit: 0n,
+        delegateCall: false,
+        onlyFallback: false,
+        behaviorOnError: 'revert',
+      }
+
+      if (!RPC_URL) {
+        // Configure mock provider
+        ;(provider as any).request.mockImplementation(({ method, params }) => {
+          if (method === 'eth_chainId') {
+            return Promise.resolve(chainId.toString())
+          }
+          if (method === 'eth_call' && params[0].data === AbiFunction.encodeData(Constants.GET_IMPLEMENTATION)) {
+            // Undeployed wallet
+            return Promise.resolve('0x')
+          }
+          if (method === 'eth_call' && params[0].data === AbiFunction.encodeData(Constants.READ_NONCE, [0n])) {
+            // Nonce is 0
+            return Promise.resolve('0x00')
+          }
+        })
+      }
+
+      // Sign and send the transaction
+      await signAndSend(call)
+    },
+    PRIVATE_KEY || RPC_URL ? { timeout: 60000 } : undefined,
+  )
+
+  it(
+    'should create and sign with an implicit session',
+    async () => {
+      // Create the implicit session signer
+      const e = await dapp.pkStore.generateAndStore()
+      const s = await dapp.pkStore.getEncryptedPkStore(e.address)
+      if (!s) {
+        throw new Error('Failed to create pk store')
+      }
+
+      // Request the session authorization from the WDK
+      const requestId = await wdk.manager.prepareAuthorizeImplicitSession(dapp.wallet.address, e.address, {
+        target: 'https://example.com',
+      })
+
+      // Sign the request (Wallet UI action)
+      const sigRequest = await wdk.manager.getSignatureRequest(requestId)
+      const identitySigner = sigRequest.signers[0]
+      if (!identitySigner || (identitySigner.status !== 'actionable' && identitySigner.status !== 'ready')) {
+        throw new Error(`Identity signer not found or not ready/actionable: ${identitySigner?.status}`)
+      }
+      const handled = await identitySigner.handle()
+      if (!handled) {
+        throw new Error('Failed to handle identity signer')
+      }
+
+      // Complete the request
+      const { attestation, signature: identitySignature } =
+        await wdk.manager.completeAuthorizeImplicitSession(requestId)
+
+      // Load the implicit signer
+      const implicitSigner = new CoreSigners.Session.Implicit(
+        s,
+        attestation,
+        identitySignature,
+        dapp.sessionManager.address,
+      )
+      dapp.sessionManager = dapp.sessionManager.withImplicitSigner(implicitSigner)
+
+      // Create a call payload
+      const call: Payload.Call = {
+        to: EMITTER_ADDRESS,
+        value: 0n,
+        data: AbiFunction.encodeData(EMITTER_ABI[1]), // implicitEmit
+        gasLimit: 0n,
+        delegateCall: false,
+        onlyFallback: false,
+        behaviorOnError: 'revert',
+      }
+
+      if (!RPC_URL) {
+        // Configure mock provider
+        ;(provider as any).request.mockImplementation(({ method, params }) => {
+          if (method === 'eth_chainId') {
+            return Promise.resolve(chainId.toString())
+          }
+          if (method === 'eth_call' && params[0].data === AbiFunction.encodeData(Constants.GET_IMPLEMENTATION)) {
+            // Undeployed wallet
+            return Promise.resolve('0x')
+          }
+          if (method === 'eth_call' && params[0].data === AbiFunction.encodeData(Constants.READ_NONCE, [0n])) {
+            // Nonce is 0
+            return Promise.resolve('0x00')
+          }
+          if (
+            method === 'eth_call' &&
+            Address.isEqual(params[0].from, dapp.sessionManager.address) &&
+            Address.isEqual(params[0].to, call.to)
+          ) {
+            // Implicit request simulation result
+            const expectedResult = Bytes.toHex(
+              Attestation.generateImplicitRequestMagic(attestation, dapp.wallet.address),
+            )
+            return Promise.resolve(expectedResult)
+          }
+        })
+      }
+
+      // Sign and send the transaction
+      await signAndSend(call)
+    },
+    PRIVATE_KEY || RPC_URL ? { timeout: 60000 } : undefined,
+  )
+})

package/test/setup.ts

@@ -0,0 +1,63 @@
+import { indexedDB, IDBFactory } from 'fake-indexeddb'
+import { Address, Bytes, Hex, Provider, RpcTransport } from 'ox'
+import { vi } from 'vitest'
+import { LOCAL_RPC_URL } from './constants'
+
+// Add IndexedDB support to the test environment
+global.indexedDB = indexedDB
+global.IDBFactory = IDBFactory
+
+// Mock navigator.locks API for Node.js environment ---
+
+// 1. Ensure the global navigator object exists
+if (typeof global.navigator === 'undefined') {
+  console.log('mocking navigator')
+  global.navigator = {} as Navigator
+}
+
+// 2. Define or redefine the 'locks' property on navigator
+//    Check if 'locks' is falsy (null or undefined), OR if it's an object
+//    that doesn't have the 'request' property we expect in our mock.
+if (!global.navigator.locks || !('request' in global.navigator.locks)) {
+  Object.defineProperty(global.navigator, 'locks', {
+    // The value of the 'locks' property will be our mock object
+    value: {
+      // Mock the 'request' method
+      request: vi
+        .fn()
+        .mockImplementation(async (name: string, callback: (lock: { name: string } | null) => Promise<any>) => {
+          // Simulate acquiring the lock immediately in the test environment.
+          const mockLock = { name } // A minimal mock lock object
+          try {
+            // Execute the callback provided to navigator.locks.request
+            const result = await callback(mockLock)
+            return result // Return the result of the callback
+          } catch (e) {
+            // Log errors from the callback for better debugging in tests
+            console.error(`Error occurred within mocked lock callback for lock "${name}":`, e)
+            throw e // Re-throw the error so the test potentially fails
+          }
+        }),
+      // Mock the 'query' method
+      query: vi.fn().mockResolvedValue({ held: [], pending: [] }),
+    },
+    writable: true,
+    configurable: true,
+    enumerable: true,
+  })
+} else {
+  console.log('navigator.locks already exists and appears to have a "request" property.')
+}
+
+export function mockEthereum() {
+  // Add window.ethereum support, pointing to the the Anvil local RPC
+  if (typeof (window as any).ethereum === 'undefined') {
+    ;(window as any).ethereum = {
+      request: vi.fn().mockImplementation(async (args: any) => {
+        // Pipe the request to the Anvil local RPC
+        const provider = Provider.from(RpcTransport.fromHttp(LOCAL_RPC_URL))
+        return provider.request(args)
+      }),
+    }
+  }
+}