mppx 0.8.17 → 0.8.18

package/src/tempo/legacy/session/Channel.test.ts

@@ -1,109 +0,0 @@
-import { AbiParameters, Hash } from 'ox'
-import { describe, expect, test } from 'vp/test'
-
-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}$/)
-  })
-})

package/src/tempo/legacy/session/Channel.ts

@@ -1,51 +0,0 @@
-import { AbiParameters, Hash } from 'ox'
-import type * as Hex from 'ox/Hex'
-
-/**
- * Computes a channel ID from its parameters.
- *
- * Mirrors the onchain `computeChannelId` function: `keccak256(abi.encode(payer, payee, token, salt, authorizedSigner, escrowContract, chainId))`.
- */
-export function computeId(parameters: computeId.Parameters): Hex.Hex {
-  const encoded = AbiParameters.encode(
-    AbiParameters.from([
-      'address payer',
-      'address payee',
-      'address token',
-      'bytes32 salt',
-      'address authorizedSigner',
-      'address escrowContract',
-      'uint256 chainId',
-    ]),
-    [
-      parameters.payer,
-      parameters.payee,
-      parameters.token,
-      parameters.salt,
-      parameters.authorizedSigner,
-      parameters.escrowContract,
-      BigInt(parameters.chainId),
-    ],
-  )
-  return Hash.keccak256(encoded)
-}
-
-/** Type helpers for {@link computeId}. */
-export declare namespace computeId {
-  type Parameters = {
-    /** Address authorized to sign vouchers on behalf of the payer. */
-    authorizedSigner: Hex.Hex
-    /** Chain ID of the network the escrow contract is deployed on. */
-    chainId: number
-    /** Address of the escrow contract. */
-    escrowContract: Hex.Hex
-    /** Address of the payee (recipient). */
-    payee: Hex.Hex
-    /** Address of the payer (sender). */
-    payer: Hex.Hex
-    /** Unique salt to differentiate channels with the same parameters. */
-    salt: Hex.Hex
-    /** Address of the token used for payment. */
-    token: Hex.Hex
-  }
-}

package/src/tempo/legacy/session/Types.ts

@@ -1,91 +0,0 @@
-import type { Address, Hex } from 'viem'
-
-import type { SessionSignedVoucher, SessionVoucher } from '../../session/precompile/Protocol.js'
-
-/**
- * Legacy credential payload that opens a smart-contract-backed channel and authorizes initial spend.
- */
-export type LegacyOpenCredentialPayload = {
-  action: 'open'
-  type: 'transaction'
-  /** Session channel ID. */
-  channelId: Hex
-  /** Signed transaction containing the channel-open call. */
-  transaction: Hex
-  /** Voucher signature for `cumulativeAmount`. */
-  signature: Hex
-  /** Voucher signer selected for the opened channel. */
-  authorizedSigner?: Address | undefined
-  /** Initial cumulative spend authorized by the opening voucher, as raw units. */
-  cumulativeAmount: string
-}
-
-/** Legacy credential payload that adds deposit to an existing smart-contract-backed channel. */
-export type LegacyTopUpCredentialPayload = {
-  action: 'topUp'
-  type: 'transaction'
-  /** Session channel ID being topped up. */
-  channelId: Hex
-  /** Signed transaction containing the channel top-up call. */
-  transaction: Hex
-  /** Additional deposit to add, as raw units. */
-  additionalDeposit: string
-}
-
-/** Legacy credential payload that increases cumulative spend authorization. */
-export type LegacyVoucherCredentialPayload = {
-  action: 'voucher'
-  /** Session channel ID the voucher applies to. */
-  channelId: Hex
-  /** Highest cumulative spend authorized by this voucher, as raw units. */
-  cumulativeAmount: string
-  /** Voucher signature for `cumulativeAmount`. */
-  signature: Hex
-}
-
-/** Legacy credential payload that cooperatively closes a channel at final cumulative spend. */
-export type LegacyCloseCredentialPayload = {
-  action: 'close'
-  /** Session channel ID being closed. */
-  channelId: Hex
-  /** Final cumulative spend authorized at close, as raw units. */
-  cumulativeAmount: string
-  /** Voucher signature for `cumulativeAmount`. */
-  signature: Hex
-}
-
-/**
- * Legacy smart-contract-backed session credential payload.
- */
-export type LegacySessionCredentialPayload =
-  | LegacyOpenCredentialPayload
-  | LegacyTopUpCredentialPayload
-  | LegacyVoucherCredentialPayload
-  | LegacyCloseCredentialPayload
-
-/** Legacy smart-contract-backed voucher for cumulative payment. */
-export type LegacyVoucher = SessionVoucher
-
-/** Legacy smart-contract-backed voucher with EIP-712 signature. */
-export type LegacySignedVoucher = SessionSignedVoucher
-
-/** @deprecated Use {@link LegacyVoucher}. */
-export type Voucher = LegacyVoucher
-
-/** @deprecated Use {@link LegacySignedVoucher}. */
-export type SignedVoucher = LegacySignedVoucher
-
-/** @deprecated Use {@link LegacyOpenCredentialPayload}. */
-export type OpenCredentialPayload = LegacyOpenCredentialPayload
-
-/** @deprecated Use {@link LegacyTopUpCredentialPayload}. */
-export type TopUpCredentialPayload = LegacyTopUpCredentialPayload
-
-/** @deprecated Use {@link LegacyVoucherCredentialPayload}. */
-export type VoucherCredentialPayload = LegacyVoucherCredentialPayload
-
-/** @deprecated Use {@link LegacyCloseCredentialPayload}. */
-export type CloseCredentialPayload = LegacyCloseCredentialPayload
-
-/** @deprecated Use {@link LegacySessionCredentialPayload}. */
-export type SessionCredentialPayload = LegacySessionCredentialPayload

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

@@ -1,410 +0,0 @@
-import { P256, Secp256k1, Signature } from 'ox'
-import { SignatureEnvelope } from 'ox/tempo'
-import { createClient, http, type Account, type Hex } from 'viem'
-import { privateKeyToAccount } from 'viem/accounts'
-import { Account as TempoAccount, WebCryptoP256 } from 'viem/tempo'
-import { describe, expect, test } from 'vp/test'
-
-import { parseVoucherFromPayload, signVoucher, verifyVoucher } from './Voucher.js'
-
-const account = privateKeyToAccount(
-  '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
-)
-const escrowContract = '0x1234567890abcdef1234567890abcdef12345678' as const
-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 = 1000000n
-
-describe('Voucher', () => {
-  test('signVoucher and verifyVoucher round-trip', async () => {
-    const signature = await signVoucher(
-      client,
-      account,
-      { channelId, cumulativeAmount },
-      escrowContract,
-      chainId,
-    )
-    expect(signature).toMatch(/^0x/)
-    expect(signature.length).toBe(132)
-
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount, signature },
-      account.address,
-    )
-    expect(isValid).toBe(true)
-  })
-
-  test('signVoucher rejects direct WebCrypto P256 voucher signatures', async () => {
-    const keyPair = await WebCryptoP256.createKeyPair()
-    const p256Account = TempoAccount.fromWebCryptoP256(keyPair)
-    const p256Client = createClient({
-      account: p256Account,
-      transport: http('http://127.0.0.1'),
-    })
-
-    await expect(
-      signVoucher(
-        p256Client,
-        p256Account,
-        { channelId, cumulativeAmount },
-        escrowContract,
-        chainId,
-      ),
-    ).rejects.toThrow('Session vouchers only support secp256k1 signatures')
-  })
-
-  test('signVoucher rejects direct WebAuthn voucher signatures', 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'),
-    })
-
-    await expect(
-      signVoucher(
-        webAuthnClient,
-        webAuthnAccount,
-        { channelId, cumulativeAmount },
-        escrowContract,
-        chainId,
-      ),
-    ).rejects.toThrow('Session vouchers only support secp256k1 signatures')
-  })
-
-  test('signVoucher signs v1 secp256k1 access keys with raw signatures', async () => {
-    const accessKey = TempoAccount.fromSecp256k1(
-      '0x59c6995e998f97a5a0044966f09453863d462d2b3f1446a99f0a3d7b5d0f5a0d',
-      { access: account, internal_version: 'v1' },
-    )
-    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('secp256k1')
-    expect(signature.length).toBe(132)
-
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount, signature },
-      accessKey.accessKeyAddress,
-    )
-    expect(isValid).toBe(true)
-  })
-
-  test('signVoucher unwraps legacy secp256k1 keychain signatures', async () => {
-    const privateKey = '0x59c6995e998f97a5a0044966f09453863d462d2b3f1446a99f0a3d7b5d0f5a0d'
-    const rawAccessKey = TempoAccount.fromSecp256k1(privateKey)
-    const keychainSigner = {
-      accessKeyAddress: rawAccessKey.address,
-      address: account.address,
-      async sign({ hash }: { hash: Hex }) {
-        const inner = SignatureEnvelope.from(
-          Signature.toHex(Secp256k1.sign({ payload: hash, privateKey })),
-        )
-        return SignatureEnvelope.serialize({
-          type: 'keychain',
-          version: 'v1',
-          userAddress: account.address,
-          inner,
-        })
-      },
-    } as unknown as Account
-
-    const signature = await signVoucher(
-      client,
-      keychainSigner,
-      { channelId, cumulativeAmount },
-      escrowContract,
-      chainId,
-    )
-    const envelope = SignatureEnvelope.from(signature as SignatureEnvelope.Serialized)
-
-    expect(envelope.type).toBe('secp256k1')
-    expect(signature.length).toBe(132)
-
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount, signature },
-      rawAccessKey.address,
-    )
-    expect(isValid).toBe(true)
-  })
-
-  test('signVoucher signs v2 secp256k1 access keys with raw signatures', async () => {
-    const accessKey = TempoAccount.fromSecp256k1(
-      '0x59c6995e998f97a5a0044966f09453863d462d2b3f1446a99f0a3d7b5d0f5a0d',
-      { access: account },
-    )
-    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('secp256k1')
-    expect(signature.length).toBe(132)
-
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount, signature },
-      accessKey.accessKeyAddress,
-    )
-    expect(isValid).toBe(true)
-  })
-
-  test('verifyVoucher rejects keychain envelopes', async () => {
-    const privateKey = '0x59c6995e998f97a5a0044966f09453863d462d2b3f1446a99f0a3d7b5d0f5a0d'
-    const inner = SignatureEnvelope.from(
-      Signature.toHex(Secp256k1.sign({ payload: channelId, privateKey })),
-    )
-    const keychainSignature = SignatureEnvelope.serialize({
-      type: 'keychain',
-      version: 'v2',
-      userAddress: account.address,
-      inner,
-    })
-
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount, signature: keychainSignature },
-      account.address,
-    )
-    expect(isValid).toBe(false)
-  })
-
-  test('signVoucher signs non-secp256k1 access keys without keychain envelopes', async () => {
-    const accessKey = TempoAccount.fromP256(P256.randomPrivateKey(), {
-      access: account,
-      internal_version: 'v1',
-    })
-    const accessKeyClient = createClient({
-      account: accessKey,
-      transport: http('http://127.0.0.1'),
-    })
-
-    await expect(
-      signVoucher(
-        accessKeyClient,
-        accessKey,
-        { channelId, cumulativeAmount },
-        escrowContract,
-        chainId,
-      ),
-    ).rejects.toThrow('Session vouchers only support secp256k1 signatures')
-  })
-
-  test('verifyVoucher rejects magic-suffixed secp256k1 signatures', async () => {
-    const signature = await signVoucher(
-      client,
-      account,
-      { channelId, cumulativeAmount },
-      escrowContract,
-      chainId,
-    )
-    const signatureWithMagic = SignatureEnvelope.serialize(SignatureEnvelope.from(signature), {
-      magic: true,
-    })
-
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount, signature: signatureWithMagic },
-      account.address,
-    )
-    expect(isValid).toBe(false)
-  })
-
-  test('verifyVoucher rejects EIP-155-style secp256k1 v values', async () => {
-    const signature = await signVoucher(
-      client,
-      account,
-      { channelId, cumulativeAmount },
-      escrowContract,
-      chainId,
-    )
-    const signatureWithEip155V = `${signature.slice(0, -2)}${
-      signature.endsWith('1b') ? '23' : '24'
-    }` as `0x${string}`
-
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount, signature: signatureWithEip155V },
-      account.address,
-    )
-    expect(isValid).toBe(false)
-  })
-
-  test('verifyVoucher rejects wrong signer', async () => {
-    const signature = await signVoucher(
-      client,
-      account,
-      { channelId, cumulativeAmount },
-      escrowContract,
-      chainId,
-    )
-
-    const wrongAddress = '0x0000000000000000000000000000000000000001' as const
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount, signature },
-      wrongAddress,
-    )
-    expect(isValid).toBe(false)
-  })
-
-  test('verifyVoucher rejects tampered amount', async () => {
-    const signature = await signVoucher(
-      client,
-      account,
-      { channelId, cumulativeAmount },
-      escrowContract,
-      chainId,
-    )
-
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount: 9999999n, signature },
-      account.address,
-    )
-    expect(isValid).toBe(false)
-  })
-
-  test('verifyVoucher rejects tampered channelId', async () => {
-    const signature = await signVoucher(
-      client,
-      account,
-      { channelId, cumulativeAmount },
-      escrowContract,
-      chainId,
-    )
-
-    const wrongChannelId =
-      '0x0000000000000000000000000000000000000000000000000000000000000099' as const
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId: wrongChannelId, cumulativeAmount, signature },
-      account.address,
-    )
-    expect(isValid).toBe(false)
-  })
-
-  test('verifyVoucher rejects wrong chain ID', async () => {
-    const signature = await signVoucher(
-      client,
-      account,
-      { channelId, cumulativeAmount },
-      escrowContract,
-      chainId,
-    )
-
-    const isValid = await verifyVoucher(
-      escrowContract,
-      99999,
-      { channelId, cumulativeAmount, signature },
-      account.address,
-    )
-    expect(isValid).toBe(false)
-  })
-
-  test('verifyVoucher returns false for invalid signature', async () => {
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount, signature: '0xdeadbeef' },
-      account.address,
-    )
-    expect(isValid).toBe(false)
-  })
-
-  test('parseVoucherFromPayload', () => {
-    const sig =
-      '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890ab' as const
-    const voucher = parseVoucherFromPayload(channelId, '5000000', sig)
-    expect(voucher.channelId).toBe(channelId)
-    expect(voucher.cumulativeAmount).toBe(5000000n)
-    expect(voucher.signature).toBe(sig)
-  })
-
-  test('parseVoucherFromPayload with zero amount', () => {
-    const sig =
-      '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890ab' as const
-    const voucher = parseVoucherFromPayload(channelId, '0', sig)
-    expect(voucher.cumulativeAmount).toBe(0n)
-  })
-
-  test('verifyVoucher rejects wrong escrow contract', async () => {
-    const signature = await signVoucher(
-      client,
-      account,
-      { channelId, cumulativeAmount },
-      escrowContract,
-      chainId,
-    )
-
-    const wrongEscrow = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd' as const
-    const isValid = await verifyVoucher(
-      wrongEscrow,
-      chainId,
-      { channelId, cumulativeAmount, signature },
-      account.address,
-    )
-    expect(isValid).toBe(false)
-  })
-
-  test('signVoucher and verifyVoucher round-trip with zero amount', async () => {
-    const zeroAmount = 0n
-    const signature = await signVoucher(
-      client,
-      account,
-      { channelId, cumulativeAmount: zeroAmount },
-      escrowContract,
-      chainId,
-    )
-    expect(signature).toMatch(/^0x/)
-
-    const isValid = await verifyVoucher(
-      escrowContract,
-      chainId,
-      { channelId, cumulativeAmount: zeroAmount, signature },
-      account.address,
-    )
-    expect(isValid).toBe(true)
-  })
-})