mppx 0.0.0-main-20260715214817

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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,51 @@
+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/ChannelStore.test.ts

@@ -0,0 +1,58 @@
+import type { Address, Hex } from 'viem'
+import { describe, expect, test } from 'vp/test'
+
+import * as Store from '../../../Store.js'
+import { chainId, escrowContract as escrowContractDefaults } from '../../internal/defaults.js'
+import * as ChannelStore from './ChannelStore.js'
+
+const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
+
+function legacyChannel(
+  overrides: Partial<ChannelStore.LegacyState> = {},
+): ChannelStore.LegacyState {
+  return {
+    channelId,
+    payer: '0x0000000000000000000000000000000000000001' as Address,
+    payee: '0x0000000000000000000000000000000000000002' as Address,
+    token: '0x0000000000000000000000000000000000000003' as Address,
+    authorizedSigner: '0x0000000000000000000000000000000000000004' as Address,
+    chainId: 42431,
+    escrowContract: escrowContractDefaults[chainId.testnet] as Address,
+    deposit: 10_000_000n,
+    settledOnChain: 0n,
+    highestVoucherAmount: 10_000_000n,
+    highestVoucher: null,
+    spent: 0n,
+    units: 0,
+    closeRequestedAt: 0n,
+    finalized: false,
+    createdAt: '2025-01-01T00:00:00.000Z',
+    ...overrides,
+  }
+}
+
+describe('legacy ChannelStore', () => {
+  test('keeps existing contract-backed channels compatible when backend fields are absent', async () => {
+    const store = ChannelStore.fromStore(Store.memory())
+    await store.updateChannel(channelId, () => legacyChannel())
+
+    const loaded = await store.getChannel(channelId)
+    expect(loaded).not.toBeNull()
+    expect(ChannelStore.isContractState(loaded!)).toBe(true)
+    expect(loaded!.backend).toBeUndefined()
+    expect('operator' in loaded!).toBe(false)
+    expect('salt' in loaded!).toBe(false)
+    expect('expiringNonceHash' in loaded!).toBe(false)
+    expect('descriptor' in loaded!).toBe(false)
+  })
+
+  test('supports explicit contract-backed channel state', async () => {
+    const store = ChannelStore.fromStore(Store.memory())
+    await store.updateChannel(channelId, () => legacyChannel({ backend: 'contract' }))
+
+    const loaded = await store.getChannel(channelId)
+    expect(loaded).not.toBeNull()
+    expect(ChannelStore.isContractState(loaded!)).toBe(true)
+    expect(loaded!.backend).toBe('contract')
+  })
+})

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

@@ -0,0 +1,39 @@
+/**
+ * Legacy contract-backed session channel-store facade.
+ *
+ * Legacy code imports channel-store types and helpers from this module so the
+ * contract-backed backend stays rooted under `tempo/legacy`. The underlying
+ * store adapter is shared with the TIP-1034 implementation because both
+ * backends persist the same accounting counters.
+ */
+import type * as SharedChannelStore from '../../session/server/ChannelStore.js'
+
+export {
+  deductFromChannel,
+  fromStore,
+  normalizeChannelId,
+  type BackendState,
+  type BaseState,
+  type ChannelStore,
+  type DeductResult,
+  type State,
+} from '../../session/server/ChannelStore.js'
+
+/** State for a legacy smart-contract-backed payment channel. */
+export interface LegacyContractBackendState {
+  /** Channel backend. Omitted for existing legacy records. */
+  backend?: 'contract' | undefined
+}
+
+/** @deprecated Use {@link LegacyContractBackendState}. */
+export type ContractBackendState = LegacyContractBackendState
+
+/** Legacy contract-backed channel state persisted by `tempo.sessionLegacy`. */
+export type LegacyState = SharedChannelStore.BaseState & LegacyContractBackendState
+
+/** Returns whether a channel is backed by the legacy smart contract escrow. */
+export function isContractState(
+  state: SharedChannelStore.State,
+): state is SharedChannelStore.BaseState & LegacyContractBackendState {
+  return state.backend === undefined || state.backend === 'contract'
+}

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

@@ -0,0 +1,91 @@
+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