tapimo 0.15.1 → 0.18.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
+  }
+}

package/src/handlers/internal/multisig.ts

@@ -1,4 +1,4 @@
-import type { Store } from 'viem/tempo'
+import { Store } from 'viem/tempo'
 
 import type * as core_Store from '../../internal/Store.js'
 
@@ -7,14 +7,17 @@ export function fromStore(store: core_Store.State): Store.Atomic {
   const swap = store.swap?.bind(store)
   if (!swap) throw new Error('Multisig coordination requires an atomic state store.')
 
-  return {
-    compareAndSet(key, expected, value, options) {
-      const ttl =
-        options?.expiresAt === undefined ? undefined : Math.max(0, options.expiresAt - Date.now())
-      return swap(key, expected, value, ttl === undefined ? undefined : { ttl })
+  return Store.from(
+    {
+      compareAndSet(key, expected, value, options) {
+        const ttl =
+          options?.expiresAt === undefined ? undefined : Math.max(0, options.expiresAt - Date.now())
+        return swap(key, expected, value, ttl === undefined ? undefined : { ttl })
+      },
+      getItem: (key) => store.get(key),
+      removeItem: (key) => store.delete(key),
+      setItem: (key, value) => store.put(key, value),
     },
-    getItem: (key) => store.get(key),
-    removeItem: (key) => store.delete(key),
-    setItem: (key, value) => store.put(key, value),
-  }
+    { key: 'multisig:v2' },
+  )
 }