mppx 0.8.17 → 0.8.19

package/src/tempo/Methods.ts

@@ -1,367 +0,0 @@
-import type { Account, Address } from 'viem'
-import { parseUnits } from 'viem'
-
-import * as Constants from '../Constants.js'
-import * as Method from '../Method.js'
-import * as z from '../zod.js'
-import type { SessionSnapshot } from './session/client/Runtime.js'
-import type * as PrecompileChannel from './session/precompile/Channel.js'
-import type { SubscriptionPeriodUnit } from './subscription/Types.js'
-
-export const chargeModes = ['push', 'pull'] as const
-export type ChargeMode = (typeof chargeModes)[number]
-export type SubscriptionPeriodCountInput = string | number | bigint
-
-const split = z.object({
-  amount: z.amount(),
-  memo: z.optional(z.hash()),
-  recipient: z.pipe(
-    z.string(),
-    z.transform((v) => v as Address),
-  ),
-})
-
-const uint64Max = (1n << 64n) - 1n
-const subscriptionPeriodUnitSeconds = {
-  dev_second: 1n,
-  day: 86_400n,
-  week: 604_800n,
-} satisfies Record<SubscriptionPeriodUnit, bigint>
-
-const normalizedAddress = z.pipe(
-  z.address(),
-  z.transform((value) => value.toLowerCase() as Address),
-)
-
-const subscriptionAccessKey = z.object({
-  accessKeyAddress: normalizedAddress,
-  keyType: z.enum(['p256', 'secp256k1', 'webAuthn']),
-})
-
-const subscriptionMethodDetails = z.object({
-  accessKey: z.optional(subscriptionAccessKey),
-  chainId: z.optional(z.number()),
-})
-
-const subscriptionExpires = z
-  .datetimeInput('subscriptionExpires must be a valid date')
-  .check(
-    z.refine(
-      (value) => value.getTime() % 1_000 === 0,
-      'subscriptionExpires must be representable as whole seconds',
-    ),
-  )
-
-const subscriptionPeriodUnits = [
-  'dev_second',
-  'day',
-  'week',
-] as const satisfies readonly SubscriptionPeriodUnit[]
-const subscriptionPeriodUnit = z.enum(subscriptionPeriodUnits)
-
-const uint64String = z
-  .pipe(
-    z.union([
-      z.string(),
-      z.bigint(),
-      z.custom<number>((value) => typeof value === 'number' && Number.isSafeInteger(value)),
-    ]),
-    z.transform((value) => value.toString()),
-  )
-  .check(
-    z.regex(/^[1-9]\d*$/, 'Invalid periodCount'),
-    z.refine((value) => {
-      try {
-        return BigInt(value) <= uint64Max
-      } catch {
-        return false
-      }
-    }, 'periodCount exceeds uint64'),
-  )
-
-function positiveParsedAmount(message: string) {
-  return z.refine((value) => {
-    const { amount, decimals } = value as { amount: string; decimals: number }
-    return parseUnits(amount, decimals) > 0n
-  }, message)
-}
-
-function subscriptionPeriodFitsUint64(value: unknown) {
-  const { periodCount, periodUnit } = value as {
-    periodCount: string
-    periodUnit: SubscriptionPeriodUnit
-  }
-  try {
-    const unitSeconds = subscriptionPeriodUnitSeconds[periodUnit]
-    if (unitSeconds === undefined) return false
-    return BigInt(periodCount) * unitSeconds <= uint64Max
-  } catch {
-    return false
-  }
-}
-
-/**
- * Tempo charge intent for one-time TIP-20 token transfers.
- *
- * @see https://github.com/tempoxyz/payment-auth-spec/blob/main/specs/methods/tempo/draft-tempo-charge-00.md
- */
-export const charge = Method.from({
-  name: 'tempo',
-  intent: 'charge',
-  schema: {
-    credential: {
-      payload: z.discriminatedUnion('type', [
-        z.object({ hash: z.hash(), type: z.literal('hash') }),
-        z.object({ signature: z.signature(), type: z.literal('transaction') }),
-        z.object({ signature: z.signature(), type: z.literal('proof') }),
-      ]),
-    },
-    request: z.pipe(
-      z
-        .object({
-          amount: z.amount(),
-          chainId: z.optional(z.number()),
-          currency: z.string(),
-          decimals: z.number(),
-          description: z.optional(z.string()),
-          externalId: z.optional(z.string()),
-          feePayer: z.optional(
-            z.pipe(
-              z.union([z.boolean(), z.custom<Account>()]),
-              z.transform((v): boolean => (typeof v === 'object' ? true : v)),
-            ),
-          ),
-          memo: z.optional(z.hash()),
-          recipient: z.optional(z.string()),
-          splits: z.optional(z.array(split).check(z.minLength(1), z.maxLength(10))),
-          supportedModes: z.optional(z.array(z.enum(chargeModes)).check(z.minLength(1))),
-        })
-        .check(
-          z.refine(({ amount, decimals, splits }) => {
-            if (!splits) return true
-
-            const totalAmount = parseUnits(amount, decimals)
-            const splitTotal = splits.reduce(
-              (sum, split) => sum + parseUnits(split.amount, decimals),
-              0n,
-            )
-
-            return (
-              splits.every((split) => parseUnits(split.amount, decimals) > 0n) &&
-              splitTotal < totalAmount
-            )
-          }, 'Invalid splits'),
-        ),
-      z.transform(
-        ({ amount, chainId, decimals, feePayer, memo, splits, supportedModes, ...rest }) => ({
-          ...rest,
-          amount: parseUnits(amount, decimals).toString(),
-          ...(chainId !== undefined ||
-          feePayer !== undefined ||
-          memo !== undefined ||
-          splits !== undefined ||
-          supportedModes !== undefined
-            ? {
-                methodDetails: {
-                  ...(chainId !== undefined && { chainId }),
-                  ...(feePayer !== undefined && { feePayer }),
-                  ...(memo !== undefined && { memo }),
-                  ...(splits !== undefined && {
-                    splits: splits.map((split) => ({
-                      ...split,
-                      amount: parseUnits(split.amount, decimals).toString(),
-                    })),
-                  }),
-                  ...(supportedModes !== undefined && { supportedModes }),
-                },
-              }
-            : {}),
-        }),
-      ),
-    ),
-  },
-})
-
-/**
- * Tempo session intent for pay-as-you-go streaming payments.
- *
- * Uses cumulative vouchers over a payment channel. Credential payloads
- * are a discriminated union on `action`: open, topUp, voucher, close.
- */
-export const session = Method.from({
-  name: 'tempo',
-  intent: 'session',
-  schema: {
-    credential: {
-      payload: z.discriminatedUnion('action', [
-        z.object({
-          action: z.literal('open'),
-          authorizedSigner: z.optional(z.string()),
-          channelId: z.hash(),
-          cumulativeAmount: z.amount(),
-          descriptor: z.optional(z.custom<PrecompileChannel.ChannelDescriptor>()),
-          signature: z.signature(),
-          transaction: z.signature(),
-          type: z.literal('transaction'),
-        }),
-        z.object({
-          action: z.literal('topUp'),
-          additionalDeposit: z.amount(),
-          channelId: z.hash(),
-          descriptor: z.optional(z.custom<PrecompileChannel.ChannelDescriptor>()),
-          transaction: z.signature(),
-          type: z.literal('transaction'),
-        }),
-        z.object({
-          action: z.literal('voucher'),
-          channelId: z.hash(),
-          cumulativeAmount: z.amount(),
-          descriptor: z.optional(z.custom<PrecompileChannel.ChannelDescriptor>()),
-          signature: z.signature(),
-        }),
-        z.object({
-          action: z.literal('close'),
-          channelId: z.hash(),
-          cumulativeAmount: z.amount(),
-          descriptor: z.optional(z.custom<PrecompileChannel.ChannelDescriptor>()),
-          signature: z.signature(),
-        }),
-      ]),
-    },
-    request: z.pipe(
-      z
-        .object({
-          amount: z.amount(),
-          chainId: z.optional(z.number()),
-          channelId: z.optional(z.hash()),
-          currency: z.string(),
-          decimals: z.number(),
-          escrowContract: z.optional(z.string()),
-          feePayer: z.optional(
-            z.pipe(
-              z.union([z.boolean(), z.custom<Account>()]),
-              z.transform((v): boolean => (typeof v === 'object' ? true : v)),
-            ),
-          ),
-          minVoucherDelta: z.optional(z.amount()),
-          operator: z.optional(z.address()),
-          recipient: z.optional(z.string()),
-          sessionProtocol: z.optional(
-            z.enum([Constants.SessionProtocols.v2, Constants.SessionProtocols.v1]),
-          ),
-          sessionSnapshot: z.optional(z.custom<SessionSnapshot>()),
-          suggestedDeposit: z.optional(z.amount()),
-          unitType: z.string(),
-        })
-        .check(
-          z.refine(
-            ({ amount, decimals }) => parseUnits(amount, decimals) > 0n,
-            'Session amount must be greater than 0',
-          ),
-        ),
-      z.transform(
-        ({
-          amount,
-          chainId,
-          channelId,
-          decimals,
-          escrowContract,
-          feePayer,
-          minVoucherDelta,
-          operator,
-          sessionProtocol,
-          sessionSnapshot,
-          suggestedDeposit,
-          ...rest
-        }) => ({
-          ...rest,
-          amount: parseUnits(amount, decimals).toString(),
-          ...(suggestedDeposit
-            ? {
-                suggestedDeposit: parseUnits(suggestedDeposit, decimals).toString(),
-              }
-            : {}),
-          methodDetails: {
-            escrowContract,
-            ...(channelId !== undefined && { channelId }),
-            ...(minVoucherDelta !== undefined && {
-              minVoucherDelta: parseUnits(minVoucherDelta, decimals).toString(),
-            }),
-            ...(chainId !== undefined && { chainId }),
-            ...(feePayer !== undefined && { feePayer }),
-            ...(operator !== undefined && { operator }),
-            ...(sessionProtocol !== undefined && {
-              [Constants.MethodDetailKeys.sessionProtocol]: sessionProtocol,
-            }),
-            ...(sessionSnapshot !== undefined && {
-              [Constants.MethodDetailKeys.sessionSnapshot]: sessionSnapshot,
-            }),
-          },
-        }),
-      ),
-    ),
-  },
-})
-
-/**
- * Tempo subscription intent for recurring TIP-20 token transfers.
- *
- * Uses a signed key authorization that delegates one transfer per billing period.
- */
-export const subscription = Method.from({
-  name: 'tempo',
-  intent: 'subscription',
-  schema: {
-    credential: {
-      payload: z.object({
-        signature: z.signature(),
-        type: z.literal('keyAuthorization'),
-      }),
-    },
-    request: z.pipe(
-      z
-        .object({
-          amount: z.amount(),
-          accessKey: z.optional(subscriptionAccessKey),
-          chainId: z.optional(z.number()),
-          currency: normalizedAddress,
-          decimals: z.number(),
-          description: z.optional(z.string()),
-          externalId: z.optional(z.string()),
-          methodDetails: z.optional(subscriptionMethodDetails),
-          periodCount: uint64String,
-          periodUnit: subscriptionPeriodUnit,
-          recipient: normalizedAddress,
-          subscriptionExpires,
-        })
-        .check(
-          positiveParsedAmount('Subscription amount must be greater than 0'),
-          z.refine(subscriptionPeriodFitsUint64, 'Subscription period exceeds uint64'),
-        ),
-      z.transform(
-        ({ accessKey, amount, chainId, decimals, methodDetails, subscriptionExpires, ...rest }) => {
-          // Accept top-level convenience input, but serialize Tempo-specific fields under methodDetails.
-          const nextMethodDetails: {
-            accessKey?: z.infer<typeof subscriptionAccessKey> | undefined
-            chainId?: number | undefined
-          } = {
-            ...methodDetails,
-            ...(accessKey !== undefined && { accessKey }),
-            ...(chainId !== undefined && { chainId }),
-          }
-
-          return {
-            ...rest,
-            amount: parseUnits(amount, decimals).toString(),
-            subscriptionExpires: subscriptionExpires.toISOString(),
-            ...(Object.keys(nextMethodDetails).length > 0
-              ? {
-                  methodDetails: nextMethodDetails,
-                }
-              : {}),
-          }
-        },
-      ),
-    ),
-  },
-})

package/src/tempo/Proof.conformance.test.ts

@@ -1,146 +0,0 @@
-import { recoverTypedDataAddress } from 'viem'
-import { privateKeyToAccount } from 'viem/accounts'
-import { describe, expect, test } from 'vp/test'
-
-import * as Proof from './Proof.js'
-
-/**
- * Deterministic conformance vector for the wallet-bound Tempo proof contract
- * (EIP-712 domain `MPP` version `3`). These values pin the on-the-wire
- * signing payload so any change to the proof ABI is caught here.
- */
-const vector = {
-  account: '0x1a642f0E3c3aF545E7AcBD38b07251B3990914F1',
-  chainId: 42431,
-  challengeId: 'kM9xPqWvT2nJrHsY4aDfEb',
-  digest: '0x3860a700a55e02ad3c2dc047e92489feceecbdb0a801d948e1d9f0b61ea9bc3f',
-  privateKey: `0x${'01'.repeat(32)}`,
-  realm: 'api.example.com',
-  signature:
-    '0x53f5d64d9f995e841b4212639b2e17e508e96752e10316df3814a16443dcbdb626c082190a4c3ecc3148101eb443d15bd83b579380b1be735a9c99f0df36c9fe1b',
-} as const
-
-const params = {
-  account: vector.account,
-  chainId: vector.chainId,
-  challengeId: vector.challengeId,
-  realm: vector.realm,
-} as const
-
-describe('tempo.Proof conformance (wallet binding)', () => {
-  test('typedData is the canonical wallet-bound MPP v3 proof contract', () => {
-    expect(Proof.typedData(params)).toEqual({
-      domain: { name: 'MPP', version: '3', chainId: vector.chainId },
-      types: {
-        Proof: [
-          { name: 'account', type: 'address' },
-          { name: 'challengeId', type: 'string' },
-          { name: 'realm', type: 'string' },
-        ],
-      },
-      primaryType: 'Proof',
-      message: {
-        account: vector.account,
-        challengeId: vector.challengeId,
-        realm: vector.realm,
-      },
-    })
-  })
-
-  test('hash matches the deterministic EIP-712 digest vector', () => {
-    expect(Proof.hash(params)).toBe(vector.digest)
-  })
-
-  test('the wallet produces the deterministic signature vector', async () => {
-    const account = privateKeyToAccount(vector.privateKey)
-    expect(account.address).toBe(vector.account)
-    const signature = await account.signTypedData(Proof.typedData(params))
-    expect(signature).toBe(vector.signature)
-  })
-
-  test('the signature vector recovers to the bound wallet', async () => {
-    const recovered = await recoverTypedDataAddress({
-      ...Proof.typedData(params),
-      signature: vector.signature,
-    })
-    expect(recovered).toBe(vector.account)
-  })
-
-  test('the digest is bound to the wallet: a different account changes the digest', () => {
-    const other = '0x000000000000000000000000000000000000dEaD'
-    expect(Proof.hash({ ...params, account: other })).not.toBe(vector.digest)
-  })
-
-  test('a proof cannot be replayed against a different wallet for the same challenge', async () => {
-    const account = privateKeyToAccount(vector.privateKey)
-    const signature = await account.signTypedData(Proof.typedData(params))
-
-    // An attacker swaps the bound `account` to a wallet they want to impersonate
-    // while keeping the same challenge. Because `account` is a signed field, the
-    // recovered signer no longer matches the swapped wallet, so verification
-    // (and the access-key delegation check, which rebuilds the message from the
-    // claimed source) fails.
-    const swapped = '0x000000000000000000000000000000000000dEaD'
-    const recovered = await recoverTypedDataAddress({
-      ...Proof.typedData({ ...params, account: swapped }),
-      signature,
-    })
-    expect(recovered).not.toBe(swapped)
-    expect(recovered).not.toBe(vector.account)
-  })
-
-  test('models the access-key delegation path: swapping the source breaks signer recovery', async () => {
-    // An access key K signs a proof bound to root account A. The server's
-    // delegation check recovers the signer from the message it rebuilds using
-    // the *claimed* source, then requires `isActiveAccessKey(signer, source)`.
-    // Distinct access key (signer) and root account (the bound payer / source).
-    const accessKey = privateKeyToAccount(`0x${'02'.repeat(32)}`)
-    const rootA = vector.account // proof is signed bound to account = A
-    const signature = await accessKey.signTypedData(Proof.typedData({ ...params, account: rootA }))
-    expect(accessKey.address).not.toBe(rootA)
-
-    // Honest submission (source = A): server recovers exactly K, so
-    // isActiveAccessKey(K, A) — the key actually authorized for A — is checked.
-    const recoveredForA = await recoverTypedDataAddress({
-      ...Proof.typedData({ ...params, account: rootA }),
-      signature,
-    })
-    expect(recoveredForA).toBe(accessKey.address)
-
-    // Replay against a different root B (attacker swaps source to B): server
-    // rebuilds the message with account = B, recovering some K' != K. Even if K
-    // is an active access key of B, the server checks isActiveAccessKey(K', B),
-    // which cannot match the authorized key. Replay is rejected.
-    const rootB = '0x000000000000000000000000000000000000bEEF'
-    const recoveredForB = await recoverTypedDataAddress({
-      ...Proof.typedData({ ...params, account: rootB }),
-      signature,
-    })
-    expect(recoveredForB).not.toBe(accessKey.address)
-  })
-
-  test('a legacy v2 proof (no account field) does not verify under the v3 contract', async () => {
-    // The pre-binding contract: domain version "2", message without `account`.
-    const account = privateKeyToAccount(vector.privateKey)
-    const legacyTypedData = {
-      domain: { name: 'MPP', version: '2', chainId: vector.chainId },
-      types: {
-        Proof: [
-          { name: 'challengeId', type: 'string' },
-          { name: 'realm', type: 'string' },
-        ],
-      },
-      primaryType: 'Proof',
-      message: { challengeId: vector.challengeId, realm: vector.realm },
-    } as const
-    const legacySignature = await account.signTypedData(legacyTypedData)
-
-    // Verified against the current wallet-bound v3 contract, recovery yields a
-    // different address, so the server rejects stale v2 proofs.
-    const recovered = await recoverTypedDataAddress({
-      ...Proof.typedData(params),
-      signature: legacySignature,
-    })
-    expect(recovered).not.toBe(account.address)
-  })
-})

package/src/tempo/Proof.test-d.ts

@@ -1,32 +0,0 @@
-import type { Address, Hex } from 'viem'
-import { expectTypeOf, test } from 'vp/test'
-
-import { Proof } from './index.js'
-
-test('Proof exports the wallet-bound typed-data contract helpers', () => {
-  expectTypeOf(Proof.message).toEqualTypeOf<
-    (parameters: { account: Address; challengeId: string; realm: string }) => {
-      readonly account: Address
-      readonly challengeId: string
-      readonly realm: string
-    }
-  >()
-
-  expectTypeOf(Proof.hash).toEqualTypeOf<
-    (parameters: { account: Address; chainId: number; challengeId: string; realm: string }) => Hex
-  >()
-})
-
-test('Proof exports public proof source helpers', () => {
-  expectTypeOf(Proof.proofSource).toEqualTypeOf<
-    (parameters: { address: string; chainId: number }) => string
-  >()
-
-  expectTypeOf(Proof.parsePkhSource).toEqualTypeOf<
-    (source: string) => { address: `0x${string}`; chainId: number } | null
-  >()
-
-  expectTypeOf(Proof.parseProofSource).toEqualTypeOf<
-    (source: string) => { address: `0x${string}`; chainId: number } | null
-  >()
-})

package/src/tempo/Proof.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-
-import * as tempo from './index.js'
-
-describe('tempo.Proof', () => {
-  test('proofSource constructs a did:pkh:eip155 source', () => {
-    expect(
-      tempo.Proof.proofSource({
-        address: '0xAbCdEf1234567890AbCdEf1234567890AbCdEf12',
-        chainId: 42431,
-      }),
-    ).toBe('did:pkh:eip155:42431:0xAbCdEf1234567890AbCdEf1234567890AbCdEf12')
-  })
-
-  test('parseProofSource parses a valid did:pkh:eip155 source', () => {
-    expect(
-      tempo.Proof.parseProofSource(
-        'did:pkh:eip155:42431:0xa5cc3c03994db5b0d9ba5e4f6d2efbd9f213b141',
-      ),
-    ).toEqual({
-      address: '0xa5cc3c03994db5b0d9ba5e4f6d2efbd9f213b141',
-      chainId: 42431,
-    })
-  })
-
-  test('parsePkhSource parses a valid did:pkh:eip155 source', () => {
-    expect(
-      tempo.Proof.parsePkhSource('did:pkh:eip155:42431:0xa5cc3c03994db5b0d9ba5e4f6d2efbd9f213b141'),
-    ).toEqual({
-      address: '0xa5cc3c03994db5b0d9ba5e4f6d2efbd9f213b141',
-      chainId: 42431,
-    })
-  })
-
-  test('parseProofSource rejects invalid source values', () => {
-    expect(
-      tempo.Proof.parseProofSource('did:pkh:eip155:01:0xa5cc3c03994db5b0d9ba5e4f6d2efbd9f213b141'),
-    ).toBe(null)
-  })
-})

package/src/tempo/Proof.ts

@@ -1,69 +0,0 @@
-import type { Address, Hex } from 'viem'
-
-import * as Proof_internal from './internal/proof.js'
-
-/** EIP-712 primary type for Tempo proof credentials. */
-export const primaryType = Proof_internal.primaryType
-
-/**
- * EIP-712 typed-data field definitions for Tempo zero-amount proof credentials.
- *
- * The `account` field cryptographically binds the signature to the payer
- * wallet, so a proof signed for one account cannot be replayed against another.
- */
-export const types = Proof_internal.types
-
-/** Constructs the EIP-712 domain for a Tempo proof credential. */
-export function domain(chainId: number) {
-  return Proof_internal.domain(chainId)
-}
-
-/**
- * Constructs the EIP-712 message for a Tempo proof credential.
- *
- * @param parameters - Proof message parameters.
- * @param parameters.account - Payer wallet address the proof is bound to.
- * @param parameters.challengeId - Challenge `id` being proven.
- * @param parameters.realm - Challenge `realm` being proven.
- */
-export function message(parameters: { account: Address; challengeId: string; realm: string }) {
-  return Proof_internal.message(parameters)
-}
-
-/**
- * Constructs the complete EIP-712 typed-data payload for a Tempo proof
- * credential — the canonical, wallet-bound proof contract.
- */
-export function typedData(parameters: {
-  account: Address
-  chainId: number
-  challengeId: string
-  realm: string
-}) {
-  return Proof_internal.typedData(parameters)
-}
-
-/** Computes the EIP-712 digest (signing payload) for a Tempo proof credential. */
-export function hash(parameters: {
-  account: Address
-  chainId: number
-  challengeId: string
-  realm: string
-}): Hex {
-  return Proof_internal.hash(parameters)
-}
-
-/** Constructs the canonical `did:pkh:eip155` source DID for Tempo proof credentials. */
-export function proofSource(parameters: { address: string; chainId: number }): string {
-  return Proof_internal.proofSource(parameters)
-}
-
-/** Parses a Tempo `did:pkh:eip155` source DID into its chain ID and wallet address. */
-export function parsePkhSource(source: string): { address: Address; chainId: number } | null {
-  return Proof_internal.parsePkhSource(source)
-}
-
-/** Parses a Tempo proof credential source DID into its chain ID and wallet address. */
-export function parseProofSource(source: string): { address: Address; chainId: number } | null {
-  return Proof_internal.parsePkhSource(source)
-}