mppx 0.6.31 → 0.7.0

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

@@ -0,0 +1,316 @@
+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('sign rejects p256 keychain access-key voucher delegation explicitly', 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'),
+    })
+
+    await expect(
+      signVoucher(
+        accessKeyClient,
+        accessKey,
+        { channelId, cumulativeAmount },
+        escrowContract,
+        chainId,
+        accessKey.accessKeyAddress,
+      ),
+    ).rejects.toThrow('TIP-1034 voucher signing only supports secp256k1 voucher signatures.')
+  })
+
+  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,160 @@
+import { Signature } from 'ox'
+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 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,
+  _authorizedSigner?: Address | undefined,
+): 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 (envelope.type === 'keychain' && envelope.inner.type === 'secp256k1')
+    return Signature.toHex(envelope.inner.signature)
+  if (envelope.type === 'keychain' || envelope.type !== 'secp256k1')
+    throw new Error('TIP-1034 voucher signing only supports secp256k1 voucher signatures.')
+
+  return signature
+}
+
+/**
+ * Verify a voucher signature matches the expected signer.
+ *
+ * Only accepts raw secp256k1 signatures — the escrow contract verifies
+ * via ecrecover. Keychain, p256, and webAuthn signatures are rejected.
+ */
+export function verifyVoucher(
+  escrowContract: Address,
+  chainId: number,
+  voucher: SignedVoucher,
+  expectedSigner: Address,
+): boolean {
+  try {
+    const envelope = SignatureEnvelope.from(voucher.signature as SignatureEnvelope.Serialized)
+
+    // Reject keychain signatures — the escrow contract verifies raw ECDSA
+    // signatures against authorizedSigner, not keychain-wrapped ones.
+    if (envelope.type === 'keychain') return false
+    if (envelope.type !== 'secp256k1') return false
+    if (SignatureEnvelope.serialize(envelope).toLowerCase() !== voucher.signature.toLowerCase())
+      return false
+
+    const payload =
+      escrowContract.toLowerCase() === Channel.address.toLowerCase()
+        ? getVoucherDigest(chainId, voucher)
+        : hashTypedData({
+            domain: getVoucherDomain(escrowContract, chainId),
+            types: voucherTypes,
+            primaryType: 'Voucher',
+            message: {
+              channelId: voucher.channelId,
+              cumulativeAmount: voucher.cumulativeAmount,
+            },
+          })
+    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,
+  }
+}

package/src/tempo/session/precompile/escrow.abi.ts

@@ -0,0 +1,226 @@
+const channelDescriptorComponents = [
+  { name: 'payer', type: 'address' },
+  { name: 'payee', type: 'address' },
+  { name: 'operator', type: 'address' },
+  { name: 'token', type: 'address' },
+  { name: 'salt', type: 'bytes32' },
+  { name: 'authorizedSigner', type: 'address' },
+  { name: 'expiringNonceHash', type: 'bytes32' },
+] as const
+
+const channelStateComponents = [
+  { name: 'settled', type: 'uint96' },
+  { name: 'deposit', type: 'uint96' },
+  { name: 'closeRequestedAt', type: 'uint32' },
+] as const
+
+const channelDescriptorInput = {
+  name: 'descriptor',
+  type: 'tuple',
+  components: channelDescriptorComponents,
+} as const
+
+/** ABI for the TIP-1034 TIP-20 Channel Escrow precompile. */
+export const escrowAbi = [
+  {
+    type: 'function',
+    name: 'CLOSE_GRACE_PERIOD',
+    stateMutability: 'view',
+    inputs: [],
+    outputs: [{ type: 'uint64' }],
+  },
+  {
+    type: 'function',
+    name: 'VOUCHER_TYPEHASH',
+    stateMutability: 'view',
+    inputs: [],
+    outputs: [{ type: 'bytes32' }],
+  },
+  {
+    type: 'function',
+    name: 'open',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'payee', type: 'address' },
+      { name: 'operator', type: 'address' },
+      { name: 'token', type: 'address' },
+      { name: 'deposit', type: 'uint96' },
+      { name: 'salt', type: 'bytes32' },
+      { name: 'authorizedSigner', type: 'address' },
+    ],
+    outputs: [{ name: 'channelId', type: 'bytes32' }],
+  },
+  {
+    type: 'function',
+    name: 'settle',
+    stateMutability: 'nonpayable',
+    inputs: [
+      channelDescriptorInput,
+      { name: 'cumulativeAmount', type: 'uint96' },
+      { name: 'signature', type: 'bytes' },
+    ],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'topUp',
+    stateMutability: 'nonpayable',
+    inputs: [channelDescriptorInput, { name: 'additionalDeposit', type: 'uint96' }],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'close',
+    stateMutability: 'nonpayable',
+    inputs: [
+      channelDescriptorInput,
+      { name: 'cumulativeAmount', type: 'uint96' },
+      { name: 'captureAmount', type: 'uint96' },
+      { name: 'signature', type: 'bytes' },
+    ],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'requestClose',
+    stateMutability: 'nonpayable',
+    inputs: [channelDescriptorInput],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'withdraw',
+    stateMutability: 'nonpayable',
+    inputs: [channelDescriptorInput],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'getChannel',
+    stateMutability: 'view',
+    inputs: [channelDescriptorInput],
+    outputs: [
+      {
+        type: 'tuple',
+        components: [
+          { name: 'descriptor', type: 'tuple', components: channelDescriptorComponents },
+          { name: 'state', type: 'tuple', components: channelStateComponents },
+        ],
+      },
+    ],
+  },
+  {
+    type: 'function',
+    name: 'getChannelState',
+    stateMutability: 'view',
+    inputs: [{ name: 'channelId', type: 'bytes32' }],
+    outputs: [{ type: 'tuple', components: channelStateComponents }],
+  },
+  {
+    type: 'function',
+    name: 'getChannelStatesBatch',
+    stateMutability: 'view',
+    inputs: [{ name: 'channelIds', type: 'bytes32[]' }],
+    outputs: [{ type: 'tuple[]', components: channelStateComponents }],
+  },
+  {
+    type: 'function',
+    name: 'computeChannelId',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'payer', type: 'address' },
+      { name: 'payee', type: 'address' },
+      { name: 'operator', type: 'address' },
+      { name: 'token', type: 'address' },
+      { name: 'salt', type: 'bytes32' },
+      { name: 'authorizedSigner', type: 'address' },
+      { name: 'expiringNonceHash', type: 'bytes32' },
+    ],
+    outputs: [{ type: 'bytes32' }],
+  },
+  {
+    type: 'function',
+    name: 'getVoucherDigest',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'channelId', type: 'bytes32' },
+      { name: 'cumulativeAmount', type: 'uint96' },
+    ],
+    outputs: [{ type: 'bytes32' }],
+  },
+  {
+    type: 'function',
+    name: 'domainSeparator',
+    stateMutability: 'view',
+    inputs: [],
+    outputs: [{ type: 'bytes32' }],
+  },
+  {
+    type: 'event',
+    name: 'ChannelOpened',
+    inputs: [
+      { name: 'channelId', type: 'bytes32', indexed: true },
+      { name: 'payer', type: 'address', indexed: true },
+      { name: 'payee', type: 'address', indexed: true },
+      { name: 'operator', type: 'address' },
+      { name: 'token', type: 'address' },
+      { name: 'authorizedSigner', type: 'address' },
+      { name: 'salt', type: 'bytes32' },
+      { name: 'expiringNonceHash', type: 'bytes32' },
+      { name: 'deposit', type: 'uint96' },
+    ],
+  },
+  {
+    type: 'event',
+    name: 'Settled',
+    inputs: [
+      { name: 'channelId', type: 'bytes32', indexed: true },
+      { name: 'payer', type: 'address', indexed: true },
+      { name: 'payee', type: 'address', indexed: true },
+      { name: 'cumulativeAmount', type: 'uint96' },
+      { name: 'deltaPaid', type: 'uint96' },
+      { name: 'newSettled', type: 'uint96' },
+    ],
+  },
+  {
+    type: 'event',
+    name: 'TopUp',
+    inputs: [
+      { name: 'channelId', type: 'bytes32', indexed: true },
+      { name: 'payer', type: 'address', indexed: true },
+      { name: 'payee', type: 'address', indexed: true },
+      { name: 'additionalDeposit', type: 'uint96' },
+      { name: 'newDeposit', type: 'uint96' },
+    ],
+  },
+  {
+    type: 'event',
+    name: 'CloseRequested',
+    inputs: [
+      { name: 'channelId', type: 'bytes32', indexed: true },
+      { name: 'payer', type: 'address', indexed: true },
+      { name: 'payee', type: 'address', indexed: true },
+      { name: 'closeGraceEnd', type: 'uint256' },
+    ],
+  },
+  {
+    type: 'event',
+    name: 'ChannelClosed',
+    inputs: [
+      { name: 'channelId', type: 'bytes32', indexed: true },
+      { name: 'payer', type: 'address', indexed: true },
+      { name: 'payee', type: 'address', indexed: true },
+      { name: 'settledToPayee', type: 'uint96' },
+      { name: 'refundedToPayer', type: 'uint96' },
+    ],
+  },
+  {
+    type: 'event',
+    name: 'CloseRequestCancelled',
+    inputs: [
+      { name: 'channelId', type: 'bytes32', indexed: true },
+      { name: 'payer', type: 'address', indexed: true },
+      { name: 'payee', type: 'address', indexed: true },
+    ],
+  },
+] as const