mppx 0.3.11 → 0.3.12

package/src/client/Mppx.test-d.ts

@@ -2,6 +2,8 @@ import type { Account } from 'viem'
 import { describe, expectTypeOf, test } from 'vitest'
 import * as Method from '../Method.js'
 import { charge } from '../tempo/client/Charge.js'
+import { tempo } from '../tempo/client/Methods.js'
+import type * as AutoSwap from '../tempo/internal/auto-swap.js'
 import * as Methods from '../tempo/Methods.js'
 import * as z from '../zod.js'
 import * as Mppx from './Mppx.js'
@@ -88,3 +90,29 @@ describe('Mppx with context', () => {
     expectTypeOf(mppx.createCredential).returns.toMatchTypeOf<Promise<string>>()
   })
 })
+
+describe('fetch context', () => {
+  test('context has typed account and autoSwap for tempo charge', () => {
+    const mppx = Mppx.create({ methods: [charge()] })
+
+    type FetchInit = NonNullable<Parameters<typeof mppx.fetch>[1]>
+    type Context = NonNullable<FetchInit['context']>
+
+    expectTypeOf<Context>().toHaveProperty('account')
+    expectTypeOf<Context>().toHaveProperty('autoSwap')
+
+    expectTypeOf<Context['autoSwap']>().toEqualTypeOf<AutoSwap.resolve.Value | undefined>()
+  })
+
+  test('context has typed account and autoSwap for tempo()', () => {
+    const mppx = Mppx.create({ methods: [tempo()] })
+
+    type FetchInit = NonNullable<Parameters<typeof mppx.fetch>[1]>
+    type Context = NonNullable<FetchInit['context']>
+
+    // Context is a union of charge and session contexts.
+    // `account` exists on both; `autoSwap` only on charge.
+    expectTypeOf<Context>().toHaveProperty('account')
+    expectTypeOf<Extract<Context, { autoSwap?: unknown }>>().toHaveProperty('autoSwap')
+  })
+})

package/src/client/Mppx.ts

@@ -142,9 +142,9 @@ export declare namespace create {
  * @internal
  */
 type AnyContextFor<methods extends readonly Method.AnyClient[]> = {
-  [method in keyof methods]: methods[method] extends Method.Client<any, infer context>
-    ? context extends z.ZodMiniType
-      ? z.input<context>
+  [method in keyof methods]: NonNullable<methods[method]['context']> extends infer ctx
+    ? ctx extends z.ZodMiniType
+      ? z.input<ctx>
       : undefined
     : undefined
 }[number]

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

@@ -268,6 +268,374 @@ describe('Fetch.from', () => {
   })
 })
 
+// Minimal mock method — createCredential is only invoked on the 402 retry path.
+const noopMethod = {
+  name: 'test',
+  intent: 'test',
+  context: undefined,
+  createCredential: async () => 'credential',
+} as any
+
+/** Builds a valid 402 response with a WWW-Authenticate header. */
+function make402(overrides?: { method?: string; intent?: string }) {
+  const method = overrides?.method ?? 'test'
+  const intent = overrides?.intent ?? 'test'
+  const request = btoa(JSON.stringify({ amount: '1' }))
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '')
+  const header = `Payment id="abc", realm="test", method="${method}", intent="${intent}", request="${request}"`
+  return new Response(null, {
+    status: 402,
+    headers: { 'WWW-Authenticate': header },
+  })
+}
+
+describe('Fetch.from: init passthrough (non-402)', () => {
+  test('passes unmodified init to underlying fetch for non-402 responses', 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],
+    })
+
+    const customInit = {
+      method: 'POST',
+      headers: { 'X-Custom': 'value' },
+      body: JSON.stringify({ data: 'test' }),
+    }
+
+    await fetch('https://example.com/ws-upgrade', customInit)
+
+    expect(receivedInits[0]).toBe(customInit)
+  })
+
+  test('preserves extra properties on init for non-402 responses', 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],
+    })
+
+    const customInit = {
+      method: 'GET',
+      headers: { Authorization: 'Bearer token123' },
+      signal: AbortSignal.timeout(5000),
+    }
+
+    await fetch('https://example.com/api', customInit)
+
+    const received = receivedInits[0]!
+    expect(received.method).toBe('GET')
+    expect((received.headers as Record<string, string>).Authorization).toBe('Bearer token123')
+    expect(received.signal).toBe(customInit.signal)
+  })
+
+  test('passes through undefined init', 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],
+    })
+
+    await fetch('https://example.com/api')
+    expect(receivedInits[0]).toBeUndefined()
+  })
+
+  test('passes init with context through untouched', 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],
+    })
+
+    const customInit = { method: 'POST', context: { account: '0xabc' } }
+    await fetch('https://example.com/api', customInit as any)
+
+    expect(receivedInits[0]).toBe(customInit)
+  })
+
+  test('preserves object identity across all non-402 status codes', async () => {
+    for (const status of [200, 201, 204, 301, 400, 401, 403, 404, 500, 503]) {
+      const receivedInits: (RequestInit | undefined)[] = []
+      const mockFetch: typeof globalThis.fetch = async (_input, init) => {
+        receivedInits.push(init)
+        return new Response(null, { status })
+      }
+
+      const fetch = Fetch.from({
+        fetch: mockFetch,
+        methods: [noopMethod],
+      })
+
+      const customInit = { method: 'GET' }
+      await fetch('https://example.com/api', customInit)
+      expect(receivedInits[0]).toBe(customInit)
+    }
+  })
+})
+
+describe('Fetch.from: 402 retry path', () => {
+  test('strips context from init on retry', async () => {
+    const calls: { init: 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],
+    })
+
+    await fetch('https://example.com/api', {
+      method: 'POST',
+      context: { account: '0xabc' },
+    } as any)
+
+    expect(calls).toHaveLength(2)
+    const retryInit = calls[1]!.init as Record<string, unknown>
+    expect(retryInit).not.toHaveProperty('context')
+  })
+
+  test('adds Authorization header on retry', async () => {
+    let callCount = 0
+    const calls: { init: RequestInit | undefined }[] = []
+    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],
+    })
+
+    await fetch('https://example.com/api')
+
+    const retryInit = calls[1]!.init as Record<string, unknown>
+    const headers = retryInit.headers as Record<string, string>
+    expect(headers.Authorization).toBe('credential')
+  })
+
+  test('preserves existing headers on retry', async () => {
+    let callCount = 0
+    const calls: { init: RequestInit | undefined }[] = []
+    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],
+    })
+
+    await fetch('https://example.com/api', {
+      headers: { 'X-Custom': 'value', 'Content-Type': 'application/json' },
+    })
+
+    const retryInit = calls[1]!.init as Record<string, unknown>
+    const headers = retryInit.headers as Record<string, string>
+    expect(headers['X-Custom']).toBe('value')
+    expect(headers['Content-Type']).toBe('application/json')
+    expect(headers.Authorization).toBe('credential')
+  })
+
+  test('preserves method and other init properties on retry', async () => {
+    let callCount = 0
+    const calls: { init: RequestInit | undefined }[] = []
+    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],
+    })
+
+    await fetch('https://example.com/api', {
+      method: 'PUT',
+      body: JSON.stringify({ data: 'test' }),
+      credentials: 'include',
+      mode: 'cors',
+    })
+
+    const retryInit = calls[1]!.init as Record<string, unknown>
+    expect(retryInit.method).toBe('PUT')
+    expect(retryInit.body).toBe(JSON.stringify({ data: 'test' }))
+    expect(retryInit.credentials).toBe('include')
+    expect(retryInit.mode).toBe('cors')
+  })
+
+  test('handles undefined init on 402 retry', async () => {
+    let callCount = 0
+    const calls: { init: RequestInit | undefined }[] = []
+    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],
+    })
+
+    await fetch('https://example.com/api')
+
+    expect(calls).toHaveLength(2)
+    const retryInit = calls[1]!.init as Record<string, unknown>
+    expect(retryInit.headers).toEqual({ Authorization: 'credential' })
+  })
+
+  test('throws when no matching method for 402 challenge', async () => {
+    const mockFetch: typeof globalThis.fetch = async () =>
+      make402({ method: 'stripe', intent: 'charge' })
+
+    const fetch = Fetch.from({
+      fetch: mockFetch,
+      methods: [noopMethod],
+    })
+
+    await expect(fetch('https://example.com/api')).rejects.toThrow(
+      'No method found for "stripe.charge"',
+    )
+  })
+
+  test('retries exactly once — does not loop on repeated 402', async () => {
+    let callCount = 0
+    const mockFetch: typeof globalThis.fetch = async () => {
+      callCount++
+      return make402()
+    }
+
+    const fetch = Fetch.from({
+      fetch: mockFetch,
+      methods: [noopMethod],
+    })
+
+    const response = await fetch('https://example.com/api')
+    expect(callCount).toBe(2)
+    expect(response.status).toBe(402)
+  })
+})
+
+describe('Fetch.from: 402 retry headers normalization', () => {
+  test('preserves headers when passed as a Headers instance', async () => {
+    let callCount = 0
+    const calls: { init: RequestInit | undefined }[] = []
+    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],
+    })
+
+    const headers = new Headers({ 'X-Custom': 'value', 'Content-Type': 'application/json' })
+    await fetch('https://example.com/api', { headers })
+
+    const retryHeaders = (calls[1]!.init as Record<string, unknown>).headers as Record<
+      string,
+      string
+    >
+    expect(retryHeaders['x-custom']).toBe('value')
+    expect(retryHeaders['content-type']).toBe('application/json')
+    expect(retryHeaders.Authorization).toBe('credential')
+  })
+
+  test('preserves headers when passed as array of tuples', async () => {
+    let callCount = 0
+    const calls: { init: RequestInit | undefined }[] = []
+    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],
+    })
+
+    await fetch('https://example.com/api', {
+      headers: [
+        ['X-Custom', 'value'],
+        ['Accept', 'application/json'],
+      ],
+    })
+
+    const retryHeaders = (calls[1]!.init as Record<string, unknown>).headers as Record<
+      string,
+      string
+    >
+    expect(retryHeaders['X-Custom']).toBe('value')
+    expect(retryHeaders.Accept).toBe('application/json')
+    expect(retryHeaders.Authorization).toBe('credential')
+  })
+})
+
+describe('Fetch.from: input passthrough', () => {
+  test('passes URL input through on both initial and retry calls', async () => {
+    let callCount = 0
+    const receivedInputs: (RequestInfo | URL)[] = []
+    const mockFetch: typeof globalThis.fetch = async (input, _init) => {
+      receivedInputs.push(input)
+      callCount++
+      if (callCount === 1) return make402()
+      return new Response('OK', { status: 200 })
+    }
+
+    const fetch = Fetch.from({
+      fetch: mockFetch,
+      methods: [noopMethod],
+    })
+
+    const url = new URL('https://example.com/resource')
+    await fetch(url)
+
+    expect(receivedInputs[0]).toBe(url)
+    expect(receivedInputs[1]).toBe(url)
+  })
+})
+
 describe('Fetch.polyfill', () => {
   test('default', async () => {
     Fetch.polyfill({
@@ -313,3 +681,45 @@ describe('Fetch.polyfill', () => {
     Fetch.restore()
   })
 })
+
+describe('Fetch.polyfill / restore', () => {
+  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 originalFetch = globalThis.fetch
+
+    Fetch.polyfill({ methods: [noopMethod] })
+    expect(globalThis.fetch).not.toBe(originalFetch)
+
+    Fetch.restore()
+    expect(globalThis.fetch).toBe(originalFetch)
+  })
+
+  test('stacked polyfill calls preserve the true original fetch', () => {
+    const originalFetch = globalThis.fetch
+
+    Fetch.polyfill({ methods: [noopMethod] })
+    const firstPolyfill = globalThis.fetch
+
+    Fetch.polyfill({ methods: [noopMethod] })
+    expect(globalThis.fetch).not.toBe(firstPolyfill)
+
+    Fetch.restore()
+    expect(globalThis.fetch).toBe(originalFetch)
+  })
+
+  test('double restore does not clobber fetch', () => {
+    const originalFetch = globalThis.fetch
+
+    Fetch.polyfill({ methods: [noopMethod] })
+    Fetch.restore()
+    expect(globalThis.fetch).toBe(originalFetch)
+
+    Fetch.restore()
+    expect(globalThis.fetch).toBe(originalFetch)
+  })
+})

package/src/client/internal/Fetch.ts

@@ -31,11 +31,15 @@ export function from<const methods extends readonly Method.AnyClient[]>(
   const { fetch = globalThis.fetch, methods, onChallenge } = config
 
   return async (input, init) => {
-    const { context, ...fetchInit } = init ?? {}
-    const response = await fetch(input, fetchInit)
+    // Pass init through untouched to preserve object identity for non-402 responses.
+    const response = await fetch(input, init)
 
     if (response.status !== 402) return response
 
+    // Only extract context for payment handling after confirming 402.
+    const context = (init as Record<string, unknown> | undefined)?.context
+    const { context: _, ...fetchInit } = (init ?? {}) as Record<string, unknown>
+
     const challenge = Challenge.fromResponse(response)
 
     const mi = methods.find((m) => m.name === challenge.method && m.intent === challenge.intent)
@@ -55,7 +59,7 @@ export function from<const methods extends readonly Method.AnyClient[]>(
     return fetch(input, {
       ...fetchInit,
       headers: {
-        ...fetchInit.headers,
+        ...normalizeHeaders(fetchInit.headers),
         Authorization: credential,
       },
     })
@@ -64,9 +68,9 @@ export function from<const methods extends readonly Method.AnyClient[]>(
 
 /** Union of all context types from all methods that have context schemas. */
 type AnyContextFor<methods extends readonly Method.AnyClient[]> = {
-  [K in keyof methods]: methods[K] extends Method.Client<any, infer contextSchema>
-    ? contextSchema extends z.ZodMiniType
-      ? z.input<contextSchema>
+  [K in keyof methods]: NonNullable<methods[K]['context']> extends infer ctx
+    ? ctx extends z.ZodMiniType
+      ? z.input<ctx>
       : undefined
     : undefined
 }[number]
@@ -123,7 +127,7 @@ export declare namespace from {
 export function polyfill<const methods extends readonly Method.AnyClient[]>(
   config: polyfill.Config<methods>,
 ): void {
-  originalFetch = globalThis.fetch
+  if (!originalFetch) originalFetch = globalThis.fetch
   globalThis.fetch = from(config) as typeof globalThis.fetch
 }
 
@@ -153,6 +157,20 @@ export function restore(): void {
   }
 }
 
+/** @internal Normalizes headers to a plain object for spreading. */
+function normalizeHeaders(headers: unknown): Record<string, string> {
+  if (!headers) return {}
+  if (headers instanceof Headers) {
+    const result: Record<string, string> = {}
+    headers.forEach((value, key) => {
+      result[key] = value
+    })
+    return result
+  }
+  if (Array.isArray(headers)) return Object.fromEntries(headers)
+  return headers as Record<string, string>
+}
+
 /** @internal */
 async function resolveCredential(
   challenge: Challenge.Challenge,

package/src/tempo/client/Charge.ts

@@ -1,4 +1,5 @@
 import type * as Hex from 'ox/Hex'
+import type { Address } from 'viem'
 import { prepareTransactionRequest, signTransaction } from 'viem/actions'
 import { tempo as tempo_chain } from 'viem/chains'
 import { Actions } from 'viem/tempo'
@@ -8,6 +9,7 @@ import * as Account from '../../viem/Account.js'
 import * as Client from '../../viem/Client.js'
 import * as z from '../../zod.js'
 import * as Attribution from '../Attribution.js'
+import * as AutoSwap from '../internal/auto-swap.js'
 import * as defaults from '../internal/defaults.js'
 import * as Methods from '../Methods.js'
 
@@ -36,6 +38,7 @@ export function charge(parameters: charge.Parameters = {}) {
   return Method.toClient(Methods.charge, {
     context: z.object({
       account: z.optional(z.custom<Account.getResolver.Parameters['account']>()),
+      autoSwap: z.optional(z.custom<charge.AutoSwap>()),
     }),
 
     async createCredential({ challenge, context }) {
@@ -44,22 +47,41 @@ export function charge(parameters: charge.Parameters = {}) {
       const account = getAccount(client, context)
 
       const { request } = challenge
-      const { amount, currency, recipient, methodDetails } = request
+      const { amount, methodDetails } = request
+      const currency = request.currency as Address
+      const recipient = request.recipient as Address
 
       const memo = methodDetails?.memo
         ? (methodDetails.memo as Hex.Hex)
         : Attribution.encode({ serverId: challenge.realm, clientId })
 
+      const transferCall = Actions.token.transfer.call({
+        amount: BigInt(amount),
+        memo,
+        to: recipient,
+        token: currency,
+      })
+
+      const autoSwap = AutoSwap.resolve(
+        context?.autoSwap ?? parameters.autoSwap,
+        AutoSwap.defaultCurrencies,
+      )
+
+      const swapCalls = autoSwap
+        ? await AutoSwap.findCalls(client, {
+            account: account.address,
+            amountOut: BigInt(amount),
+            tokenOut: currency,
+            tokenIn: autoSwap.tokenIn,
+            slippage: autoSwap.slippage,
+          })
+        : undefined
+
+      const calls = [...(swapCalls ?? []), transferCall]
+
       const prepared = await prepareTransactionRequest(client, {
         account,
-        calls: [
-          Actions.token.transfer.call({
-            amount: BigInt(amount),
-            memo,
-            to: recipient as Hex.Hex,
-            token: currency as Hex.Hex,
-          }),
-        ],
+        calls,
         ...(methodDetails?.feePayer && { feePayer: true }),
         nonceKey: 'expiring',
       } as never)
@@ -77,7 +99,16 @@ export function charge(parameters: charge.Parameters = {}) {
 }
 
 export declare namespace charge {
+  type AutoSwap = AutoSwap.resolve.Value
+
   type Parameters = {
+    /**
+     * Automatically swap from a fallback currency (pathUsd, USDC.e) via the
+     * Tempo DEX when the user lacks sufficient balance of the target currency.
+     *
+     * @default false
+     */
+    autoSwap?: AutoSwap | undefined
     /** Client identifier used to derive the client fingerprint in attribution memos. */
     clientId?: string | undefined
   } & Account.getResolver.Parameters &