mppx 0.6.31 → 0.8.0

package/src/tempo/session/precompile/Voucher.test.ts

@@ -0,0 +1,354 @@
+import { P256, Secp256k1 } from 'ox'
+import { SignatureEnvelope } from 'ox/tempo'
+import { createClient, hashTypedData, http } from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
+import { signTypedData } from 'viem/actions'
+import { Account as TempoAccount } from 'viem/tempo'
+import { describe, expect, test } from 'vp/test'
+
+import { tip20ChannelEscrow } from './Protocol.js'
+import { uint96 } from './Protocol.js'
+import {
+  getVoucherDomain,
+  parseVoucherFromPayload,
+  signVoucher,
+  voucherTypes,
+  verifyVoucher,
+} from './Voucher.js'
+
+const account = privateKeyToAccount(
+  '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+)
+const escrowContract = tip20ChannelEscrow
+const chainId = 42431
+
+const client = createClient({
+  account,
+  transport: http('http://127.0.0.1'), // only used for local signTypedData
+})
+
+const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as const
+const cumulativeAmount = uint96(1_000_000n)
+
+describe('Precompile Voucher', () => {
+  test('sign and verify round-trip', async () => {
+    const signature = await signVoucher(
+      client,
+      account,
+      { channelId, cumulativeAmount },
+      escrowContract,
+      chainId,
+    )
+    expect(signature).toMatch(/^0x/)
+    expect(signature.length).toBe(132)
+
+    const isValid = verifyVoucher(
+      escrowContract,
+      chainId,
+      { channelId, cumulativeAmount, signature },
+      account.address,
+    )
+    expect(isValid).toBe(true)
+  })
+
+  test('verify rejects wrong signer', async () => {
+    const signature = await signVoucher(
+      client,
+      account,
+      { channelId, cumulativeAmount },
+      escrowContract,
+      chainId,
+    )
+
+    const wrongAddress = '0x0000000000000000000000000000000000000001' as const
+    const isValid = verifyVoucher(
+      escrowContract,
+      chainId,
+      { channelId, cumulativeAmount, signature },
+      wrongAddress,
+    )
+    expect(isValid).toBe(false)
+  })
+
+  test('verify rejects tampered amount', async () => {
+    const signature = await signVoucher(
+      client,
+      account,
+      { channelId, cumulativeAmount },
+      escrowContract,
+      chainId,
+    )
+
+    const isValid = verifyVoucher(
+      escrowContract,
+      chainId,
+      { channelId, cumulativeAmount: uint96(9_999_999n), signature },
+      account.address,
+    )
+    expect(isValid).toBe(false)
+  })
+
+  test('verify rejects tampered channelId', async () => {
+    const signature = await signVoucher(
+      client,
+      account,
+      { channelId, cumulativeAmount },
+      escrowContract,
+      chainId,
+    )
+
+    const wrongChannelId =
+      '0x0000000000000000000000000000000000000000000000000000000000000099' as const
+    const isValid = verifyVoucher(
+      escrowContract,
+      chainId,
+      { channelId: wrongChannelId, cumulativeAmount, signature },
+      account.address,
+    )
+    expect(isValid).toBe(false)
+  })
+
+  test('verify rejects wrong chain ID', async () => {
+    const signature = await signVoucher(
+      client,
+      account,
+      { channelId, cumulativeAmount },
+      escrowContract,
+      chainId,
+    )
+
+    const isValid = verifyVoucher(
+      escrowContract,
+      99999,
+      { channelId, cumulativeAmount, signature },
+      account.address,
+    )
+    expect(isValid).toBe(false)
+  })
+
+  test('signs and verifies custom escrow domain with EIP-712', async () => {
+    const customEscrow = '0x0000000000000000000000000000000000000005' as const
+    const signature = await signVoucher(
+      client,
+      account,
+      { channelId, cumulativeAmount },
+      customEscrow,
+      chainId,
+    )
+
+    expect(
+      verifyVoucher(
+        customEscrow,
+        chainId,
+        { channelId, cumulativeAmount, signature },
+        account.address,
+      ),
+    ).toBe(true)
+  })
+
+  test('verify returns false for invalid signature', () => {
+    const isValid = verifyVoucher(
+      escrowContract,
+      chainId,
+      { channelId, cumulativeAmount, signature: '0xdeadbeef' },
+      account.address,
+    )
+    expect(isValid).toBe(false)
+  })
+
+  test('parseVoucherFromPayload', () => {
+    const signature =
+      '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890ab' as const
+    const voucher = parseVoucherFromPayload(channelId, '5000000', signature)
+    expect(voucher.channelId).toBe(channelId)
+    expect(voucher.cumulativeAmount).toBe(5_000_000n)
+    expect(voucher.signature).toBe(signature)
+  })
+
+  test('parseVoucherFromPayload with zero amount', () => {
+    const signature =
+      '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890ab' as const
+    const voucher = parseVoucherFromPayload(channelId, '0', signature)
+    expect(voucher.cumulativeAmount).toBe(0n)
+  })
+
+  test('parseVoucherFromPayload rejects amounts outside uint96 bounds', () => {
+    const signature = '0xdeadbeef' as const
+    expect(() => parseVoucherFromPayload(channelId, '-1', signature)).toThrow(
+      'outside uint96 bounds',
+    )
+    expect(() => parseVoucherFromPayload(channelId, (1n << 96n).toString(), signature)).toThrow(
+      'outside uint96 bounds',
+    )
+  })
+
+  test('verify rejects wrong escrow contract', async () => {
+    const signature = await signVoucher(
+      client,
+      account,
+      { channelId, cumulativeAmount },
+      escrowContract,
+      chainId,
+    )
+
+    const wrongEscrow = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd' as const
+    const isValid = verifyVoucher(
+      wrongEscrow,
+      chainId,
+      { channelId, cumulativeAmount, signature },
+      account.address,
+    )
+    expect(isValid).toBe(false)
+  })
+
+  test('sign and verify round-trip with zero amount', async () => {
+    const zeroAmount = uint96(0n)
+    const signature = await signVoucher(
+      client,
+      account,
+      { channelId, cumulativeAmount: zeroAmount },
+      escrowContract,
+      chainId,
+    )
+    expect(signature).toMatch(/^0x/)
+
+    const isValid = verifyVoucher(
+      escrowContract,
+      chainId,
+      { channelId, cumulativeAmount: zeroAmount, signature },
+      account.address,
+    )
+    expect(isValid).toBe(true)
+  })
+
+  test('verify rejects direct keychain wrapper signatures', async () => {
+    const signature = await signTypedData(client, {
+      account,
+      domain: getVoucherDomain(escrowContract, chainId),
+      types: voucherTypes,
+      primaryType: 'Voucher',
+      message: { channelId, cumulativeAmount },
+    })
+    const envelope = SignatureEnvelope.from(signature as SignatureEnvelope.Serialized)
+    const wrapped = SignatureEnvelope.serialize(
+      {
+        inner: envelope,
+        type: 'keychain',
+        userAddress: account.address,
+        version: 'v1',
+      },
+      { magic: true },
+    )
+
+    expect(
+      verifyVoucher(
+        escrowContract,
+        chainId,
+        { channelId, cumulativeAmount, signature: wrapped },
+        account.address,
+      ),
+    ).toBe(false)
+  })
+
+  test('verify rejects magic-suffixed secp256k1 signatures', async () => {
+    const signature = await signTypedData(client, {
+      account,
+      domain: getVoucherDomain(escrowContract, chainId),
+      types: voucherTypes,
+      primaryType: 'Voucher',
+      message: { channelId, cumulativeAmount },
+    })
+    const envelope = SignatureEnvelope.from(signature as SignatureEnvelope.Serialized)
+    const suffixed = SignatureEnvelope.serialize(envelope, { magic: true })
+
+    expect(
+      verifyVoucher(
+        escrowContract,
+        chainId,
+        { channelId, cumulativeAmount, signature: suffixed },
+        account.address,
+      ),
+    ).toBe(false)
+  })
+
+  test('signs and verifies p256 access-key vouchers as primitives', async () => {
+    const rootAccount = TempoAccount.fromSecp256k1(Secp256k1.randomPrivateKey())
+    const accessKey = TempoAccount.fromP256(P256.randomPrivateKey(), {
+      access: rootAccount,
+    })
+    const accessKeyClient = createClient({
+      account: accessKey,
+      transport: http('http://127.0.0.1'),
+    })
+
+    const signature = await signVoucher(
+      accessKeyClient,
+      accessKey,
+      { channelId, cumulativeAmount },
+      escrowContract,
+      chainId,
+    )
+
+    const envelope = SignatureEnvelope.from(signature as SignatureEnvelope.Serialized)
+    expect(envelope.type).toBe('p256')
+    expect(
+      verifyVoucher(
+        escrowContract,
+        chainId,
+        { channelId, cumulativeAmount, signature },
+        accessKey.accessKeyAddress,
+      ),
+    ).toBe(true)
+  })
+
+  test('signs and verifies webAuthn root vouchers as primitives', async () => {
+    const webAuthnAccount = TempoAccount.fromHeadlessWebAuthn(P256.randomPrivateKey(), {
+      origin: 'https://example.com',
+      rpId: 'example.com',
+    })
+    const webAuthnClient = createClient({
+      account: webAuthnAccount,
+      transport: http('http://127.0.0.1'),
+    })
+
+    const signature = await signVoucher(
+      webAuthnClient,
+      webAuthnAccount,
+      { channelId, cumulativeAmount },
+      escrowContract,
+      chainId,
+    )
+
+    const envelope = SignatureEnvelope.from(signature as SignatureEnvelope.Serialized)
+    expect(envelope.type).toBe('webAuthn')
+    expect(
+      verifyVoucher(
+        escrowContract,
+        chainId,
+        { channelId, cumulativeAmount, signature },
+        webAuthnAccount.address,
+      ),
+    ).toBe(true)
+  })
+
+  test('domain and type match TIP-1034', () => {
+    expect(getVoucherDomain(escrowContract, chainId)).toEqual({
+      name: 'TIP20 Channel Reserve',
+      version: '1',
+      chainId,
+      verifyingContract: escrowContract,
+    })
+    expect(voucherTypes.Voucher).toEqual([
+      { name: 'channelId', type: 'bytes32' },
+      { name: 'cumulativeAmount', type: 'uint96' },
+    ])
+    expect(
+      hashTypedData({
+        domain: getVoucherDomain(escrowContract, chainId),
+        types: voucherTypes,
+        primaryType: 'Voucher',
+        message: { channelId, cumulativeAmount },
+      }),
+    ).toMatch(/^0x[0-9a-f]{64}$/)
+  })
+})

package/src/tempo/session/precompile/Voucher.ts

@@ -0,0 +1,162 @@
+import { Channel, SignatureEnvelope } from 'ox/tempo'
+import type { Account, Address, Client, Hex } from 'viem'
+import { hashTypedData } from 'viem'
+import { signTypedData } from 'viem/actions'
+import { Account as TempoAccount } from 'viem/tempo'
+
+import * as TempoAddress from '../../internal/address.js'
+import type { Voucher, SignedVoucher } from './Protocol.js'
+import { uint96 } from './Protocol.js'
+
+/** Must match the on-chain TIP-20 channel reserve DOMAIN_SEPARATOR name. */
+const DOMAIN_NAME = 'TIP20 Channel Reserve'
+/** Must match the on-chain TIP20 channel escrow DOMAIN_SEPARATOR version. */
+const DOMAIN_VERSION = '1'
+
+/**
+ * EIP-712 domain for voucher signing.
+ */
+export function getVoucherDomain(escrowContract: Address, chainId: number) {
+  return {
+    name: DOMAIN_NAME,
+    version: DOMAIN_VERSION,
+    chainId,
+    verifyingContract: escrowContract,
+  } as const
+}
+
+/**
+ * EIP-712 types for voucher signing.
+ * Matches @tempo/stream-channels/voucher and on-chain VOUCHER_TYPEHASH.
+ */
+export const voucherTypes = {
+  Voucher: [
+    { name: 'channelId', type: 'bytes32' },
+    { name: 'cumulativeAmount', type: 'uint96' },
+  ],
+} as const
+
+function getVoucherDigest(chainId: number, voucher: Voucher): Hex {
+  return Channel.getVoucherSignPayload({
+    chainId,
+    channelId: voucher.channelId,
+    cumulativeAmount: voucher.cumulativeAmount,
+  }) as Hex
+}
+
+function getVoucherPayload(verifyingContract: Address, chainId: number, voucher: Voucher): Hex {
+  if (verifyingContract.toLowerCase() === Channel.address.toLowerCase())
+    return getVoucherDigest(chainId, voucher)
+  return hashTypedData({
+    domain: getVoucherDomain(verifyingContract, chainId),
+    types: voucherTypes,
+    primaryType: 'Voucher',
+    message: {
+      channelId: voucher.channelId,
+      cumulativeAmount: voucher.cumulativeAmount,
+    },
+  })
+}
+
+function isPrimitiveEnvelope(type: string): boolean {
+  return type === 'secp256k1' || type === 'p256' || type === 'webAuthn'
+}
+
+function signCanonicalTempoVoucher(
+  account: Account,
+  parameters: {
+    chainId: number
+    channelId: Hex
+    cumulativeAmount: bigint
+  },
+) {
+  // viem/tempo's canonical TIP-1034 voucher signer accepts Tempo account
+  // extensions that are wider than viem's base Account type. Keep that
+  // compatibility bridge here and fall back to generic EIP-712 below.
+  return TempoAccount.signVoucher(account as never, {
+    chainId: parameters.chainId,
+    channel: parameters.channelId,
+    cumulativeAmount: parameters.cumulativeAmount,
+  })
+}
+
+/**
+ * Sign a voucher with an account.
+ */
+export async function signVoucher(
+  client: Client,
+  account: Account,
+  voucher: Voucher,
+  verifyingContract: Address,
+  chainId: number,
+): Promise<Hex> {
+  const signature = await (async () => {
+    if (verifyingContract.toLowerCase() === Channel.address.toLowerCase()) {
+      try {
+        return await signCanonicalTempoVoucher(account, {
+          chainId,
+          channelId: voucher.channelId,
+          cumulativeAmount: voucher.cumulativeAmount,
+        })
+      } catch {}
+    }
+    return signTypedData(client, {
+      account,
+      domain: getVoucherDomain(verifyingContract, chainId),
+      types: voucherTypes,
+      primaryType: 'Voucher',
+      message: voucher,
+    })
+  })()
+
+  const envelope = SignatureEnvelope.from(signature as SignatureEnvelope.Serialized)
+  if (!isPrimitiveEnvelope(envelope.type))
+    throw new Error(
+      `TIP-1034 vouchers require a TIP-1020 primitive signature; received "${envelope.type}".`,
+    )
+
+  return SignatureEnvelope.serialize(envelope)
+}
+
+/**
+ * Verify a voucher signature matches the expected signer.
+ *
+ * Accepts canonical TIP-1020 primitive signatures. Keychain wrappers,
+ * multisig signatures, and magic-suffixed encodings are rejected.
+ */
+export function verifyVoucher(
+  escrowContract: Address,
+  chainId: number,
+  voucher: SignedVoucher,
+  expectedSigner: Address,
+): boolean {
+  try {
+    const envelope = SignatureEnvelope.from(voucher.signature as SignatureEnvelope.Serialized)
+
+    if (!isPrimitiveEnvelope(envelope.type)) return false
+    if (SignatureEnvelope.serialize(envelope).toLowerCase() !== voucher.signature.toLowerCase())
+      return false
+
+    const payload = getVoucherPayload(escrowContract, chainId, voucher)
+    const signer = SignatureEnvelope.extractAddress({ payload, signature: envelope })
+    const valid = SignatureEnvelope.verify(envelope, { address: signer, payload })
+    return valid && TempoAddress.isEqual(signer, expectedSigner)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Parse a voucher from credential payload.
+ */
+export function parseVoucherFromPayload(
+  channelId: Hex,
+  cumulativeAmount: string,
+  signature: Hex,
+): SignedVoucher {
+  return {
+    channelId,
+    cumulativeAmount: uint96(BigInt(cumulativeAmount)),
+    signature,
+  }
+}