mppx 0.8.15 → 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/ChannelStore.test.ts

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

@@ -1,39 +0,0 @@
-/**
- * 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

@@ -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