tapimo 0.0.2 → 0.1.0

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

@@ -0,0 +1,146 @@
+import { MultisigConfig, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
+import { fillTransaction, getTransactionReceipt, sendRawTransactionSync } from 'viem/actions'
+import { Account } from 'viem/tempo'
+
+import * as Relay from '../../../test/Relay.js'
+import * as Store from '../../internal/Store.js'
+
+const owner_1 = Relay.accounts[1]!
+const owner_2 = Relay.accounts[2]!
+const feePayer = Relay.accounts[0]!
+
+// Skipped: the localnet node images currently available (including the same
+// `ghcr.io/tempoxyz/tempo:latest` the accounts suite uses) reject the multisig
+// signed-transaction envelope with "failed to decode signed transaction". This
+// test fails identically in the accounts repo today; it only passes against a
+// node build that supports the multisig envelope. Re-enable once such an image
+// is pinned here.
+describe.skip('relay multisig', () => {
+  const store = Store.memory()
+  let client: ReturnType<typeof Relay.getClient>
+  let server: Relay.Server
+
+  beforeAll(async () => {
+    server = await Relay.createServer(
+      (
+        await Relay.relay({
+          feePayer: { account: feePayer },
+          multisig: { store },
+        })
+      ).listener,
+    )
+    client = Relay.getClient({ url: server.url })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  test('behavior: collects approvals and resolves operation-id receipt aliases on localnet', async () => {
+    const account = Account.fromMultisig({
+      threshold: 2,
+      owners: [
+        { owner: owner_1.address, weight: 1 },
+        { owner: owner_2.address, weight: 1 },
+      ],
+    })
+    const { transaction } = await fillTransaction(client, {
+      account,
+      to: account.address,
+      value: 0n,
+    } as never)
+    const { account: _account, gas, ...filled } = transaction as Record<string, unknown>
+    const request: Record<string, unknown> = {
+      ...filled,
+      feePayerSignature: null,
+      gas: typeof gas === 'bigint' ? gas + 100_000n : gas,
+    }
+    const {
+      _capabilities,
+      account: _account_request,
+      data,
+      from: _from,
+      multisig: _multisig,
+      signature: _signature,
+      signatures: _signatures,
+      to,
+      value,
+      ...transaction_request
+    } = request
+    const calls = (() => {
+      if ('calls' in transaction_request) return transaction_request['calls']
+      if (typeof to !== 'string') return undefined
+      return [
+        {
+          ...(typeof data === 'string' ? { data } : {}),
+          to,
+          value: typeof value === 'bigint' ? value : 0n,
+        },
+      ]
+    })()
+    const envelope = TxEnvelopeTempo.from({ ...transaction_request, calls } as never)
+    const payload = TxEnvelopeTempo.getSignPayload(envelope)
+    const genesisConfigId = MultisigConfig.toId(account.config)
+    const id = MultisigConfig.getSignPayload({
+      account: account.address,
+      genesisConfigId,
+      payload,
+    })
+    const signature_1 = await signApproval({ digest: id, signer: owner_1 })
+    const signature_2 = await signApproval({ digest: id, signer: owner_2 })
+
+    const pending = await client.request({
+      method: 'eth_sendRawTransactionSync',
+      params: [serializeTransaction({ account, envelope, signatures: [signature_1] })],
+    } as never)
+
+    expect(pending).toMatchInlineSnapshot(`"${id}"`)
+    await expect(
+      client.request({ method: 'eth_getTransactionReceipt', params: [id] }),
+    ).resolves.toMatchInlineSnapshot(`null`)
+
+    const receipt = await sendRawTransactionSync(client, {
+      serializedTransaction: serializeTransaction({ account, envelope, signatures: [signature_2] }),
+    })
+    const hash = receipt.transactionHash
+    if (!hash) throw new Error('Expected multisig transaction hash.')
+
+    expect(hash === id).toMatchInlineSnapshot(`false`)
+    expect(receipt).toMatchObject({
+      status: 'success',
+    })
+    await expect(getTransactionReceipt(client, { hash: id })).resolves.toMatchObject({
+      transactionHash: hash,
+    })
+  })
+})
+
+async function signApproval(options: { digest: `0x${string}`; signer: typeof owner_1 }) {
+  const { digest, signer } = options
+  return SignatureEnvelope.serialize(SignatureEnvelope.from(await signer.sign({ hash: digest })))
+}
+
+function serializeTransaction(options: {
+  account: ReturnType<typeof Account.fromMultisig>
+  envelope: ReturnType<typeof TxEnvelopeTempo.from>
+  signatures: readonly `0x${string}`[]
+}) {
+  const { account, envelope } = options
+  const payload = TxEnvelopeTempo.getSignPayload(envelope)
+  const genesisConfigId = MultisigConfig.toId(account.config)
+  const signatures = SignatureEnvelope.sortMultisigApprovals({
+    account: account.address,
+    genesisConfigId,
+    payload,
+    signatures: options.signatures.map((signature) => SignatureEnvelope.from(signature)),
+  })
+  return TxEnvelopeTempo.serialize(envelope, {
+    feePayerSignature: undefined,
+    signature: SignatureEnvelope.from({
+      account: account.address,
+      genesisConfigId,
+      init: account.config,
+      signatures,
+    }),
+  })
+}