tapimo 0.1.0 → 0.3.0

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

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