mppx 0.8.17 → 0.8.18

package/src/client/Transport.ts

@@ -1,170 +0,0 @@
-import * as Challenge from '../Challenge.js'
-import * as Credential from '../Credential.js'
-import * as Mcp from '../Mcp.js'
-import { mcp as mcpProtocol, paymentRequiredData } from './internal/protocols/Mcp.js'
-import { mpp as mppProtocol } from './internal/protocols/Mpp.js'
-import type { Protocol } from './internal/protocols/Protocol.js'
-import { paymentRequiredStatus } from './internal/protocols/Shared.js'
-import { x402 as x402Protocol } from './internal/protocols/X402.js'
-
-/**
- * Client-side transport adapter.
- *
- * Abstracts how challenges are received and credentials are sent
- * across different transport protocols (HTTP, MCP, etc.).
- */
-export type Transport<in out request = unknown, in out response = unknown> = {
-  /** Transport name for identification. */
-  name: string
-  /**
-   * Checks if a response indicates payment is required. May inspect the request (to gate
-   * body reads) and be async (to read a response body).
-   */
-  isPaymentRequired: (response: response, request?: request) => boolean | Promise<boolean>
-  /** Extracts all challenges from a payment-required response. */
-  getChallenges: (
-    response: response,
-    request?: request,
-  ) => Challenge.Challenge[] | Promise<Challenge.Challenge[]>
-  /** Attaches a credential to a request. */
-  setCredential: (
-    request: request,
-    credential: string,
-    options?: setCredential.Options | undefined,
-  ) => request
-}
-export type AnyTransport = Transport<any, any>
-
-export declare namespace setCredential {
-  type Options = {
-    /** Challenge selected for credential creation. */
-    challenge?: Challenge.Challenge | undefined
-  }
-}
-
-/** Extracts the response type from a transport. */
-export type ResponseOf<transport extends Transport> =
-  transport extends Transport<any, infer response> ? response : never
-
-/** Extracts the request type from a transport. */
-export type RequestOf<transport extends Transport> =
-  transport extends Transport<infer request, any> ? request : never
-
-/**
- * Creates a custom client-side transport.
- *
- * @example
- * ```ts
- * import { Transport } from 'mppx/client'
- *
- * const custom = Transport.from({
- *   name: 'custom',
- *   isPaymentRequired(response) { ... },
- *   getChallenges(response) { ... },
- *   setCredential(request, credential) { ... },
- * })
- * ```
- */
-export function from<request, response>(
-  transport: Transport<request, response>,
-): Transport<request, response> {
-  return transport
-}
-
-/** HTTP transport that composes payment protocols while keeping `fetch` as the single boundary. */
-export function http(): Transport<RequestInit, Response> {
-  const protocols: readonly Protocol[] = [mppProtocol(), x402Protocol(), mcpProtocol()]
-  const protocolForChallenge = new WeakMap<Challenge.Challenge, Protocol>()
-
-  const remember = (protocol: Protocol, challenges: Challenge.Challenge[]) => {
-    for (const challenge of challenges) protocolForChallenge.set(challenge, protocol)
-    return challenges
-  }
-
-  // Collect every protocol offer. Header-only 402 paths stay synchronous; MCP returns a promise
-  // only when it has to inspect a JSON-RPC/SSE body.
-  const collect = (
-    response: Response,
-    request?: RequestInit,
-  ): Challenge.Challenge[] | Promise<Challenge.Challenge[]> => {
-    const collectFrom = (
-      index: number,
-      collected: Challenge.Challenge[],
-    ): Challenge.Challenge[] | Promise<Challenge.Challenge[]> => {
-      for (let i = index; i < protocols.length; i++) {
-        const protocol = protocols[i]!
-        const challenges = protocol.getChallenges(response, request)
-        if (challenges instanceof Promise)
-          return challenges.then((list) =>
-            collectFrom(i + 1, [...collected, ...remember(protocol, list)]),
-          )
-        collected.push(...remember(protocol, challenges))
-      }
-      return collected
-    }
-    return collectFrom(0, [])
-  }
-
-  return from<RequestInit, Response>({
-    name: 'http',
-
-    isPaymentRequired(response, request) {
-      if (response.status === paymentRequiredStatus) return true // HTTP 402 — sync fast path
-      const challenges = collect(response, request)
-      return challenges instanceof Promise
-        ? challenges.then((list) => list.length > 0)
-        : challenges.length > 0
-    },
-
-    getChallenges(response, request) {
-      return collect(response, request)
-    },
-
-    setCredential(request, credential, options) {
-      const protocol = options?.challenge ? protocolForChallenge.get(options.challenge) : undefined
-      const fallback = protocols[0]
-      if (!protocol && !fallback) throw new Error('No protocol to attach the credential.')
-      return (protocol ?? fallback)!.setCredential(request, credential)
-    },
-  })
-}
-
-function mcpPaymentRequiredChallenges(response: Mcp.Response) {
-  const data = paymentRequiredData(response)
-  if (!data) throw new Error('No challenge in response.')
-  return data.challenges
-}
-
-/**
- * MCP protocol transport for direct JSON-RPC objects.
- *
- * Prefer {@link http} for MCP-over-HTTP fetches; this remains for callers that already operate on
- * parsed MCP request/response objects.
- */
-export function mcp() {
-  return from<Mcp.Request, Mcp.Response>({
-    name: 'mcp',
-
-    isPaymentRequired(response) {
-      return !!paymentRequiredData(response)
-    },
-
-    getChallenges(response) {
-      return mcpPaymentRequiredChallenges(response)
-    },
-
-    setCredential(request, credential) {
-      const parsed = Credential.deserialize(credential)
-      return {
-        ...request,
-        params: {
-          ...request.params,
-          ['_meta']: {
-            ...request.params?.['_meta'],
-            [Mcp.credentialMetaKey]: parsed,
-          },
-        },
-      }
-    },
-  })
-}

package/src/client/index.ts

@@ -1,29 +0,0 @@
-export * as Constants from '../Constants.js'
-export * as Expires from '../Expires.js'
-export * as Fetch from './internal/Fetch.js'
-export {
-  evm,
-  session,
-  sessionManager,
-  sessionMethod,
-  sessionLegacy,
-  sessionLegacyManager,
-  stripe,
-  tempo,
-} from './Methods.js'
-export {
-  createChannelStore,
-  createJsonChannelStore,
-  entryKey,
-  type ChannelStore,
-  type JsonChannelKv,
-} from '../tempo/session/client/ChannelStore.js'
-export type { ChargeContext } from '../tempo/client/Charge.js'
-export type {
-  ResolveAccount,
-  ResolveAccountCall,
-  ResolveAccountInfo,
-  ResolveAccountOperation,
-} from '../tempo/client/ResolveAccount.js'
-export * as Mppx from './Mppx.js'
-export * as Transport from './Transport.js'

package/src/client/internal/Fetch.browser.test.ts

@@ -1,197 +0,0 @@
-import { describe, expect, test, vi } from 'vp/test'
-
-import * as Fetch from './Fetch.js'
-
-const noopMethod = {
-  name: 'test',
-  intent: 'test',
-  context: undefined,
-  createCredential: async () => 'credential',
-} as any
-
-function make402() {
-  const request = btoa(JSON.stringify({ amount: '1' }))
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=+$/, '')
-  return new Response(null, {
-    status: 402,
-    headers: {
-      'WWW-Authenticate': `Payment id="abc", realm="test", method="test", intent="test", request="${request}"`,
-    },
-  })
-}
-
-function toHeaders(headers: unknown): Headers {
-  return new Headers((headers ?? {}) as HeadersInit)
-}
-
-/** Returns a fetch wrapper and the init captured from the 402 retry call. */
-function setup() {
-  const calls: (RequestInit | undefined)[] = []
-  let callCount = 0
-  const mockFetch: typeof globalThis.fetch = async (_input, init) => {
-    calls.push(init)
-    callCount++
-    if (callCount === 1) return make402()
-    return new Response('OK', { status: 200 })
-  }
-  const fetch = Fetch.from({ fetch: mockFetch, methods: [noopMethod] })
-  return {
-    fetch,
-    /** Headers sent on the retry (second) request. */
-    retryHeaders: async (input: RequestInfo | URL, init?: RequestInit) => {
-      await fetch(input, init)
-      return toHeaders((calls[1] as Record<string, unknown>)?.headers)
-    },
-  }
-}
-
-describe('Fetch.from: browser header normalization', () => {
-  test('preserves Headers instance', async () => {
-    const { retryHeaders } = setup()
-    const h = await retryHeaders('https://example.com', {
-      headers: new Headers({ 'X-Custom': 'value', 'Content-Type': 'application/json' }),
-    })
-    expect(h.get('x-custom')).toBe('value')
-    expect(h.get('content-type')).toBe('application/json')
-    expect(h.get('authorization')).toBe('credential')
-  })
-
-  test('preserves header tuples', async () => {
-    const { retryHeaders } = setup()
-    const h = await retryHeaders('https://example.com', {
-      headers: [
-        ['X-Custom', 'value'],
-        ['Accept', 'application/json'],
-      ],
-    })
-    expect(h.get('x-custom')).toBe('value')
-    expect(h.get('accept')).toBe('application/json')
-    expect(h.get('authorization')).toBe('credential')
-  })
-
-  test('replaces authorization case-insensitively', async () => {
-    const { retryHeaders } = setup()
-    const h = await retryHeaders('https://example.com', {
-      headers: { authorization: 'Bearer stale', 'X-Custom': 'value' },
-    })
-    expect(h.get('authorization')).toBe('credential')
-    expect(h.get('x-custom')).toBe('value')
-  })
-
-  test('preserves plain object headers', async () => {
-    const { retryHeaders } = setup()
-    const h = await retryHeaders('https://example.com', { headers: { 'X-Custom': 'val' } })
-    expect(h.get('x-custom')).toBe('val')
-    expect(h.get('authorization')).toBe('credential')
-  })
-
-  test('adds Authorization when no headers provided', async () => {
-    const { retryHeaders } = setup()
-    const h = await retryHeaders('https://example.com')
-    expect(h.get('authorization')).toBe('credential')
-  })
-})
-
-describe('Fetch.from: acceptPaymentPolicy (browser)', () => {
-  test('policy: "same-origin" injects for same-origin requests', async () => {
-    const receivedInits: (RequestInit | undefined)[] = []
-    const mockFetch: typeof globalThis.fetch = async (_input, init) => {
-      receivedInits.push(init)
-      return new Response('OK', { status: 200 })
-    }
-
-    const fetch = Fetch.from({
-      fetch: mockFetch,
-      methods: [noopMethod],
-      acceptPaymentPolicy: 'same-origin',
-    })
-
-    await fetch(`${globalThis.location.origin}/api`)
-    expect(toHeaders(receivedInits[0]?.headers).get('Accept-Payment')).toBe('test/test')
-  })
-
-  test('policy: "same-origin" skips for cross-origin requests', async () => {
-    const receivedInits: (RequestInit | undefined)[] = []
-    const mockFetch: typeof globalThis.fetch = async (_input, init) => {
-      receivedInits.push(init)
-      return new Response('OK', { status: 200 })
-    }
-
-    const fetch = Fetch.from({
-      fetch: mockFetch,
-      methods: [noopMethod],
-      acceptPaymentPolicy: 'same-origin',
-    })
-
-    await fetch('https://cross-origin.example.com/api')
-    expect(toHeaders(receivedInits[0]?.headers).get('Accept-Payment')).toBeNull()
-  })
-
-  test('policy: "same-origin" still handles 402 on cross-origin', async () => {
-    let callCount = 0
-    const mockFetch: typeof globalThis.fetch = async (_input, init) => {
-      callCount++
-      if (callCount === 1) {
-        expect(toHeaders(init?.headers).get('Accept-Payment')).toBeNull()
-        return make402()
-      }
-      expect(toHeaders(init?.headers).get('Authorization')).toBe('credential')
-      return new Response('OK', { status: 200 })
-    }
-
-    const fetch = Fetch.from({
-      fetch: mockFetch,
-      methods: [noopMethod],
-      acceptPaymentPolicy: 'same-origin',
-    })
-
-    const response = await fetch('https://cross-origin.example.com/api')
-    expect(response.status).toBe(200)
-  })
-})
-
-describe('Fetch.polyfill / restore: browser', () => {
-  test('restore is a no-op when polyfill was never called', () => {
-    const before = globalThis.fetch
-    Fetch.restore()
-    expect(globalThis.fetch).toBe(before)
-  })
-
-  test('restore reverts to original fetch', () => {
-    const original = globalThis.fetch
-    Fetch.polyfill({ methods: [noopMethod] })
-    expect(globalThis.fetch).not.toBe(original)
-    Fetch.restore()
-    expect(globalThis.fetch).toBe(original)
-  })
-
-  test('stacked polyfill calls preserve the true original', () => {
-    const original = globalThis.fetch
-    Fetch.polyfill({ methods: [noopMethod] })
-    Fetch.polyfill({ methods: [noopMethod] })
-    Fetch.restore()
-    expect(globalThis.fetch).toBe(original)
-  })
-
-  test('double restore does not clobber fetch', () => {
-    const original = globalThis.fetch
-    Fetch.polyfill({ methods: [noopMethod] })
-    Fetch.restore()
-    Fetch.restore()
-    expect(globalThis.fetch).toBe(original)
-  })
-
-  test('restore is a no-op when fetch was replaced externally', () => {
-    const original = globalThis.fetch
-    const external = vi.fn(
-      async () => new Response('external'),
-    ) as unknown as typeof globalThis.fetch
-    Fetch.polyfill({ methods: [noopMethod] })
-    globalThis.fetch = external
-    Fetch.restore()
-    expect(globalThis.fetch).toBe(external)
-    globalThis.fetch = original
-  })
-})

package/src/client/internal/Fetch.test-d.ts

@@ -1,109 +0,0 @@
-import type { Account } from 'viem'
-import { describe, expectTypeOf, test } from 'vp/test'
-
-import * as Challenge from '../../Challenge.js'
-import { charge } from '../../tempo/client/Charge.js'
-import * as Fetch from './Fetch.js'
-
-describe('Fetch.from', () => {
-  test('default', () => {
-    const fetch = Fetch.from({
-      methods: [charge()],
-    })
-
-    expectTypeOf(fetch).toBeFunction()
-    expectTypeOf(fetch).returns.toMatchTypeOf<Promise<Response>>()
-  })
-
-  test('behavior: accepts context in RequestInit when method has context', () => {
-    const fetch = Fetch.from({
-      methods: [charge()],
-    })
-
-    expectTypeOf(fetch).toBeCallableWith('https://example.com', {
-      context: { account: {} as Account },
-    })
-  })
-
-  test('behavior: context is optional in RequestInit', () => {
-    const fetch = Fetch.from({
-      methods: [charge()],
-    })
-
-    expectTypeOf(fetch).toBeCallableWith('https://example.com')
-    expectTypeOf(fetch).toBeCallableWith('https://example.com', {})
-  })
-
-  test('behavior: RequestInit extends standard RequestInit', () => {
-    const fetch = Fetch.from({
-      methods: [charge()],
-    })
-
-    expectTypeOf(fetch).toBeCallableWith('https://example.com', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ foo: 'bar' }),
-    })
-  })
-
-  test('behavior: accepts challenge ordering hook', () => {
-    const fetch = Fetch.from({
-      methods: [charge()],
-      orderChallenges: (candidates) => candidates,
-    })
-
-    expectTypeOf(fetch).toBeCallableWith('https://example.com', {
-      orderChallenges: (candidates) => candidates,
-    })
-  })
-
-  test('behavior: accepts payment retry cap', () => {
-    const fetch = Fetch.from({
-      maxPaymentRetries: 1,
-      methods: [charge()],
-    })
-
-    expectTypeOf(fetch).toBeFunction()
-  })
-
-  test('behavior: events infer payload types from methods', () => {
-    const method = charge()
-    const dispatcher = Fetch.createEventDispatcher<[typeof method]>()
-    dispatcher.on('*', (event) => {
-      if (event.name === 'challenge.received')
-        expectTypeOf(event.payload.challenge).toEqualTypeOf<Challenge.Challenge>()
-    })
-    dispatcher.on('challenge.received', (payload) => {
-      expectTypeOf(payload.method.intent).toEqualTypeOf<'charge'>()
-      return payload.createCredential({ account: {} as Account })
-    })
-    dispatcher.on('credential.created', (payload) => {
-      expectTypeOf(payload.method.intent).toEqualTypeOf<'charge'>()
-      expectTypeOf(payload.credential).toEqualTypeOf<string>()
-    })
-    dispatcher.on('payment.failed', (payload) => {
-      expectTypeOf(payload.error).toEqualTypeOf<unknown>()
-    })
-    dispatcher.on('payment.response', (payload) => {
-      expectTypeOf(payload.response).toEqualTypeOf<Response>()
-    })
-
-    const fetch = Fetch.from({
-      eventDispatcher: dispatcher,
-      methods: [method],
-    })
-
-    expectTypeOf(fetch).toBeFunction()
-  })
-})
-
-describe('Fetch.from.RequestInit', () => {
-  test('behavior: has context property typed to method context', () => {
-    const _method = charge()
-
-    type Methods = [typeof _method]
-    type Init = Fetch.from.RequestInit<Methods>
-
-    expectTypeOf<Init>().toHaveProperty('context')
-  })
-})