mppx 0.3.1 → 0.3.3

package/src/tempo/stream/Chain.test.ts

@@ -0,0 +1,511 @@
+import { type Address, encodeFunctionData, erc20Abi, type Hex } from 'viem'
+import { Addresses, Transaction } from 'viem/tempo'
+import { beforeAll, describe, expect, test } from 'vitest'
+import {
+  closeChannelOnChain,
+  deployEscrow,
+  openChannel,
+  signOpenChannel,
+  signTopUpChannel,
+  topUpChannel,
+} from '~test/tempo/stream.js'
+import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'
+import {
+  broadcastOpenTransaction,
+  broadcastTopUpTransaction,
+  closeOnChain,
+  getOnChainChannel,
+  settleOnChain,
+  verifyTopUpTransaction,
+} from './Chain.js'
+import { signVoucher } from './Voucher.js'
+
+const UINT128_MAX = 2n ** 128n - 1n
+
+describe('assertUint128 (via settleOnChain / closeOnChain)', () => {
+  const mockClient = { chain: { id: 42431 } } as any
+  const dummyEscrow = '0x0000000000000000000000000000000000000001' as Address
+  const dummyChannelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
+
+  test('settleOnChain rejects amounts exceeding uint128', async () => {
+    await expect(
+      settleOnChain(mockClient, dummyEscrow, {
+        channelId: dummyChannelId,
+        cumulativeAmount: UINT128_MAX + 1n,
+        signature: '0xsig' as Hex,
+      }),
+    ).rejects.toThrow('cumulativeAmount exceeds uint128 range')
+  })
+
+  test('settleOnChain rejects negative amounts', async () => {
+    await expect(
+      settleOnChain(mockClient, dummyEscrow, {
+        channelId: dummyChannelId,
+        cumulativeAmount: -1n,
+        signature: '0xsig' as Hex,
+      }),
+    ).rejects.toThrow('cumulativeAmount exceeds uint128 range')
+  })
+
+  test('closeOnChain rejects amounts exceeding uint128', async () => {
+    await expect(
+      closeOnChain(mockClient, dummyEscrow, {
+        channelId: dummyChannelId,
+        cumulativeAmount: UINT128_MAX + 1n,
+        signature: '0xsig' as Hex,
+      }),
+    ).rejects.toThrow('cumulativeAmount exceeds uint128 range')
+  })
+
+  test('closeOnChain throws when no account available', async () => {
+    await expect(
+      closeOnChain(mockClient, dummyEscrow, {
+        channelId: dummyChannelId,
+        cumulativeAmount: 1_000_000n,
+        signature: '0xsig' as Hex,
+      }),
+    ).rejects.toThrow('no account available')
+  })
+})
+
+describe('on-chain', () => {
+  const payer = accounts[2]
+  const recipient = accounts[0].address
+  const currency = asset
+
+  let escrowContract: Address
+  let saltCounter = 0
+
+  beforeAll(async () => {
+    escrowContract = await deployEscrow()
+    await fundAccount({ address: payer.address, token: Addresses.pathUsd })
+    await fundAccount({ address: payer.address, token: currency })
+  })
+
+  function nextSalt(): Hex {
+    saltCounter++
+    return `0x${saltCounter.toString(16).padStart(64, '0')}` as Hex
+  }
+
+  describe('getOnChainChannel', () => {
+    test('reads channel state after opening', async () => {
+      const salt = nextSalt()
+      const deposit = 10_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const channel = await getOnChainChannel(client, escrowContract, channelId)
+
+      expect(channel.deposit).toBe(deposit)
+      expect(channel.finalized).toBe(false)
+      expect(channel.settled).toBe(0n)
+    })
+  })
+
+  describe('verifyTopUpTransaction', () => {
+    test('rejects when channel is finalized', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const signature = await signVoucher(
+        client,
+        payer,
+        { channelId, cumulativeAmount: 0n },
+        escrowContract,
+        chain.id,
+      )
+
+      await closeChannelOnChain({
+        escrow: escrowContract,
+        payee: accounts[0],
+        channelId,
+        cumulativeAmount: 0n,
+        signature,
+      })
+
+      await expect(verifyTopUpTransaction(client, escrowContract, channelId, 0n)).rejects.toThrow(
+        'channel is finalized on-chain',
+      )
+    })
+
+    test('rejects when deposit did not increase', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      await expect(
+        verifyTopUpTransaction(client, escrowContract, channelId, deposit),
+      ).rejects.toThrow('channel deposit did not increase')
+    })
+
+    test('succeeds when deposit increased via topUp', async () => {
+      const salt = nextSalt()
+      const initialDeposit = 5_000_000n
+      const topUpAmount = 3_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit: initialDeposit,
+        salt,
+      })
+
+      await topUpChannel({
+        escrow: escrowContract,
+        payer,
+        channelId,
+        token: currency,
+        amount: topUpAmount,
+      })
+
+      const result = await verifyTopUpTransaction(client, escrowContract, channelId, initialDeposit)
+
+      expect(result.deposit).toBe(initialDeposit + topUpAmount)
+    })
+  })
+
+  describe('broadcastOpenTransaction', () => {
+    test('rejects when payee does not match recipient', async () => {
+      const wrongPayee = accounts[3].address
+      const salt = nextSalt()
+
+      const { channelId, serializedTransaction } = await signOpenChannel({
+        escrow: escrowContract,
+        payer,
+        payee: wrongPayee,
+        token: currency,
+        deposit: 5_000_000n,
+        salt,
+      })
+
+      await expect(
+        broadcastOpenTransaction({
+          client,
+          serializedTransaction,
+          escrowContract,
+          channelId,
+          recipient,
+          currency,
+        }),
+      ).rejects.toThrow('open transaction payee does not match server recipient')
+    })
+
+    test('rejects when token does not match currency', async () => {
+      const wrongToken = Addresses.pathUsd
+      const salt = nextSalt()
+
+      const { channelId, serializedTransaction } = await signOpenChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: wrongToken,
+        deposit: 5_000_000n,
+        salt,
+      })
+
+      await expect(
+        broadcastOpenTransaction({
+          client,
+          serializedTransaction,
+          escrowContract,
+          channelId,
+          recipient,
+          currency,
+        }),
+      ).rejects.toThrow('open transaction token does not match server currency')
+    })
+
+    test('successful broadcast returns txHash and onChain state', async () => {
+      const salt = nextSalt()
+      const deposit = 10_000_000n
+
+      const { channelId, serializedTransaction } = await signOpenChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const result = await broadcastOpenTransaction({
+        client,
+        serializedTransaction,
+        escrowContract,
+        channelId,
+        recipient,
+        currency,
+      })
+
+      expect(result.txHash).toBeDefined()
+      expect(result.onChain.deposit).toBe(deposit)
+      expect(result.onChain.finalized).toBe(false)
+    })
+
+    test('fee-payer: rejects unauthorized calls', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+
+      const { channelId, serializedTransaction } = await signOpenChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const transferData = encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'transfer',
+        args: [recipient, deposit],
+      })
+
+      const deserialized = Transaction.deserialize(
+        serializedTransaction as Transaction.TransactionSerializedTempo,
+      )
+
+      const tampered = (await Transaction.serialize({
+        ...deserialized,
+        calls: [
+          ...((deserialized as any).calls ?? []),
+          { to: '0x8888888888888888888888888888888888888888' as Address, data: transferData },
+        ],
+      } as any)) as unknown as Hex
+
+      await expect(
+        broadcastOpenTransaction({
+          client,
+          serializedTransaction: tampered,
+          escrowContract,
+          channelId,
+          recipient,
+          currency,
+          feePayer: accounts[0],
+        }),
+      ).rejects.toThrow('fee-sponsored open transaction contains an unauthorized call')
+    })
+
+    test('duplicate broadcast returns fallback with txHash undefined', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+
+      const { channelId, serializedTransaction } = await signOpenChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      await broadcastOpenTransaction({
+        client,
+        serializedTransaction,
+        escrowContract,
+        channelId,
+        recipient,
+        currency,
+      })
+
+      const result = await broadcastOpenTransaction({
+        client,
+        serializedTransaction,
+        escrowContract,
+        channelId,
+        recipient,
+        currency,
+      })
+
+      expect(result.txHash).toBeUndefined()
+      expect(result.onChain.deposit).toBe(deposit)
+    })
+  })
+
+  describe('broadcastTopUpTransaction', () => {
+    test('rejects channelId mismatch', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+      const topUpAmount = 3_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const { serializedTransaction } = await signTopUpChannel({
+        escrow: escrowContract,
+        payer,
+        channelId,
+        token: currency,
+        amount: topUpAmount,
+      })
+
+      const wrongChannelId =
+        '0x0000000000000000000000000000000000000000000000000000000000000099' as Hex
+
+      await expect(
+        broadcastTopUpTransaction({
+          client,
+          serializedTransaction,
+          escrowContract,
+          channelId: wrongChannelId,
+          declaredDeposit: topUpAmount,
+          previousDeposit: deposit,
+        }),
+      ).rejects.toThrow('topUp transaction channelId does not match payload channelId')
+    })
+
+    test('rejects amount mismatch', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+      const topUpAmount = 3_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const { serializedTransaction } = await signTopUpChannel({
+        escrow: escrowContract,
+        payer,
+        channelId,
+        token: currency,
+        amount: topUpAmount,
+      })
+
+      await expect(
+        broadcastTopUpTransaction({
+          client,
+          serializedTransaction,
+          escrowContract,
+          channelId,
+          declaredDeposit: 9_999_999n,
+          previousDeposit: deposit,
+        }),
+      ).rejects.toThrow('topUp transaction amount')
+    })
+
+    test('successful broadcast returns txHash and newDeposit', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+      const topUpAmount = 3_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const { serializedTransaction } = await signTopUpChannel({
+        escrow: escrowContract,
+        payer,
+        channelId,
+        token: currency,
+        amount: topUpAmount,
+      })
+
+      const result = await broadcastTopUpTransaction({
+        client,
+        serializedTransaction,
+        escrowContract,
+        channelId,
+        declaredDeposit: topUpAmount,
+        previousDeposit: deposit,
+      })
+
+      expect(result.txHash).toBeDefined()
+      expect(result.newDeposit).toBe(deposit + topUpAmount)
+    })
+
+    test('fee-payer: rejects unauthorized calls', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+      const topUpAmount = 3_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const { serializedTransaction } = await signTopUpChannel({
+        escrow: escrowContract,
+        payer,
+        channelId,
+        token: currency,
+        amount: topUpAmount,
+      })
+
+      const transferData = encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'transfer',
+        args: [recipient, topUpAmount],
+      })
+
+      const deserialized = Transaction.deserialize(
+        serializedTransaction as Transaction.TransactionSerializedTempo,
+      )
+
+      const tampered = (await Transaction.serialize({
+        ...deserialized,
+        calls: [
+          ...((deserialized as any).calls ?? []),
+          { to: '0x8888888888888888888888888888888888888888' as Address, data: transferData },
+        ],
+      } as any)) as unknown as Hex
+
+      await expect(
+        broadcastTopUpTransaction({
+          client,
+          serializedTransaction: tampered,
+          escrowContract,
+          channelId,
+          declaredDeposit: topUpAmount,
+          previousDeposit: deposit,
+          feePayer: accounts[0],
+        }),
+      ).rejects.toThrow('fee-sponsored topUp transaction contains an unauthorized call')
+    })
+  })
+}) // end describe('on-chain')

package/src/tempo/stream/Channel.test.ts

@@ -0,0 +1,108 @@
+import { AbiParameters, Hash } from 'ox'
+import { describe, expect, test } from 'vitest'
+import * as Channel from './Channel.js'
+
+describe('computeId', () => {
+  const defaultParams: Channel.computeId.Parameters = {
+    payer: '0x1111111111111111111111111111111111111111',
+    payee: '0x2222222222222222222222222222222222222222',
+    token: '0x3333333333333333333333333333333333333333',
+    salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
+    authorizedSigner: '0x4444444444444444444444444444444444444444',
+    escrowContract: '0x5555555555555555555555555555555555555555',
+    chainId: 42431,
+  }
+
+  test('returns deterministic hash for fixed inputs', () => {
+    const id1 = Channel.computeId(defaultParams)
+    const id2 = Channel.computeId(defaultParams)
+    expect(id1).toBe(id2)
+  })
+
+  test('matches manual keccak256(abi.encode(...))', () => {
+    const encoded = AbiParameters.encode(
+      AbiParameters.from([
+        'address payer',
+        'address payee',
+        'address token',
+        'bytes32 salt',
+        'address authorizedSigner',
+        'address escrowContract',
+        'uint256 chainId',
+      ]),
+      [
+        defaultParams.payer,
+        defaultParams.payee,
+        defaultParams.token,
+        defaultParams.salt,
+        defaultParams.authorizedSigner,
+        defaultParams.escrowContract,
+        BigInt(defaultParams.chainId),
+      ],
+    )
+    const expected = Hash.keccak256(encoded)
+    expect(Channel.computeId(defaultParams)).toBe(expected)
+  })
+
+  test('different payer produces different id', () => {
+    const id1 = Channel.computeId(defaultParams)
+    const id2 = Channel.computeId({
+      ...defaultParams,
+      payer: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+    })
+    expect(id1).not.toBe(id2)
+  })
+
+  test('different salt produces different id', () => {
+    const id1 = Channel.computeId(defaultParams)
+    const id2 = Channel.computeId({
+      ...defaultParams,
+      salt: '0x0000000000000000000000000000000000000000000000000000000000000002',
+    })
+    expect(id1).not.toBe(id2)
+  })
+
+  test('different chainId produces different id', () => {
+    const id1 = Channel.computeId(defaultParams)
+    const id2 = Channel.computeId({ ...defaultParams, chainId: 1 })
+    expect(id1).not.toBe(id2)
+  })
+
+  test('chainId is encoded as uint256', () => {
+    const largeChainId = 2 ** 32
+    const id = Channel.computeId({ ...defaultParams, chainId: largeChainId })
+    expect(id).toMatch(/^0x[0-9a-f]{64}$/)
+
+    const encoded = AbiParameters.encode(
+      AbiParameters.from([
+        'address payer',
+        'address payee',
+        'address token',
+        'bytes32 salt',
+        'address authorizedSigner',
+        'address escrowContract',
+        'uint256 chainId',
+      ]),
+      [
+        defaultParams.payer,
+        defaultParams.payee,
+        defaultParams.token,
+        defaultParams.salt,
+        defaultParams.authorizedSigner,
+        defaultParams.escrowContract,
+        BigInt(largeChainId),
+      ],
+    )
+    expect(id).toBe(Hash.keccak256(encoded))
+  })
+
+  test('result is a 0x-prefixed 32-byte hex string', () => {
+    const id = Channel.computeId(defaultParams)
+    expect(id).toMatch(/^0x[0-9a-f]{64}$/)
+  })
+
+  test('chainId 0 is valid', () => {
+    const id = Channel.computeId({ ...defaultParams, chainId: 0 })
+    expect(id).toMatch(/^0x[0-9a-f]{64}$/)
+  })
+})