tapimo 0.15.0 → 0.18.0

package/src/db/tables/verifiedTokenRequests.ts

@@ -11,44 +11,61 @@ export type Record = Selectable<Table>
 /** Review status of a request. */
 export type Status = Record['status']
 
+/** Maximum pending verification requests retained for one requester. */
+export const maxPendingPerRequester = 10
+
 /**
  * Inserts a pending request; `undefined` when a pending request for
- * (chainId, address) already exists.
+ * (chainId, address) already exists. Throws `PendingLimitError` when the
+ * requester already has the maximum retained pending requests.
  */
 export function create(db: Db.Db, input: create.Input): Promise<Record | undefined> {
   const now = new Date().toISOString()
-  return db.kysely
-    .insertInto('verified_token_requests')
-    .values({
-      address: input.address,
-      chainId: input.chainId,
-      createdAt: now,
-      currency: input.currency,
-      decimals: input.decimals,
-      id: Id.generate('vtr'),
-      logo: input.logo ?? null,
-      logoUri: input.logoUri ?? null,
-      name: input.name,
-      note: input.note ?? null,
-      orgId: input.orgId,
-      requestedBy: input.requestedBy,
-      reviewNote: null,
-      reviewedAt: null,
-      reviewedBy: null,
-      status: 'pending',
-      symbol: input.symbol,
-      updatedAt: now,
-    })
-    .onConflict((oc) =>
-      oc
-        .columns(['chainId', 'address'])
-        // `sql.lit` keeps the predicate literal; a bound parameter would
-        // defeat partial-index inference for the conflict target.
-        .where('status', '=', sql.lit('pending'))
-        .doNothing(),
+  return db.transaction(async (tx) => {
+    // Serialize admission per requester so parallel organizations cannot exceed the retained queue cap.
+    await sql`SELECT pg_advisory_xact_lock(hashtextextended(${`verified-token-requests:${input.requestedBy}`}, 0))`.execute(
+      tx.kysely,
     )
-    .returningAll()
-    .executeTakeFirst()
+    const pending = await tx.kysely
+      .selectFrom('verified_token_requests')
+      .select(({ fn }) => fn.countAll<string>().as('count'))
+      .where('requestedBy', '=', input.requestedBy)
+      .where('status', '=', 'pending')
+      .executeTakeFirstOrThrow()
+    if (Number(pending.count) >= maxPendingPerRequester) throw new PendingLimitError()
+    return tx.kysely
+      .insertInto('verified_token_requests')
+      .values({
+        address: input.address,
+        chainId: input.chainId,
+        createdAt: now,
+        currency: input.currency,
+        decimals: input.decimals,
+        id: Id.generate('vtr'),
+        logo: input.logo ?? null,
+        logoUri: input.logoUri ?? null,
+        name: input.name,
+        note: input.note ?? null,
+        orgId: input.orgId,
+        requestedBy: input.requestedBy,
+        reviewNote: null,
+        reviewedAt: null,
+        reviewedBy: null,
+        status: 'pending',
+        symbol: input.symbol,
+        updatedAt: now,
+      })
+      .onConflict((oc) =>
+        oc
+          .columns(['chainId', 'address'])
+          // `sql.lit` keeps the predicate literal; a bound parameter would
+          // defeat partial-index inference for the conflict target.
+          .where('status', '=', sql.lit('pending'))
+          .doNothing(),
+      )
+      .returningAll()
+      .executeTakeFirst()
+  })
 }
 
 export declare namespace create {
@@ -96,17 +113,42 @@ export function list(db: Db.Db, orgId: string): Promise<Record[]> {
 export function listByStatus(
   db: Db.Db,
   status: Status,
+  options: listByStatus.Options,
 ): Promise<(Record & { orgName: string | null })[]> {
-  return db.kysely
+  const { cursor } = options
+  let query = db.kysely
     .selectFrom('verified_token_requests')
     .leftJoin('organizations', 'organizations.id', 'verified_token_requests.orgId')
     .selectAll('verified_token_requests')
     .select('organizations.name as orgName')
     .where('status', '=', status)
+  if (cursor)
+    query = query.where((eb) =>
+      eb.or([
+        eb('verified_token_requests.createdAt', '>', cursor.createdAt),
+        eb.and([
+          eb('verified_token_requests.createdAt', '=', cursor.createdAt),
+          eb('verified_token_requests.id', '>', cursor.id),
+        ]),
+      ]),
+    )
+  return query
     .orderBy('verified_token_requests.createdAt', 'asc')
+    .orderBy('verified_token_requests.id', 'asc')
+    .limit(options.limit)
     .execute()
 }
 
+export declare namespace listByStatus {
+  /** Pagination options for the global review queue. */
+  type Options = {
+    /** Oldest-first position after which to continue. */
+    cursor?: { createdAt: string; id: string } | undefined
+    /** Maximum records to return. */
+    limit: number
+  }
+}
+
 /** Gets a request by id. */
 export function get(db: Db.Db, id: string): Promise<Record | undefined> {
   return db.kysely
@@ -116,17 +158,6 @@ export function get(db: Db.Db, id: string): Promise<Record | undefined> {
     .executeTakeFirst()
 }
 
-/** Counts an organization's pending requests. */
-export async function countPending(db: Db.Db, orgId: string): Promise<number> {
-  const row = await db.kysely
-    .selectFrom('verified_token_requests')
-    .select(({ fn }) => fn.countAll<string>().as('count'))
-    .where('orgId', '=', orgId)
-    .where('status', '=', 'pending')
-    .executeTakeFirstOrThrow()
-  return Number(row.count)
-}
-
 /** Hard-deletes an org-scoped request while pending; `undefined` otherwise. */
 export function remove(db: Db.Db, orgId: string, id: string): Promise<Record | undefined> {
   return db.kysely
@@ -180,3 +211,8 @@ export function toRequest(record: Record) {
     ...(logoUri === null ? {} : { logoUri }),
   }
 }
+
+/** The requester already has the maximum retained pending requests. */
+export class PendingLimitError extends Error {
+  override readonly name = 'VerifiedTokenRequests.PendingLimitError'
+}

package/src/handlers/internal/multisig.store.test.ts

@@ -0,0 +1,120 @@
+import { Hex } from 'ox'
+import { createClient, http } from 'viem'
+import { tempoLocalnet } from 'viem/tempo/chains'
+
+import * as Handler from '../../Handler.js'
+import * as Log from '../../internal/Log.js'
+import * as StateStore from '../../internal/Store.js'
+import * as Multisig from './multisig.js'
+
+describe('fromStore', () => {
+  test('requires atomic state', () => {
+    const { swap: _, ...state } = StateStore.memory()
+    expect(() => Multisig.fromStore(state)).toThrowErrorMatchingInlineSnapshot(
+      `[Error: Multisig coordination requires an atomic state store.]`,
+    )
+  })
+
+  test('preserves concurrent compare-and-set', async () => {
+    const state = StateStore.memory()
+    const a = Multisig.fromStore(state)
+    const results = await Promise.all([
+      a.compareAndSet('operation', null, 'a'),
+      a.compareAndSet('operation', null, 'b'),
+    ])
+    expect({ results }).toMatchInlineSnapshot(`
+      {
+        "results": [
+          true,
+          false,
+        ],
+      }
+    `)
+  })
+
+  test('honors absolute expiration', async () => {
+    vi.useFakeTimers()
+    try {
+      const store = Multisig.fromStore(StateStore.memory())
+      await store.compareAndSet('lease', null, 'a', { expiresAt: Date.now() + 100 })
+      await vi.advanceTimersByTimeAsync(101)
+      expect(await store.getItem('lease')).toBeNull()
+      expect(await store.compareAndSet('lease', null, 'b')).toBe(true)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+describe('relay', () => {
+  const client = createClient({ chain: tempoLocalnet, transport: http() })
+
+  test('serves unknown operations without forwarding them to the node', async () => {
+    const handler = Handler.relay({
+      getClient: () => client,
+      multisig: { store: StateStore.memory() },
+    })
+    const response = await handler.fetch(
+      new Request('http://relay/', {
+        method: 'POST',
+        body: JSON.stringify({
+          id: 42,
+          jsonrpc: '2.0',
+          method: 'multisig_getOperation',
+          params: [Hex.random(32)],
+        }),
+      }),
+    )
+    expect(await response.json()).toMatchInlineSnapshot(`
+      {
+        "id": 42,
+        "jsonrpc": "2.0",
+        "result": null,
+      }
+    `)
+  })
+
+  test('rejects invalid parameters across the five methods', async () => {
+    const handler = Handler.relay({
+      getClient: () => client,
+      multisig: { store: StateStore.memory() },
+    })
+    for (const method of [
+      'multisig_approveRawTransaction',
+      'multisig_approveRawTransactionSync',
+      'multisig_approveKeyAuthorization',
+      'multisig_getConfig',
+      'multisig_getOperation',
+    ]) {
+      const response = await handler.fetch(
+        new Request('http://relay/', {
+          method: 'POST',
+          body: JSON.stringify({ id: 1, jsonrpc: '2.0', method, params: [] }),
+        }),
+      )
+      expect(await response.json()).toMatchObject({ error: { code: -32602 } })
+    }
+  })
+
+  test('reports corrupt coordinator state through RPC server-error observability', async () => {
+    const state = StateStore.memory()
+    const hash = Hex.random(32)
+    // Operation lookup keys are part of the persisted Viem coordinator format.
+    await state.put(`multisig:v2:multisig:operation:${hash}`, 'invalid')
+    const handler = Handler.relay({ getClient: () => client, multisig: { store: state } })
+    const response = await handler.fetch(
+      new Request('http://relay/', {
+        method: 'POST',
+        body: JSON.stringify({
+          id: 1,
+          jsonrpc: '2.0',
+          method: 'multisig_getOperation',
+          params: [hash],
+        }),
+      }),
+    )
+    const body: unknown = await response.json()
+    expect(body).toMatchObject({ error: { code: -32603 } })
+    expect(Log.rpcErrors(body)).toMatchObject({ serverErrors: 1 })
+  })
+})

package/src/handlers/internal/multisig.test.ts

@@ -0,0 +1,389 @@
+import { Hex } from 'ox'
+import {
+  KeyAuthorization,
+  MultisigConfig,
+  MultisigOperation,
+  SignatureEnvelope,
+  TxEnvelopeTempo,
+} from 'ox/tempo'
+import { createClient, custom, defineChain, http } from 'viem'
+import { getTransactionReceipt, sendTransactionSync } from 'viem/actions'
+import { Account, Actions, withRelay } from 'viem/tempo'
+import { tempoLocalnet } from 'viem/tempo/chains'
+import { inject } from 'vite-plus/test'
+
+import * as Accounts from '../../../test/Accounts.js'
+import * as Handler from '../../Handler.js'
+import * as Log from '../../internal/Log.js'
+import * as StateStore from '../../internal/Store.js'
+
+const owners = Accounts.create(inject('tempoTestMnemonic'))
+const chain = defineChain({ ...tempoLocalnet, id: 1337 })
+const client = createClient({ chain, transport: http(inject('tempoMultisigRpcUrl')) })
+const feeToken = '0x20c0000000000000000000000000000000000000'
+
+beforeAll(async () => {
+  await Actions.faucet.fundSync(client, { account: owners[0] })
+})
+
+describe('relay', () => {
+  test('serves all five TIP-1101 methods and keeps submitted hashes distinct', async () => {
+    const relay = fixture()
+    const account = multisig()
+    const config = {
+      ...MultisigConfig.toRpc(account.config!),
+      owners: account.config!.owners.map(({ owner, weight }) => ({
+        owner: owner.toLowerCase(),
+        weight,
+      })),
+    }
+    expect(await relay.rpc('multisig_getConfig', [{ address: account.address }])).toBeNull()
+    expect(await relay.rpc('multisig_getOperation', [Hex.random(32)])).toBeNull()
+    const first = await approval(account, [owners[1]])
+    const hash = (await relay.rpc('multisig_approveRawTransaction', [first])) as Hex.Hex
+    const pending = await relay.operation(hash)
+    expect(pending).toMatchObject({
+      hash,
+      status: 'pending',
+      type: 'transaction',
+      signatureCount: 1,
+      weight: 1,
+      threshold: 2,
+    })
+    expect(pending.config.version).toBe('0x0')
+    expect(await relay.rpc('multisig_getConfig', [{ address: account.address }])).toEqual(config)
+    expect(await relay.rpc('eth_getTransactionReceipt', [hash])).toBeNull()
+    const second = await approval(account, [owners[2]])
+    const complete = (await relay.rpc('multisig_approveRawTransactionSync', [
+      second,
+      1000,
+    ])) as MultisigOperation.TransactionRpc
+    expect(complete).toMatchObject({ hash, status: 'success', signatureCount: 2, weight: 2 })
+    expect(complete.transactionHash).not.toBe(hash)
+    const receipt = await getTransactionReceipt(client, { hash: complete.transactionHash! })
+    expect(receipt).toMatchObject({
+      from: account.address.toLowerCase(),
+      status: 'success',
+      feePayer: owners[0].address.toLowerCase(),
+    })
+    expect(await relay.rpc('multisig_approveRawTransaction', [first])).toBe(hash)
+    expect(await relay.operation(hash)).toEqual(complete)
+    expect(await relay.rpc('eth_getTransactionReceipt', [hash])).toMatchObject({
+      transactionHash: complete.transactionHash,
+      multisig: { hash },
+    })
+    expect(await relay.rpc('multisig_getConfig', [{ address: account.address }])).toEqual(config)
+
+    const key = KeyAuthorization.from({
+      account: account.address,
+      address: owners[3].address,
+      chainId: BigInt(chain.id),
+      type: 'secp256k1',
+    })
+    const keyHash = MultisigConfig.getSignPayload({
+      account: account.address,
+      config: account.config!,
+      payload: KeyAuthorization.getSignPayload(key),
+    })
+    const signed = KeyAuthorization.from(key, {
+      signature: SignatureEnvelope.from<SignatureEnvelope.Multisig>({
+        account: account.address,
+        config: account.config!,
+        signatures: [
+          SignatureEnvelope.from(
+            await owners[1].sign({ hash: keyHash }),
+          ) as SignatureEnvelope.Primitive,
+        ],
+      }),
+    })
+    const keyPending = (await relay.rpc('multisig_approveKeyAuthorization', [
+      { keyAuthorization: KeyAuthorization.toRpc(signed) },
+    ])) as MultisigOperation.KeyAuthorizationRpc
+    expect(keyPending).toMatchObject({ hash: keyHash, status: 'pending', type: 'keyAuthorization' })
+    const nonce = await client.request({
+      method: 'eth_getTransactionCount',
+      params: [account.address, 'latest'],
+    })
+    const keySuccess = (await relay.rpc('multisig_approveKeyAuthorization', [
+      { hash: keyHash, signature: await owners[2].sign({ hash: keyHash }) },
+    ])) as MultisigOperation.KeyAuthorizationRpc
+    expect(keySuccess).toMatchObject({ hash: keyHash, status: 'success', signatureCount: 2 })
+    expect(KeyAuthorization.deserialize(keySuccess.keyAuthorization).signature?.type).toBe(
+      'multisig',
+    )
+    expect(await relay.operation(keyHash)).toEqual(keySuccess)
+    expect(
+      await client.request({
+        method: 'eth_getTransactionCount',
+        params: [account.address, 'latest'],
+      }),
+    ).toBe(nonce)
+  })
+
+  test('coordinates latest Viem transaction actions through the relay', async () => {
+    const relay = fixture()
+    const wallet = createClient({
+      chain,
+      transport: withRelay(
+        http(inject('tempoMultisigRpcUrl')),
+        custom({ request: ({ method, params }) => relay.rpc(method, params ?? []) }),
+      ),
+    })
+    const account = multisig()
+    const pending = await sendTransactionSync(wallet, {
+      account,
+      calls: [{ to: account.address, value: 0n }],
+      feePayer: true,
+      owner: owners[1],
+    })
+    expect(pending).toMatchObject({ status: 'pending' })
+    const receipt = await sendTransactionSync(wallet, {
+      account,
+      hash: pending.transactionHash,
+      owner: owners[2],
+    })
+    expect(receipt).toMatchObject({ status: 'success', from: account.address.toLowerCase() })
+  })
+
+  test('merges concurrent approvals across relay instances and deduplicates retries', async () => {
+    const store = StateStore.memory()
+    const a = fixture({ store })
+    const b = fixture({ store })
+    const account = multisig(3)
+    const first = await approval(account, [owners[1]])
+    const second = await approval(account, [owners[2]])
+    const hashes = await Promise.all([
+      a.rpc('multisig_approveRawTransaction', [first]),
+      b.rpc('multisig_approveRawTransaction', [second]),
+      a.rpc('multisig_approveRawTransaction', [first]),
+    ])
+    expect(new Set(hashes).size).toBe(1)
+    expect(await a.operation(hashes[0] as Hex.Hex)).toMatchObject({
+      status: 'pending',
+      signatureCount: 2,
+      weight: 2,
+    })
+  })
+
+  test.each(['multisig_approveRawTransaction', 'eth_sendRawTransaction'])(
+    'selects a weighted quorum and submits asynchronously via %s',
+    async (method) => {
+      const relay = fixture()
+      const account = Account.fromMultisig({
+        owners: [
+          { owner: owners[1].address, weight: 2 },
+          { owner: owners[2].address, weight: 1 },
+          { owner: owners[3].address, weight: 1 },
+        ],
+        salt: Hex.random(32),
+        threshold: 3,
+      })
+      const hash = (await relay.rpc(method, [
+        await approval(account, [owners[2], owners[3]]),
+      ])) as Hex.Hex
+      expect(await relay.operation(hash)).toMatchObject({ status: 'pending', weight: 2 })
+      expect(await relay.rpc(method, [await approval(account, [owners[1]])])).toBe(hash)
+      const operation = await relay.operation(hash)
+      expect(operation).toMatchObject({ status: 'success', signatureCount: 2, weight: 3 })
+      expect(operation.approvals).toHaveLength(3)
+    },
+  )
+
+  test('rejects positive-version configs for an unregistered account', async () => {
+    const relay = fixture()
+    const initial = multisig()
+    const account = Account.fromMultisig({
+      ...initial.config!,
+      address: initial.address,
+      version: 1n,
+    })
+    await expect(
+      relay.rpc('multisig_approveRawTransaction', [await approval(account, [owners[1]])]),
+    ).rejects.toMatchObject({ code: -32602 })
+    expect((await relay.store.list()).keys).toEqual([])
+  })
+
+  test('validates cached configurations before returning them', async () => {
+    const relay = fixture()
+    const account = multisig()
+    await relay.rpc('multisig_approveRawTransaction', [await approval(account, [owners[1]])])
+    const { keys } = await relay.store.list()
+    const key = keys.find(
+      ({ name }) => name.includes(':config:') && name.endsWith(`0x${'00'.repeat(32)}`),
+    )!
+    await relay.store.put(key.name, '{}')
+    await expect(
+      relay.rpc('multisig_getConfig', [{ address: account.address }]),
+    ).rejects.toMatchObject({ code: -32603 })
+  })
+
+  test('retains approvals after sponsorship rejection and retries successfully', async () => {
+    const store = StateStore.memory()
+    const rejected = fixture({ store, validate: async () => false })
+    const accepted = fixture({ store })
+    const account = multisig()
+    const first = await approval(account, [owners[1]])
+    const second = await approval(account, [owners[2]])
+    const hash = (await rejected.rpc('multisig_approveRawTransaction', [first])) as Hex.Hex
+    await expect(
+      rejected.rpc('multisig_approveRawTransactionSync', [second]),
+    ).rejects.toMatchObject({ code: -32602, message: 'Sponsorship rejected.' })
+    expect(await accepted.operation(hash)).toMatchObject({ status: 'pending', signatureCount: 2 })
+    expect(await accepted.rpc('multisig_approveRawTransactionSync', [second])).toMatchObject({
+      status: 'success',
+    })
+  })
+
+  test('rejects malformed requests and non-owner approvals', async () => {
+    const relay = fixture()
+    for (const [method, params] of [
+      ['multisig_approveRawTransaction', ['0x76']],
+      ['multisig_approveRawTransactionSync', ['0x']],
+      ['multisig_approveKeyAuthorization', [{ hash: Hex.random(32), signature: '0x' }]],
+      ['multisig_getConfig', [{ address: 'invalid' }]],
+      ['multisig_getOperation', ['0x']],
+    ] as const)
+      await expect(relay.rpc(method, params)).rejects.toMatchObject({ code: -32602 })
+    await expect(
+      relay.rpc('multisig_approveRawTransaction', [await approval(multisig(), [owners[4]])]),
+    ).rejects.toMatchObject({ code: -32602 })
+  })
+
+  test.each(['eth_sendRawTransaction', 'eth_sendRawTransactionSync'])(
+    'retains partial approvals without broadcasting via %s',
+    async (method) => {
+      const relay = fixture()
+      const account = multisig()
+      const partial = await approval(account, [owners[1]])
+      const result = (await relay.rpc(method, [partial])) as
+        | Hex.Hex
+        | { status: string; transactionHash: Hex.Hex }
+      const hash = typeof result === 'string' ? result : result.transactionHash
+      if (typeof result !== 'string') expect(result.status).toBe('pending')
+      const operation = await relay.operation(hash)
+      expect(operation).toMatchObject({
+        signatureCount: 1,
+        status: 'pending',
+        threshold: 2,
+        weight: 1,
+      })
+      expect(operation).not.toHaveProperty('transactionHash')
+      expect(
+        await client.request({
+          method: 'eth_getTransactionCount',
+          params: [account.address, 'latest'],
+        }),
+      ).toBe('0x0')
+    },
+  )
+
+  test('rejects chain mismatches before collecting approvals', async () => {
+    const relay = fixture()
+    await expect(
+      relay.rpc('multisig_approveRawTransaction', [await approval(multisig(), [owners[1]])], 1),
+    ).rejects.toMatchObject({ code: -32602, message: 'Conflicting chain ids.' })
+    expect((await relay.store.list()).keys).toEqual([])
+  })
+
+  test('reports corrupt stored state as an observable server error', async () => {
+    const relay = fixture()
+    const hash = (await relay.rpc('multisig_approveRawTransaction', [
+      await approval(multisig(), [owners[1]]),
+    ])) as Hex.Hex
+    const { keys } = await relay.store.list()
+    const key = keys.find(({ name }) => name.endsWith(hash.toLowerCase()))!
+    await relay.store.put(key.name, 'invalid')
+    const response = await relay.response('multisig_getOperation', [hash])
+    expect(response).toMatchObject({ error: { code: -32603 } })
+    expect(Log.rpcErrors(response)).toMatchObject({ serverErrors: 1 })
+  })
+})
+
+function multisig(threshold = 2) {
+  return Account.fromMultisig({
+    owners: [owners[1].address, owners[2].address, owners[3].address],
+    salt: Hex.random(32),
+    threshold,
+  })
+}
+
+async function approval(account: Account.MultisigAccount, signers: readonly Accounts.Account[]) {
+  const transaction = TxEnvelopeTempo.from({
+    calls: [{ to: account.address, value: 0n }],
+    chainId: chain.id,
+    feePayerSignature: null,
+    feeToken,
+    gas: 1_000_000n,
+    maxFeePerGas: 100_000_000_000n,
+    maxPriorityFeePerGas: 0n,
+    nonce: 0n,
+  })
+  const hash = MultisigConfig.getSignPayload({
+    account: account.address,
+    config: account.config!,
+    payload: TxEnvelopeTempo.getSignPayload(transaction),
+  })
+  const signatures = await Promise.all(
+    [...signers]
+      .sort((a, b) => a.address.toLowerCase().localeCompare(b.address.toLowerCase()))
+      .map(async (owner) => {
+        const signature = SignatureEnvelope.from(await owner.sign({ hash }))
+        if (signature.type === 'multisig' || signature.type === 'keychain')
+          throw new Error('Expected a primitive owner.')
+        return signature
+      }),
+  )
+  const signature = SignatureEnvelope.from({
+    account: account.address,
+    config: account.config!,
+    signatures,
+  })
+  return TxEnvelopeTempo.serialize(transaction, { signature })
+}
+
+function fixture(options: fixture.Options = {}) {
+  const store = options.store ?? StateStore.memory()
+  const handler = Handler.relay({
+    feePayer: {
+      account: owners[0],
+      feeToken,
+      ...(options.validate ? { validate: options.validate } : {}),
+    },
+    getClient: () => client,
+    multisig: { store },
+  })
+  async function response(method: string, params: readonly unknown[], chainId: number = chain.id) {
+    return (await (
+      await handler.fetch(
+        new Request(`http://relay/${chainId}`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ id: 1, jsonrpc: '2.0', method, params }),
+        }),
+      )
+    ).json()) as Promise<fixture.Response>
+  }
+  async function rpc(method: string, params: readonly unknown[], chainId: number = chain.id) {
+    const body = await response(method, params, chainId)
+    if (body.error) throw body.error
+    return body.result
+  }
+  return {
+    operation: (hash: Hex.Hex) =>
+      rpc('multisig_getOperation', [hash]) as Promise<MultisigOperation.Rpc>,
+    response,
+    rpc,
+    store,
+  }
+}
+
+declare namespace fixture {
+  type Options = {
+    store?: StateStore.State | undefined
+    validate?: NonNullable<Handler.relay.Options['feePayer']>['validate']
+  }
+  type Response = {
+    error?: { code: number; message: string } | undefined
+    result?: unknown
+  }
+}