tapimo 0.0.2 → 0.2.0

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

@@ -0,0 +1,818 @@
+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,
+    }),
+  })
+}