tapimo 0.13.0 → 0.15.0

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

@@ -1,818 +0,0 @@
-import { Address, Hex, P256 } from 'ox'
-import { MultisigConfig, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
-import { createClient, custom } from 'viem'
-import { prepareTransactionRequest, sendTransactionSync, signTransaction } from 'viem/actions'
-import { Account, Transaction } from 'viem/tempo'
-import { tempoDevnet } from 'viem/tempo/chains'
-
-import * as Relay from '../../../test/Relay.js'
-import * as Runtime from '../../../test/runtime.js'
-import * as StateStore from '../../internal/Store.js'
-import * as Multisig from './multisig.js'
-
-const privateKey_1 = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'
-const privateKey_2 = '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d'
-const privateKey_3 = '0x7c852118294f7e395961158d39c448445a22a434adcd1d4e9048bcd3d85e9e4d'
-const feeToken = '0x20c0000000000000000000000000000000000000' as const
-
-describe('memoryStore', () => {
-  test('behavior: submission claims are exclusive until TTL expiry', async () => {
-    const store = Multisig.memoryStore()
-    const operation = createOperation()
-
-    await store.savePending(operation)
-    const first = await store.claimSubmission(operation, { ttl: 1_000 })
-    const second = await store.claimSubmission(operation, { ttl: 1_000 })
-
-    expect({ first: first.status, second: second.status }).toMatchInlineSnapshot(`
-      {
-        "first": "claimed",
-        "second": "submitting",
-      }
-    `)
-  })
-
-  test('behavior: expired submission claims can be reclaimed', async () => {
-    const store = Multisig.memoryStore()
-    const operation = createOperation()
-
-    await store.savePending(operation)
-    await store.claimSubmission(operation, { ttl: -1 })
-    const reclaimed = await store.claimSubmission(operation, { ttl: 1_000 })
-
-    expect(reclaimed.status).toMatchInlineSnapshot(`"claimed"`)
-  })
-
-  test('behavior: pending saves merge signatures and submitted operations are not listed as pending', async () => {
-    const store = Multisig.memoryStore()
-    const operation = createOperation()
-
-    await store.savePending({ ...operation, signatures: [`0x${'11'.repeat(65)}`] })
-    const merged = await store.savePending({ ...operation, signatures: [`0x${'22'.repeat(65)}`] })
-    await store.claimSubmission(merged, { ttl: 1_000 })
-    await store.setSubmitted(operation.id, `0x${'33'.repeat(32)}`)
-
-    expect({
-      listed: await store.listPendingByAddress(operation.account),
-      signatures: merged.signatures.length,
-      status: (await store.get(operation.id))?.status,
-    }).toMatchInlineSnapshot(`
-      {
-        "listed": [],
-        "signatures": 2,
-        "status": "submitted",
-      }
-    `)
-  })
-})
-
-describe('handleRawTransaction', () => {
-  test('behavior: rejects first approvals when no config can be resolved', async () => {
-    const owner = Account.fromSecp256k1(privateKey_1)
-    const account = Account.fromMultisig({
-      threshold: 1,
-      owners: [{ owner: owner.address, weight: 1 }],
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 0n,
-    }
-    const signature = await owner.signTransaction(transaction as never)
-    const serialized = withoutInit(
-      await account.signTransaction({ ...transaction, signatures: [signature] } as never),
-    )
-
-    await expect(
-      Multisig.handleRawTransaction({
-        getClient: (() => undefined) as never,
-        method: 'eth_sendRawTransaction',
-        request: { params: [serialized] },
-        store: Multisig.memoryStore(),
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[RpcResponse.InvalidParamsError: Multisig config is required to collect approvals. Provide it in the bootstrap transaction or configure \`multisig.resolveConfig\`.]`,
-    )
-  })
-
-  test('behavior: finalize submitted preserves async broadcast method', async () => {
-    const owner = Account.fromSecp256k1(privateKey_1)
-    const account = Account.fromMultisig({
-      threshold: 1,
-      owners: [{ owner: owner.address, weight: 1 }],
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 0n,
-    }
-    const signature = await owner.signTransaction(transaction as never)
-    const serialized = await account.signTransaction({
-      ...transaction,
-      signatures: [signature],
-    } as never)
-    let broadcastMethod: string | undefined
-
-    const hash = await Multisig.handleRawTransaction({
-      finalize: 'submitted',
-      getClient: (() => ({
-        request: async ({ method, params }: { method: string; params: unknown }) => {
-          broadcastMethod = method
-          return hashRawTransaction(params)
-        },
-      })) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [serialized] },
-      store: Multisig.memoryStore(),
-    })
-
-    expect({ broadcastMethod, hash }).toMatchInlineSnapshot(`
-      {
-        "broadcastMethod": "eth_sendRawTransaction",
-        "hash": "${hash}",
-      }
-    `)
-  })
-})
-
-describe('config resolution', () => {
-  test('behavior: reuses pending bootstrap config when a later approval omits init', async () => {
-    const store = Multisig.memoryStore()
-    const owner_1 = Account.fromSecp256k1(privateKey_1)
-    const owner_2 = Account.fromSecp256k1(privateKey_2)
-    const account = Account.fromMultisig({
-      threshold: 2,
-      owners: [
-        { owner: owner_1.address, weight: 1 },
-        { owner: owner_2.address, weight: 1 },
-      ],
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 0n,
-    }
-    const signature_1 = await owner_1.signTransaction(transaction as never)
-    const signature_2 = await owner_2.signTransaction(transaction as never)
-    const first = await account.signTransaction({
-      ...transaction,
-      signatures: [signature_1],
-    } as never)
-    const second = withoutInit(
-      await account.signTransaction({ ...transaction, signatures: [signature_2] } as never),
-    )
-
-    await Multisig.handleRawTransaction({
-      getClient: (() => undefined) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [first] },
-      store,
-    })
-    const hash = await Multisig.handleRawTransaction({
-      getClient: (() => ({
-        request: async ({ params }: { params: unknown }) => hashRawTransaction(params),
-      })) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [second] },
-      store,
-    })
-
-    expect(hash).toMatchInlineSnapshot(`"${hash}"`)
-  })
-
-  test('behavior: preserves bootstrap init when it arrives after a resolver-backed pending approval', async () => {
-    const store = Multisig.memoryStore()
-    const owner_1 = Account.fromSecp256k1(privateKey_1)
-    const owner_2 = Account.fromSecp256k1(privateKey_2)
-    const account = Account.fromMultisig({
-      threshold: 2,
-      owners: [
-        { owner: owner_1.address, weight: 1 },
-        { owner: owner_2.address, weight: 1 },
-      ],
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 0n,
-    }
-    const signature_1 = await owner_1.signTransaction(transaction as never)
-    const signature_2 = await owner_2.signTransaction(transaction as never)
-    const first = withoutInit(
-      await account.signTransaction({ ...transaction, signatures: [signature_1] } as never),
-    )
-    const second = await account.signTransaction({
-      ...transaction,
-      signatures: [signature_2],
-    } as never)
-    let submitted: `0x${string}` | undefined
-
-    await Multisig.handleRawTransaction({
-      getClient: (() => undefined) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [first] },
-      resolveConfig: () => account.config,
-      store,
-    })
-    const hash = await Multisig.handleRawTransaction({
-      getClient: (() => ({
-        request: async ({ params }: { params: unknown }) => {
-          submitted = Array.isArray(params) ? (params[0] as `0x${string}`) : undefined
-          return hashRawTransaction(params)
-        },
-      })) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [second] },
-      resolveConfig: () => account.config,
-      store,
-    })
-
-    const transaction_submitted = Transaction.deserialize(submitted! as never) as {
-      signature: SignatureEnvelope.Multisig
-    }
-    expect({
-      hash,
-      init: transaction_submitted.signature.init
-        ? MultisigConfig.getAddress(transaction_submitted.signature.init)
-        : undefined,
-    }).toMatchInlineSnapshot(`
-      {
-        "hash": "${hash}",
-        "init": "${account.address.toLowerCase()}",
-      }
-    `)
-  })
-
-  test('behavior: attaches resolver-provided bootstrap config when approvals omit init', async () => {
-    const store = Multisig.memoryStore()
-    const owner_1 = Account.fromSecp256k1(privateKey_1)
-    const owner_2 = Account.fromSecp256k1(privateKey_2)
-    const account = Account.fromMultisig({
-      threshold: 2,
-      owners: [
-        { owner: owner_1.address, weight: 1 },
-        { owner: owner_2.address, weight: 1 },
-      ],
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 0n,
-    }
-    const signature_1 = await owner_1.signTransaction(transaction as never)
-    const signature_2 = await owner_2.signTransaction(transaction as never)
-    const first = withoutInit(
-      await account.signTransaction({ ...transaction, signatures: [signature_1] } as never),
-    )
-    const second = withoutInit(
-      await account.signTransaction({ ...transaction, signatures: [signature_2] } as never),
-    )
-    let submitted: `0x${string}` | undefined
-
-    await Multisig.handleRawTransaction({
-      getClient: (() => undefined) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [first] },
-      resolveConfig: () => account.config,
-      store,
-    })
-    const hash = await Multisig.handleRawTransaction({
-      getClient: (() => ({
-        request: async ({ params }: { params: unknown }) => {
-          submitted = Array.isArray(params) ? (params[0] as `0x${string}`) : undefined
-          return hashRawTransaction(params)
-        },
-      })) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [second] },
-      resolveConfig: () => account.config,
-      store,
-    })
-
-    const transaction_submitted = Transaction.deserialize(submitted! as never) as {
-      signature: SignatureEnvelope.Multisig
-    }
-    expect({
-      hash,
-      init: transaction_submitted.signature.init
-        ? MultisigConfig.getAddress(transaction_submitted.signature.init)
-        : undefined,
-    }).toMatchInlineSnapshot(`
-      {
-        "hash": "${hash}",
-        "init": "${account.address.toLowerCase()}",
-      }
-    `)
-  })
-
-  test('behavior: preserves bootstrap init when claimed operation omits stored init config', async () => {
-    const base = Multisig.memoryStore()
-    const store: Multisig.Store = {
-      claimSubmission: async (operation, options) => {
-        const result = await base.claimSubmission(operation, options)
-        if (result.status !== 'claimed') return result
-        return {
-          operation: { ...result.operation, initConfig: undefined },
-          status: result.status,
-        }
-      },
-      get: base.get,
-      listPendingByAddress: base.listPendingByAddress,
-      savePending: base.savePending,
-      setSubmitted: base.setSubmitted,
-    }
-    const owner = Account.fromSecp256k1(privateKey_1)
-    const account = Account.fromMultisig({
-      threshold: 1,
-      owners: [{ owner: owner.address, weight: 1 }],
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 0n,
-    }
-    const signature = await owner.signTransaction(transaction as never)
-    const serialized = await account.signTransaction({
-      ...transaction,
-      signatures: [signature],
-    } as never)
-    let submitted: `0x${string}` | undefined
-
-    const hash = await Multisig.handleRawTransaction({
-      getClient: (() => ({
-        request: async ({ params }: { params: unknown }) => {
-          submitted = Array.isArray(params) ? (params[0] as `0x${string}`) : undefined
-          return hashRawTransaction(params)
-        },
-      })) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [serialized] },
-      store,
-    })
-
-    const transaction_submitted = Transaction.deserialize(submitted! as never) as {
-      signature: SignatureEnvelope.Multisig
-    }
-    expect({
-      hash,
-      init: transaction_submitted.signature.init
-        ? MultisigConfig.getAddress(transaction_submitted.signature.init)
-        : undefined,
-    }).toMatchInlineSnapshot(`
-      {
-        "hash": "${hash}",
-        "init": "${account.address.toLowerCase()}",
-      }
-    `)
-  })
-
-  test('behavior: rejects resolved configs that do not match the multisig account', async () => {
-    const owner_1 = Account.fromSecp256k1(privateKey_1)
-    const owner_2 = Account.fromSecp256k1(privateKey_2)
-    const account = Account.fromMultisig({
-      threshold: 1,
-      owners: [{ owner: owner_1.address, weight: 1 }],
-    })
-    const wrong = Account.fromMultisig({
-      threshold: 1,
-      owners: [{ owner: owner_2.address, weight: 1 }],
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 0n,
-    }
-    const signature = await owner_1.signTransaction(transaction as never)
-    const serialized = await account.signTransaction({
-      ...transaction,
-      signatures: [signature],
-    } as never)
-
-    await expect(
-      Multisig.handleRawTransaction({
-        getClient: (() => undefined) as never,
-        method: 'eth_sendRawTransaction',
-        request: { params: [serialized] },
-        resolveConfig: () => wrong.config,
-        store: Multisig.memoryStore(),
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[RpcResponse.InvalidParamsError: Signature from non-owner 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266.]`,
-    )
-  })
-
-  test('behavior: accepts current configs for updated multisig signer sets', async () => {
-    const owner_1 = Account.fromSecp256k1(privateKey_1)
-    const owner_2 = Account.fromSecp256k1(privateKey_2)
-    const account = Account.fromMultisig({
-      threshold: 1,
-      owners: [{ owner: owner_1.address, weight: 1 }],
-    })
-    const current = MultisigConfig.from({
-      owners: [
-        { owner: owner_1.address, weight: 1 },
-        { owner: owner_2.address, weight: 1 },
-      ],
-      threshold: 1,
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 1n,
-    }
-    const signature = await owner_2.signTransaction(transaction as never)
-    const serialized = withoutInit(
-      await account.signTransaction({
-        ...transaction,
-        signatures: [signature],
-      } as never),
-    )
-    let submitted: `0x${string}` | undefined
-
-    const hash = await Multisig.handleRawTransaction({
-      getClient: (() => ({
-        request: async ({ params }: { params: unknown }) => {
-          submitted = Array.isArray(params) ? (params[0] as `0x${string}`) : undefined
-          return hashRawTransaction(params)
-        },
-      })) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [serialized] },
-      resolveConfig: () => current,
-      store: Multisig.memoryStore(),
-    })
-
-    const transaction_submitted = Transaction.deserialize(submitted! as never) as {
-      signature: SignatureEnvelope.Multisig
-    }
-    expect({
-      account: transaction_submitted.signature.account,
-      hash,
-      init: transaction_submitted.signature.init,
-    }).toMatchInlineSnapshot(`
-      {
-        "account": "${account.address.toLowerCase()}",
-        "hash": "${hash}",
-        "init": undefined,
-      }
-    `)
-  })
-})
-
-describe('approval validation', () => {
-  test('behavior: rejects P256 approvals whose embedded owner key did not sign the operation', async () => {
-    const privateKey = P256.randomPrivateKey()
-    const publicKey = P256.getPublicKey({ privateKey })
-    const owner = Address.fromPublicKey(publicKey)
-    const account = Account.fromMultisig({
-      threshold: 1,
-      owners: [{ owner, weight: 1 }],
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 0n,
-    }
-    const signature = SignatureEnvelope.serialize(
-      SignatureEnvelope.from({
-        publicKey,
-        signature: P256.sign({ payload: `0x${'44'.repeat(32)}`, privateKey }),
-        type: 'p256',
-      }),
-    )
-    const serialized = await account.signTransaction({
-      ...transaction,
-      signatures: [signature],
-    } as never)
-
-    await expect(
-      Multisig.handleRawTransaction({
-        getClient: (() => ({
-          request: async ({ params }: { params: unknown }) => hashRawTransaction(params),
-        })) as never,
-        method: 'eth_sendRawTransaction',
-        request: { params: [serialized] },
-        store: Multisig.memoryStore(),
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[RpcResponse.InvalidParamsError: Invalid signature from owner ${owner}.]`,
-    )
-  })
-})
-
-describe('handleRawTransaction with sponsor', () => {
-  test('behavior: broadcasts finalized multisig transactions with feePayerSignature and default feeToken', async () => {
-    const store = Multisig.memoryStore()
-    const owner_1 = Account.fromSecp256k1(privateKey_1)
-    const owner_2 = Account.fromSecp256k1(privateKey_2)
-    const feePayer = Account.fromSecp256k1(privateKey_3)
-    const account = Account.fromMultisig({
-      threshold: 2,
-      owners: [
-        { owner: owner_1.address, weight: 1 },
-        { owner: owner_2.address, weight: 1 },
-      ],
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      feePayerSignature: null,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 0n,
-    }
-    const signature_1 = await owner_1.signTransaction(transaction as never)
-    const signature_2 = await owner_2.signTransaction(transaction as never)
-    const first = await account.signTransaction({
-      ...transaction,
-      signatures: [signature_1],
-    } as never)
-    const second = await account.signTransaction({
-      ...transaction,
-      signatures: [signature_2],
-    } as never)
-    const broadcasted: string[] = []
-    const sponsored: unknown[] = []
-
-    await Multisig.handleRawTransaction({
-      getClient: (() => undefined) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [first] },
-      sponsor: {
-        account: feePayer as never,
-        resolveFeeToken: () => feeToken,
-      },
-      store,
-    })
-    const hash = await Multisig.handleRawTransaction({
-      getClient: () =>
-        createClient({
-          chain: tempoDevnet,
-          transport: custom({
-            request: async ({ method, params }) => {
-              if (method === 'eth_chainId') return Hex.fromNumber(tempoDevnet.id)
-              broadcasted.push((params as readonly string[])[0]!)
-              return hashRawTransaction(params)
-            },
-          }),
-        }),
-      method: 'eth_sendRawTransaction',
-      request: { params: [second] },
-      sponsor: {
-        account: feePayer as never,
-        onSponsored: (event) => {
-          sponsored.push(event)
-          expect(broadcasted).toHaveLength(0)
-        },
-        resolveFeeToken: () => feeToken,
-      },
-      store,
-    })
-
-    const transaction_broadcasted = Transaction.deserialize(broadcasted[0] as never) as Record<
-      string,
-      unknown
-    >
-    const signature = transaction_broadcasted['signature'] as { init?: unknown; type?: string }
-    expect({
-      feePayerSignature: Boolean(transaction_broadcasted['feePayerSignature']),
-      feeToken: (transaction_broadcasted['feeToken'] as string).toLowerCase(),
-      hash,
-      init: Boolean(signature.init),
-      sponsored: sponsored.length,
-      signature: signature.type,
-    }).toMatchInlineSnapshot(`
-      {
-        "feePayerSignature": true,
-        "feeToken": "0x20c0000000000000000000000000000000000000",
-        "hash": "${hash}",
-        "init": true,
-        "signature": "multisig",
-        "sponsored": 1,
-      }
-    `)
-  })
-
-  test('behavior: broadcasts already sponsored multisig transactions without replacing fee payer', async () => {
-    const owner = Account.fromSecp256k1(privateKey_1)
-    const feePayer_original = Account.fromSecp256k1(privateKey_2)
-    const feePayer_relay = Account.fromSecp256k1(privateKey_3)
-    const account = Account.fromMultisig({
-      threshold: 1,
-      owners: [{ owner: owner.address, weight: 1 }],
-    })
-    const transaction = {
-      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe', value: 1n }],
-      chainId: tempoDevnet.id,
-      feePayerSignature: null,
-      gas: 21_000n,
-      maxFeePerGas: 1n,
-      maxPriorityFeePerGas: 0n,
-      multisig: account.config,
-      nonce: 0n,
-    }
-    const signature = await owner.signTransaction(transaction as never)
-    const serialized = await account.signTransaction({
-      ...transaction,
-      signatures: [signature],
-    } as never)
-    const sponsored: `0x${string}`[] = []
-
-    await Multisig.handleRawTransaction({
-      getClient: () =>
-        createClient({
-          chain: tempoDevnet,
-          transport: custom({
-            request: async ({ method, params }) => {
-              if (method === 'eth_chainId') return Hex.fromNumber(tempoDevnet.id)
-              sponsored.push((params as readonly `0x${string}`[])[0]!)
-              return hashRawTransaction(params)
-            },
-          }),
-        }),
-      method: 'eth_sendRawTransaction',
-      request: { params: [serialized] },
-      sponsor: {
-        account: feePayer_original as never,
-        resolveFeeToken: () => feeToken,
-      },
-      store: Multisig.memoryStore(),
-    })
-    const presponsored = sponsored[0]
-    if (!presponsored) throw new Error('Expected pre-sponsored transaction.')
-
-    let broadcasted: `0x${string}` | undefined
-    const hash = await Multisig.handleRawTransaction({
-      getClient: (() => ({
-        request: async ({ params }: { params: unknown }) => {
-          broadcasted = Array.isArray(params) ? (params[0] as `0x${string}`) : undefined
-          return hashRawTransaction(params)
-        },
-      })) as never,
-      method: 'eth_sendRawTransaction',
-      request: { params: [presponsored] },
-      sponsor: {
-        account: feePayer_relay as never,
-        feeToken,
-        validate: () => false,
-      },
-      store: Multisig.memoryStore(),
-    })
-
-    const transaction_broadcasted = Transaction.deserialize(broadcasted! as never) as Record<
-      string,
-      unknown
-    >
-    expect({
-      feePayerSignature: Boolean(transaction_broadcasted['feePayerSignature']),
-      feeToken: (transaction_broadcasted['feeToken'] as string).toLowerCase(),
-      hash,
-      signature: (transaction_broadcasted['signature'] as { type?: string }).type,
-    }).toMatchInlineSnapshot(`
-      {
-        "feePayerSignature": true,
-        "feeToken": "0x20c0000000000000000000000000000000000000",
-        "hash": "${hash}",
-        "signature": "multisig",
-      }
-    `)
-  })
-})
-
-describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG === 'sha-8968664')(
-  'e2e',
-  () => {
-    const owner_1 = Relay.accounts[1]!
-    const owner_2 = Relay.accounts[2]!
-    const feePayer = Relay.accounts[0]!
-    const sponsorFeeToken = Relay.addresses.pathUsd
-    const store = StateStore.memory()
-    let client: ReturnType<typeof Relay.getClient>
-    let server: Relay.Server
-
-    beforeAll(async () => {
-      server = await Relay.createServer(
-        (
-          await Relay.relay({
-            feePayer: {
-              account: feePayer,
-              feeToken: sponsorFeeToken,
-            },
-            multisig: { store },
-          })
-        ).listener,
-      )
-      client = Relay.getClient({ url: server.url })
-    })
-
-    afterAll(() => {
-      server.close()
-    })
-
-    test('behavior: sponsors bootstrap multisig', async () => {
-      const account = Account.fromMultisig({
-        threshold: 2,
-        owners: [
-          { owner: owner_1.address, weight: 1 },
-          { owner: owner_2.address, weight: 1 },
-        ],
-      })
-      const transaction = await prepareTransactionRequest(client, {
-        account,
-        feePayer: true,
-        to: account.address,
-        value: 0n,
-      })
-      const signatures = await Promise.all(
-        [owner_1, owner_2].map((owner) =>
-          signTransaction(client, { ...transaction, account: owner }),
-        ),
-      )
-      const receipt = await sendTransactionSync(client, {
-        ...transaction,
-        account,
-        signatures,
-      })
-
-      expect(receipt).toMatchObject({
-        feePayer: feePayer.address.toLowerCase(),
-        feeToken: sponsorFeeToken.toLowerCase(),
-        from: account.address.toLowerCase(),
-        status: 'success',
-      })
-    })
-  },
-)
-
-function createOperation(): Multisig.Operation {
-  const now = Date.now()
-  return {
-    account: '0x0000000000000000000000000000000000000001',
-    chainId: tempoDevnet.id,
-    createdAt: now,
-    id: `0x${'22'.repeat(32)}`,
-    payload: `0x${'33'.repeat(32)}`,
-    signatures: [],
-    status: 'pending',
-    transaction: `0x76${'44'.repeat(32)}`,
-    updatedAt: now,
-  }
-}
-
-function hashRawTransaction(params: unknown) {
-  const serialized = Array.isArray(params) ? params[0] : undefined
-  if (typeof serialized !== 'string') throw new Error('Expected raw transaction.')
-  return TxEnvelopeTempo.hash(
-    TxEnvelopeTempo.deserialize(serialized as TxEnvelopeTempo.Serialized) as TxEnvelopeTempo.Signed,
-  )
-}
-
-function withoutInit(serialized: `0x${string}`) {
-  const transaction = Transaction.deserialize(serialized as never) as Record<string, unknown>
-  const signature = transaction['signature'] as SignatureEnvelope.Multisig
-  const { signature: _, ...unsigned } = transaction
-  return TxEnvelopeTempo.serialize(TxEnvelopeTempo.from(unsigned as never), {
-    signature: SignatureEnvelope.from({
-      account: signature.account,
-      signatures: signature.signatures,
-    }),
-  })
-}