mppx 0.8.17 → 0.8.18

package/src/evm/server/Charge.ts

@@ -1,295 +0,0 @@
-import { getAddress, recoverTypedDataAddress } from 'viem'
-
-import type * as Credential from '../../Credential.js'
-import { VerificationFailedError } from '../../Errors.js'
-import * as Method from '../../Method.js'
-import * as Receipt from '../../Receipt.js'
-import * as ServerTransport from '../../server/Transport.js'
-import * as X402 from '../../x402/server/EvmCharge.js'
-import * as Assets from '../Assets.js'
-import * as Methods from '../Methods.js'
-import * as Types from '../Types.js'
-
-/**
- * Creates an EVM charge server method.
- *
- * Speaks the native Payment-auth `evm/charge` wire format.
- */
-export function charge(
-  parameters: charge.NativeConfig,
-): Method.Server<typeof Methods.charge, charge.Defaults>
-export function charge(parameters: charge.NativeConfig): Method.AnyServer {
-  const config = resolveConfig(parameters)
-  const paths = createPaths(config)
-  const transport = httpTransport(paths)
-
-  return Method.toServer<typeof Methods.charge, charge.Defaults, typeof transport>(Methods.charge, {
-    canOffer: parameters.canOffer,
-    onPaymentSuccess: parameters.onPaymentSuccess,
-    defaults: {
-      chainId: config.chainId,
-      currency: config.currency,
-      credentialTypes: ['authorization'],
-      decimals: config.decimals,
-      recipient: config.recipient,
-    },
-    transport,
-    async verify({ credential }) {
-      const payload = credential.payload as Types.AuthorizationPayload
-      const request = credential.challenge.request as Types.ChargeRequest
-      const chainId = request.methodDetails.chainId
-      const isX402Credential = X402.isCredential(credential)
-
-      if (!request.methodDetails.credentialTypes?.includes('authorization')) {
-        throw new VerificationFailedError({
-          reason: 'EVM authorization credentials are not supported for this challenge',
-        })
-      }
-
-      if (request.methodDetails.splits?.length) {
-        throw new VerificationFailedError({
-          reason: 'EVM authorization credentials do not support splits',
-        })
-      }
-
-      assertAddressEqual(payload.to, request.recipient, 'EVM authorization recipient mismatch')
-      if (payload.value !== request.amount)
-        throw new VerificationFailedError({ reason: 'EVM authorization amount mismatch' })
-      if (!isX402Credential && payload.nonce !== Types.challengeHash(credential.challenge))
-        throw new VerificationFailedError({ reason: 'EVM authorization challenge hash mismatch' })
-      const now = BigInt(Math.floor(Date.now() / 1000))
-      if (BigInt(payload.validAfter) > now)
-        throw new VerificationFailedError({ reason: 'EVM authorization is not valid yet' })
-      if (BigInt(payload.validBefore) <= now)
-        throw new VerificationFailedError({ reason: 'EVM authorization has expired' })
-
-      const signer = await recoverTypedDataAddress({
-        domain: Types.authorizationDomain({
-          authorization: config.authorization,
-          chainId,
-          currency: request.currency as `0x${string}`,
-        }),
-        message: {
-          from: getAddress(payload.from),
-          nonce: payload.nonce as `0x${string}`,
-          to: getAddress(payload.to),
-          validAfter: BigInt(payload.validAfter),
-          validBefore: BigInt(payload.validBefore),
-          value: BigInt(payload.value),
-        },
-        primaryType: 'TransferWithAuthorization',
-        signature: payload.signature as `0x${string}`,
-        types: Types.authorizationTypes,
-      })
-      assertAddressEqual(signer, payload.from, 'EVM authorization signature mismatch')
-
-      const source = Types.toSource({ address: getAddress(payload.from), chainId })
-      if (credential.source && credential.source !== source) {
-        throw new VerificationFailedError({ reason: 'EVM authorization source mismatch' })
-      }
-
-      const settled = await config.settle({
-        credential,
-        payload,
-        request,
-        source,
-      })
-
-      return Receipt.from({
-        method: Types.paymentMethod,
-        reference: settled.reference,
-        status: 'success',
-        timestamp: settled.timestamp ?? new Date().toISOString(),
-      })
-    },
-  })
-}
-
-export declare namespace charge {
-  type Parameters = NativeConfig
-  type Native = Method.Server<typeof Methods.charge, Defaults>
-
-  type NativeConfig = BaseConfig &
-    CurrencyConfig &
-    RecipientConfig &
-    Method.ComposableHooks<typeof Methods.charge>
-
-  type BaseConfig = {
-    /** EIP-3009 token domain metadata. Required for raw addresses and viem tokens; inferred for known assets. */
-    authorization?: Types.AuthorizationConfig | undefined
-    /** EVM chain ID. Required for raw addresses and viem tokens; inferred for known assets. */
-    chainId?: number | undefined
-    /** Token decimal places. Required for raw addresses; inferred for known assets and viem tokens. */
-    decimals?: number | undefined
-    /** Custom settlement override. If omitted, `x402.facilitator` is used. */
-    settle?: SettleAuthorization | undefined
-    /** x402 compatibility options. */
-    x402?: X402.Options | undefined
-  }
-
-  type CurrencyConfig = {
-    /** Token contract address, known EVM asset metadata, or viem token definition. */
-    currency: Assets.Currency
-  }
-
-  type RecipientConfig = {
-    /** Recipient wallet address. */
-    recipient: `0x${string}`
-  }
-
-  type RouteOptions = {
-    /** Required display-unit token amount. */
-    amount: string
-    /** Optional human-readable payment description. */
-    description?: string | undefined
-    /** Optional external correlation ID. */
-    externalId?: string | undefined
-  }
-
-  type SettleAuthorization = (parameters: {
-    credential: Credential.Credential<Types.AuthorizationPayload>
-    payload: Types.AuthorizationPayload
-    request: Types.ChargeRequest
-    source: ReturnType<typeof Types.toSource>
-  }) => Promise<{
-    reference: string
-    timestamp?: string | undefined
-  }>
-
-  type Defaults = {
-    chainId: number
-    currency: `0x${string}`
-    credentialTypes: ['authorization']
-    decimals: number
-    recipient: `0x${string}`
-  }
-}
-
-type ResolvedConfig = {
-  authorization: Types.AuthorizationConfig
-  chainId: number
-  currency: `0x${string}`
-  decimals: number
-  recipient: `0x${string}`
-  settle: charge.SettleAuthorization
-  x402: X402.ResolvedOptions
-}
-
-type HttpPath = {
-  bindCredential: NonNullable<ServerTransport.Http['bindCredential']>
-  captureRequest?: ServerTransport.Http['captureRequest'] | undefined
-  getCredential: ServerTransport.Http['getCredential']
-  respondChallenge: (
-    options: Parameters<ServerTransport.Http['respondChallenge']>[0],
-    response?: Response | undefined,
-  ) => Response | Promise<Response>
-  respondReceipt: (
-    options: Parameters<ServerTransport.Http['respondReceipt']>[0],
-    response: Response,
-  ) => Response
-}
-
-type HttpPaths = {
-  mpp: HttpPath
-  x402: HttpPath
-}
-
-function resolveConfig(config: charge.NativeConfig): ResolvedConfig {
-  const { currency, recipient } = config
-  let address: `0x${string}`
-  let authorization = config.authorization
-  let chainId = config.chainId
-  let decimals = config.decimals
-
-  if (Assets.isAsset(currency)) {
-    chainId ??= Assets.toChainId(currency.network)
-  }
-
-  if (chainId !== undefined) {
-    const resolved = Assets.resolve(currency, Types.networkOf(chainId))
-    if (!resolved) throw new Error(`EVM currency is not available on chain ID ${chainId}.`)
-    address = resolved.address
-    decimals ??= resolved.decimals
-    if (resolved.transfer?.type === Types.eip3009) {
-      authorization ??= {
-        name: resolved.transfer.name,
-        version: resolved.transfer.version,
-      }
-    }
-  } else if (Assets.isRawAddress(currency)) {
-    address = currency
-  } else {
-    throw new Error('EVM authorization requires `chainId`.')
-  }
-
-  if (!authorization) throw new Error('EVM authorization requires `authorization` metadata.')
-  if (chainId === undefined) throw new Error('EVM authorization requires `chainId`.')
-  if (decimals === undefined) throw new Error('EVM authorization requires `decimals`.')
-
-  const x402 = X402.resolveOptions({
-    authorization,
-    options: config.x402,
-  })
-  const settle = config.settle ?? (x402?.facilitator ? X402.settleWithFacilitator(x402) : undefined)
-  if (!settle) throw new Error('EVM authorization requires `settle` or `x402.facilitator`.')
-
-  return {
-    authorization,
-    chainId,
-    currency: getAddress(address),
-    decimals,
-    recipient: getAddress(recipient),
-    settle,
-    x402,
-  }
-}
-
-function createPaths(config: ResolvedConfig): HttpPaths {
-  return {
-    mpp: createMppPath(),
-    x402: X402.createPath(config.x402),
-  }
-}
-
-function createMppPath(): HttpPath {
-  const transport = ServerTransport.http()
-  return {
-    bindCredential: (options) => transport.bindCredential?.(options) ?? options.credential,
-    captureRequest: transport.captureRequest,
-    getCredential: transport.getCredential,
-    respondChallenge: (options) => transport.respondChallenge(options),
-    respondReceipt: (options, response) => transport.respondReceipt({ ...options, response }),
-  }
-}
-
-function httpTransport(paths: HttpPaths): ServerTransport.Http {
-  return ServerTransport.from<Request, Response>({
-    name: 'evm-http',
-
-    captureRequest: paths.mpp.captureRequest,
-
-    getCredential(input) {
-      return paths.mpp.getCredential(input) ?? paths.x402.getCredential(input)
-    },
-
-    bindCredential(options) {
-      if (X402.isPendingCredential(options.credential)) return paths.x402.bindCredential(options)
-      return paths.mpp.bindCredential?.(options) ?? options.credential
-    },
-
-    async respondChallenge(options) {
-      const response = await paths.mpp.respondChallenge(options)
-      return paths.x402.respondChallenge(options, response)
-    },
-
-    respondReceipt(options) {
-      const response = paths.mpp.respondReceipt(options, options.response)
-      return paths.x402.respondReceipt(options, response)
-    },
-  })
-}
-
-function assertAddressEqual(actual: string, expected: string, reason: string) {
-  if (getAddress(actual) === getAddress(expected)) return
-  throw new VerificationFailedError({ reason })
-}

package/src/evm/server/Methods.ts

@@ -1,22 +0,0 @@
-import type { NoExtraKeys } from '../../internal/types.js'
-import * as Assets from '../Assets.js'
-import * as Chains from '../Chains.js'
-import { charge as charge_ } from './Charge.js'
-
-/** Creates EVM server methods from shared charge parameters. */
-export function evm<const parameters extends evm.Parameters>(
-  parameters: NoExtraKeys<parameters, evm.Parameters>,
-) {
-  return [evm.charge(parameters)] as const
-}
-
-export namespace evm {
-  export type Parameters = charge_.Parameters
-
-  /** Creates an EVM `charge` server method. */
-  export const charge = charge_
-  /** Known EVM asset metadata for public config. */
-  export const assets = Assets
-  /** Common EVM chain IDs for public config. */
-  export const chains = Chains
-}

package/src/evm/server/index.ts

@@ -1,6 +0,0 @@
-export * as assets from '../Assets.js'
-/** @deprecated Use `chains` instead. */
-export * as Chains from '../Chains.js'
-export * as chains from '../Chains.js'
-export { charge } from './Charge.js'
-export { evm } from './Methods.js'

package/src/index.ts

@@ -1,14 +0,0 @@
-export * as BodyDigest from './BodyDigest.js'
-export * as Challenge from './Challenge.js'
-export * as Constants from './Constants.js'
-export * as Credential from './Credential.js'
-export * as Errors from './Errors.js'
-export * as Expires from './Expires.js'
-export * as evm from './evm/index.js'
-export * as Mcp from './Mcp.js'
-export * as Method from './Method.js'
-export * as PaymentRequest from './PaymentRequest.js'
-export * as Receipt from './Receipt.js'
-export * as Store from './Store.js'
-export * as x402 from './x402/index.js'
-export * as z from './zod.js'

package/src/internal/AcceptPayment.test.ts

@@ -1,347 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-
-import * as x402_ChallengeBrand from '../x402/internal/ChallengeBrand.js'
-import * as AcceptPayment from './AcceptPayment.js'
-
-function stripIndex(entry: AcceptPayment.Entry) {
-  const { index: _index, ...rest } = entry
-  return rest
-}
-
-describe('AcceptPayment', () => {
-  test('resolve builds a typed header from methods and overrides', () => {
-    const resolved = AcceptPayment.resolve(
-      [
-        { name: 'tempo', intent: 'charge' },
-        { name: 'tempo', intent: 'session' },
-        { name: 'stripe', intent: 'charge' },
-      ] as const,
-      ({ tempo, stripe }) => ({
-        [stripe.charge]: 0.5,
-        [tempo.session]: 0,
-      }),
-    )
-
-    expect(resolved.header).toBe('tempo/charge, tempo/session;q=0, stripe/charge;q=0.5')
-    expect(resolved.keys.tempo.charge).toBe('tempo/charge')
-    expect(resolved.keys.tempo.session).toBe('tempo/session')
-    expect(resolved.keys.stripe.charge).toBe('stripe/charge')
-  })
-
-  test('parse supports q-values and wildcards', () => {
-    expect(
-      AcceptPayment.parse('tempo/*, stripe/charge;q=0.5, */session;q=0').map(stripIndex),
-    ).toEqual([
-      { intent: '*', method: 'tempo', q: 1 },
-      { intent: 'charge', method: 'stripe', q: 0.5 },
-      { intent: 'session', method: '*', q: 0 },
-    ])
-  })
-
-  test('parse raw header vectors into normalized entries', () => {
-    const vectors = [
-      {
-        header: 'tempo/charge',
-        entries: [{ intent: 'charge', method: 'tempo', q: 1 }],
-        normalized: 'tempo/charge',
-      },
-      {
-        header: ' stripe/charge ; q = 0.25 , */session ; q=0 ',
-        entries: [
-          { intent: 'charge', method: 'stripe', q: 0.25 },
-          { intent: 'session', method: '*', q: 0 },
-        ],
-        normalized: 'stripe/charge;q=0.25, */session;q=0',
-      },
-      {
-        header: 'tempo/*;q=1, tempo/charge;q=0, stripe/*;q=0.5',
-        entries: [
-          { intent: '*', method: 'tempo', q: 1 },
-          { intent: 'charge', method: 'tempo', q: 0 },
-          { intent: '*', method: 'stripe', q: 0.5 },
-        ],
-        normalized: 'tempo/*, tempo/charge;q=0, stripe/*;q=0.5',
-      },
-    ] as const
-
-    for (const { entries, header, normalized } of vectors) {
-      const parsed = AcceptPayment.parse(header)
-      expect(parsed.map(stripIndex)).toEqual(entries)
-      expect(AcceptPayment.serialize(parsed)).toBe(normalized)
-    }
-  })
-
-  test('parse rejects empty and malformed headers', () => {
-    expect(() => AcceptPayment.parse('')).toThrow('Accept-Payment header is empty.')
-    expect(() => AcceptPayment.parse('tempo')).toThrow('Invalid Accept-Payment entry: tempo')
-    expect(() => AcceptPayment.parse('Tempo/charge')).toThrow(
-      'Invalid Accept-Payment method: Tempo',
-    )
-    expect(() => AcceptPayment.parse('tempo/charge;q')).toThrow(
-      'Invalid Accept-Payment parameter: q',
-    )
-    expect(() => AcceptPayment.parse('tempo/charge;q=1.001')).toThrow('Expected an HTTP qvalue')
-  })
-
-  test('rank prefers higher q then preserves offer order for ties', () => {
-    const offers = [
-      { method: 'tempo', intent: 'charge' },
-      { method: 'stripe', intent: 'charge' },
-      { method: 'tempo', intent: 'session' },
-    ]
-    const preferences = AcceptPayment.parse(
-      'stripe/charge;q=0.5, tempo/charge;q=0.9, tempo/session;q=0.9',
-    )
-
-    expect(AcceptPayment.rank(offers, preferences)).toEqual([
-      { method: 'tempo', intent: 'charge' },
-      { method: 'tempo', intent: 'session' },
-      { method: 'stripe', intent: 'charge' },
-    ])
-  })
-
-  test('rank prefers more specific wildcard matches', () => {
-    const preferences = AcceptPayment.parse('tempo/*;q=0.5, tempo/session;q=0.5, */*;q=0.1')
-
-    expect(AcceptPayment.rank([{ method: 'tempo', intent: 'session' }], preferences)).toEqual([
-      { method: 'tempo', intent: 'session' },
-    ])
-  })
-
-  test('rank applies the most specific match before q-value filtering', () => {
-    const preferences = AcceptPayment.parse('tempo/*;q=1, tempo/charge;q=0, stripe/*;q=0.5')
-
-    expect(
-      AcceptPayment.rank(
-        [
-          { method: 'tempo', intent: 'charge' },
-          { method: 'stripe', intent: 'charge' },
-        ],
-        preferences,
-      ),
-    ).toEqual([{ method: 'stripe', intent: 'charge' }])
-  })
-
-  test('rank excludes offers matched only by q=0 preferences', () => {
-    const preferences = AcceptPayment.parse('tempo/charge;q=0, stripe/*;q=0.1')
-
-    expect(
-      AcceptPayment.rank(
-        [
-          { method: 'tempo', intent: 'charge' },
-          { method: 'stripe', intent: 'session' },
-        ],
-        preferences,
-      ),
-    ).toEqual([{ method: 'stripe', intent: 'session' }])
-  })
-
-  test('selectChallenge returns the best supported offer', () => {
-    const selected = AcceptPayment.selectChallenge(
-      [
-        { id: '1', intent: 'charge', method: 'stripe', realm: 'test', request: {} },
-        { id: '2', intent: 'session', method: 'tempo', realm: 'test', request: {} },
-      ],
-      [
-        { name: 'tempo', intent: 'session' },
-        { name: 'stripe', intent: 'charge' },
-      ] as const,
-      AcceptPayment.parse('stripe/charge;q=0.5, tempo/session;q=0.9'),
-    )
-
-    expect(selected?.challenge.id).toBe('2')
-    expect(selected?.method).toEqual({ name: 'tempo', intent: 'session' })
-  })
-
-  test('selectChallengeCandidates returns supported offers with methods and response indexes', () => {
-    const candidates = AcceptPayment.selectChallengeCandidates(
-      [
-        { id: '1', intent: 'charge', method: 'unknown', realm: 'test', request: {} },
-        { id: '2', intent: 'session', method: 'tempo', realm: 'test', request: {} },
-        { id: '3', intent: 'charge', method: 'stripe', realm: 'test', request: {} },
-      ],
-      [
-        { name: 'tempo', intent: 'session' },
-        { name: 'stripe', intent: 'charge' },
-      ] as const,
-      AcceptPayment.parse('stripe/charge;q=0.5, tempo/session;q=0.9'),
-    )
-
-    expect(
-      candidates.map(({ challenge, index, method }) => ({
-        id: challenge.id,
-        index,
-        key: AcceptPayment.keyOf(method),
-      })),
-    ).toEqual([
-      { id: '2', index: 1, key: 'tempo/session' },
-      { id: '3', index: 2, key: 'stripe/charge' },
-    ])
-  })
-
-  test('selectChallengeCandidates prefers Payment-auth offers before x402 offers', () => {
-    const x402Challenge = x402_ChallengeBrand.mark({
-      id: 'x402:0',
-      intent: 'charge',
-      method: 'evm',
-      realm: 'test',
-      request: { scheme: 'exact' },
-    })
-    const nativeChallenge = {
-      id: 'native',
-      intent: 'charge',
-      method: 'tempo',
-      realm: 'test',
-      request: {},
-    }
-
-    const candidates = AcceptPayment.selectChallengeCandidates(
-      [x402Challenge, nativeChallenge],
-      [
-        { name: 'evm', intent: 'charge' },
-        { name: 'tempo', intent: 'charge' },
-      ] as const,
-      AcceptPayment.parse('evm/charge, tempo/charge;q=0.5'),
-    )
-
-    expect(candidates.map(({ challenge }) => challenge.id)).toEqual(['native', 'x402:0'])
-  })
-
-  test('selectChallengeCandidates preserves preference order within Payment-auth offers', () => {
-    const candidates = AcceptPayment.selectChallengeCandidates(
-      [
-        { id: 'tempo', intent: 'charge', method: 'tempo', realm: 'test', request: {} },
-        { id: 'evm', intent: 'charge', method: 'evm', realm: 'test', request: {} },
-      ],
-      [
-        { name: 'tempo', intent: 'charge' },
-        { name: 'evm', intent: 'charge' },
-      ] as const,
-      AcceptPayment.parse('evm/charge, tempo/charge;q=0.5'),
-    )
-
-    expect(candidates.map(({ challenge }) => challenge.id)).toEqual(['evm', 'tempo'])
-  })
-
-  test('selectChallengeCandidates supports duplicate method keys with challenge predicates', () => {
-    const challenges = [
-      {
-        id: 'primary',
-        intent: 'session',
-        method: 'tempo',
-        realm: 'test',
-        request: { methodDetails: { sessionProtocol: 'primary' } },
-      },
-      {
-        id: 'fallback',
-        intent: 'session',
-        method: 'tempo',
-        realm: 'test',
-        request: { methodDetails: { sessionProtocol: 'fallback' } },
-      },
-      {
-        id: 'unmarked',
-        intent: 'session',
-        method: 'tempo',
-        realm: 'test',
-        request: {},
-      },
-    ]
-    const methods = [
-      {
-        name: 'tempo',
-        intent: 'session',
-        canHandleChallenge: ({
-          challenge,
-        }: {
-          challenge: AcceptPayment.ChallengeCandidate['challenge']
-        }) =>
-          (challenge.request.methodDetails as { sessionProtocol?: string } | undefined)
-            ?.sessionProtocol === 'primary',
-      },
-      {
-        name: 'tempo',
-        intent: 'session',
-        canHandleChallenge: ({
-          challenge,
-        }: {
-          challenge: AcceptPayment.ChallengeCandidate['challenge']
-        }) => {
-          const sessionProtocol = (
-            challenge.request.methodDetails as { sessionProtocol?: string } | undefined
-          )?.sessionProtocol
-          return sessionProtocol === undefined || sessionProtocol === 'fallback'
-        },
-      },
-    ] as const
-
-    const candidates = AcceptPayment.selectChallengeCandidates(
-      challenges,
-      methods,
-      AcceptPayment.parse('tempo/session'),
-    )
-
-    expect(candidates.map(({ challenge }) => challenge.id)).toEqual([
-      'primary',
-      'fallback',
-      'unmarked',
-    ])
-  })
-
-  test('selectChallenge honors a specific opt-out over a broader wildcard', () => {
-    const selected = AcceptPayment.selectChallenge(
-      [
-        { id: '1', intent: 'charge', method: 'tempo', realm: 'test', request: {} },
-        { id: '2', intent: 'charge', method: 'stripe', realm: 'test', request: {} },
-      ],
-      [
-        { name: 'tempo', intent: 'charge' },
-        { name: 'stripe', intent: 'charge' },
-      ] as const,
-      AcceptPayment.parse('tempo/*;q=1, tempo/charge;q=0, stripe/*;q=0.5'),
-    )
-
-    expect(selected?.challenge.id).toBe('2')
-    expect(selected?.method).toEqual({ name: 'stripe', intent: 'charge' })
-  })
-
-  test('selectChallenge returns undefined when supported offers are disabled', () => {
-    const selected = AcceptPayment.selectChallenge(
-      [
-        { id: '1', intent: 'charge', method: 'tempo', realm: 'test', request: {} },
-        { id: '2', intent: 'charge', method: 'stripe', realm: 'test', request: {} },
-      ],
-      [{ name: 'tempo', intent: 'charge' }] as const,
-      AcceptPayment.parse('tempo/charge;q=0, stripe/charge'),
-    )
-
-    expect(selected).toBeUndefined()
-  })
-
-  test('throws for unknown payment preference keys', () => {
-    expect(() =>
-      AcceptPayment.resolve(
-        [{ name: 'tempo', intent: 'charge' }] as const,
-        {
-          'stripe/charge': 1,
-        } as never,
-      ),
-    ).toThrow('Unknown payment preference "stripe/charge"')
-  })
-
-  test('throws for invalid configured q-values', () => {
-    expect(() =>
-      AcceptPayment.resolve([{ name: 'tempo', intent: 'charge' }] as const, {
-        'tempo/charge': 0.3333,
-      }),
-    ).toThrow('Expected at most 3 decimal places')
-  })
-
-  test('throws for non-finite configured q-values', () => {
-    expect(() =>
-      AcceptPayment.resolve([{ name: 'tempo', intent: 'charge' }] as const, {
-        'tempo/charge': Number.POSITIVE_INFINITY,
-      }),
-    ).toThrow('Expected a finite number')
-  })
-})