mppx 0.8.14 → 0.8.17

package/src/attestation/internal/HttpMessageSignature.ts

@@ -0,0 +1,429 @@
+import {
+  isInnerList,
+  parseDictionary,
+  serializeItem,
+  serializeDictionary,
+  serializeInnerList,
+  serializeParameters,
+} from 'structured-headers'
+import type { BareItem, Dictionary, InnerList, Item } from 'structured-headers'
+
+import type { MaybePromise } from '../../internal/types.js'
+import * as Store from '../../Store.js'
+import { Algorithms, Headers as AttestationHeaders } from '../Constants.js'
+import type { KeyResolver, SignatureAlgorithm, SigningContext } from '../Types.js'
+import * as SigningContextInternal from './SigningContext.js'
+
+/** RFC 9421 constants used by request-attestation signature profiles. */
+export const Constants = {
+  /** Derived request components supported by this narrow request profile. */
+  components: {
+    /** The target host and non-default port. */
+    authority: '@authority',
+    /** The request URL path without its query string. */
+    path: '@path',
+    /** The lowercased `Signature-Agent` request header. */
+    signatureAgent: 'signature-agent',
+    /** The signature's canonicalized covered-components and parameters. */
+    signatureParams: '@signature-params',
+  },
+} as const
+
+const algorithmDescriptors = {
+  [Algorithms.ed25519]: {
+    hash: undefined,
+    keyAlgorithm: 'Ed25519',
+    webCryptoAlgorithm: 'Ed25519',
+  },
+  [Algorithms.rsaPssSha512]: {
+    hash: 'SHA-512',
+    keyAlgorithm: 'RSA-PSS',
+    webCryptoAlgorithm: { name: 'RSA-PSS', saltLength: 64 },
+  },
+} as const satisfies Record<
+  SignatureAlgorithm,
+  {
+    hash: string | undefined
+    keyAlgorithm: string
+    webCryptoAlgorithm: AlgorithmIdentifier | RsaPssParams
+  }
+>
+
+/** A covered HTTP message component and its RFC 9421 component parameters. */
+export type Component = {
+  /** Derived component identifier or lowercased HTTP field name. */
+  id: string
+  /** Parameters that qualify the component, such as `;key="agent"`. */
+  parameters?: ReadonlyMap<string, BareItem> | undefined
+}
+
+/** Input accepted by signers; bare strings denote unparameterized components. */
+export type ComponentInput = string | Component
+
+export type SignatureInput = {
+  algorithm: SignatureAlgorithm
+  components: readonly Component[]
+  created: number
+  expires: number
+  keyId: string
+  label: string
+  nonce: string
+  parameters: ReadonlyMap<string, BareItem>
+  tag: string
+}
+
+/** Result of validating one supported RFC 9421 signature. */
+export type VerificationResult =
+  | { status: 'absent' }
+  | { status: 'invalid'; reason: string }
+  | { status: 'unverified'; reason: string }
+  | { status: 'verified'; input: SignatureInput }
+
+/** Signs a request using the configured RFC 9421-derived component list. */
+export async function sign(
+  request: Request,
+  options: {
+    components: readonly ComponentInput[]
+    expiresIn?: number | undefined
+    keyId: string
+    key: CryptoKey
+    label: string
+    context?: SigningContext | undefined
+    tag: string
+  },
+): Promise<Request> {
+  const context = options.context ?? SigningContextInternal.create()
+  const created = context.created
+  const expires = created + (options.expiresIn ?? 60)
+  const algorithm = algorithmFromKey(options.key)
+  const parameters = new Map<string, BareItem>([
+    ['created', created],
+    ['expires', expires],
+    ['keyid', options.keyId],
+    ['alg', algorithm],
+    ['nonce', context.nonce],
+    ['tag', options.tag],
+  ])
+  const input: SignatureInput = {
+    algorithm,
+    components: options.components.map(toComponent),
+    created,
+    expires,
+    keyId: options.keyId,
+    label: options.label,
+    nonce: context.nonce,
+    parameters,
+    tag: options.tag,
+  }
+  const signature = await crypto.subtle.sign(
+    webCryptoAlgorithm(algorithm),
+    options.key,
+    toArrayBuffer(encode(signatureBase(request, input))),
+  )
+  const headers = new Headers(request.headers)
+  const inputs = parseHeaderDictionary(headers, AttestationHeaders.signatureInput)
+  const signatures = parseHeaderDictionary(headers, AttestationHeaders.signature)
+  if (!haveSameKeys(inputs, signatures))
+    throw new Error('Signature-Input and Signature must contain the same labels.')
+  if (inputs.has(input.label) || signatures.has(input.label))
+    throw new Error(`HTTP message signature label "${input.label}" already exists.`)
+  inputs.set(input.label, toInnerList(input))
+  signatures.set(input.label, [signature, new Map()])
+  headers.set(AttestationHeaders.signatureInput, serializeDictionary(inputs))
+  headers.set(AttestationHeaders.signature, serializeDictionary(signatures))
+  return new Request(request, { headers })
+}
+
+/** Verifies a request signature, its lifetime, and optionally its nonce. */
+export async function verify(
+  request: Request,
+  options: {
+    keyResolver: KeyResolver
+    maxAge: number
+    nonceNamespace: string
+    nonceStore: Store.AtomicStore
+    requiredComponents: readonly string[]
+    tag: string | readonly string[]
+    validate?: ((input: SignatureInput, request: Request) => string | undefined) | undefined
+    validateKey?:
+      | ((
+          key: CryptoKey,
+          input: SignatureInput,
+          request: Request,
+        ) => MaybePromise<string | undefined>)
+      | undefined
+  },
+): Promise<VerificationResult> {
+  const parsed = parse(request, options.tag)
+  if (!parsed) return { status: 'absent' }
+  if (parsed.reason) return { status: 'invalid', reason: parsed.reason }
+  if (!parsed.input || !parsed.signature)
+    return { status: 'invalid', reason: 'The HTTP message signature is malformed.' }
+  const { input, signature } = parsed
+
+  if (!options.requiredComponents.every((component) => hasComponent(input.components, component)))
+    return {
+      status: 'invalid',
+      reason: 'The signature does not cover the required request components.',
+    }
+  const now = Math.floor(Date.now() / 1000)
+  if (input.created > now || input.expires <= now || input.expires - input.created > options.maxAge)
+    return { status: 'invalid', reason: 'The signature is expired or has an invalid lifetime.' }
+  if (options.validate) {
+    const reason = options.validate(input, request)
+    if (reason) return { status: 'invalid', reason }
+  }
+  let key: CryptoKey | undefined
+  try {
+    key = await options.keyResolver({
+      algorithm: input.algorithm,
+      keyId: input.keyId,
+      request,
+    })
+  } catch {
+    return { status: 'unverified', reason: 'The public key could not be resolved.' }
+  }
+  if (!key)
+    return {
+      status: 'unverified',
+      reason: 'No public key is available for the signature key ID.',
+    }
+  if (!keySupportsAlgorithm(key, input.algorithm))
+    return {
+      status: 'invalid',
+      reason: 'The public key does not support the signature algorithm.',
+    }
+  if (options.validateKey) {
+    const reason = await options.validateKey(key, input, request)
+    if (reason) return { status: 'invalid', reason }
+  }
+  let valid: boolean
+  try {
+    valid = await crypto.subtle.verify(
+      webCryptoAlgorithm(input.algorithm),
+      key,
+      toArrayBuffer(signature),
+      toArrayBuffer(encode(signatureBase(request, input))),
+    )
+  } catch {
+    valid = false
+  }
+  if (!valid) return { status: 'invalid', reason: 'The HTTP message signature is invalid.' }
+  try {
+    if (
+      !(await Store.tryClaim(
+        options.nonceStore,
+        `${options.nonceNamespace}:${input.keyId}:${input.nonce}`,
+        input.expires * 1000,
+      ))
+    )
+      return { status: 'invalid', reason: 'The signature nonce has already been used.' }
+  } catch {
+    return { status: 'unverified', reason: 'Replay protection is unavailable.' }
+  }
+  return { status: 'verified', input }
+}
+
+function parse(
+  request: Request,
+  expectedTag: string | readonly string[],
+): { input?: SignatureInput; reason?: string; signature?: Uint8Array } | undefined {
+  const inputHeader = request.headers.get(AttestationHeaders.signatureInput)
+  const signatureHeader = request.headers.get(AttestationHeaders.signature)
+  if (!inputHeader && !signatureHeader) return undefined
+  if (!inputHeader || !signatureHeader)
+    return { reason: 'Signature-Input and Signature must both be provided.' }
+  let inputs: Dictionary
+  let signatures: Dictionary
+  try {
+    inputs = parseDictionary(inputHeader)
+    signatures = parseDictionary(signatureHeader)
+  } catch {
+    return { reason: 'The HTTP message signature is malformed.' }
+  }
+  if (!haveSameKeys(inputs, signatures))
+    return { reason: 'Signature-Input and Signature do not contain the same labels.' }
+  const tags = new Set(typeof expectedTag === 'string' ? [expectedTag] : expectedTag)
+  for (const [label, entry] of inputs) {
+    if (!hasExpectedTag(entry, tags)) continue
+    const input = toSignatureInput(label, entry)
+    if (!input) return { reason: 'The HTTP message signature is malformed.' }
+    const signature = signatures.get(label)
+    if (!signature || isInnerList(signature) || !(signature[0] instanceof ArrayBuffer))
+      return { reason: 'No matching HTTP message signature was provided.' }
+    return { input, signature: new Uint8Array(signature[0]) }
+  }
+  return undefined
+}
+
+function serializeInput(input: SignatureInput): string {
+  return serializeInnerList(toInnerList(input))
+}
+
+function toInnerList(input: SignatureInput): InnerList {
+  const components: InnerList[0] = input.components.map((component) => [
+    component.id,
+    new Map(component.parameters),
+  ])
+  return [components, new Map(input.parameters)]
+}
+
+function toSignatureInput(label: string, entry: unknown): SignatureInput | undefined {
+  const innerList = entry as InnerList
+  if (!isInnerList(innerList)) return undefined
+  const [componentEntries, parameters] = innerList
+  if (
+    !componentEntries.length ||
+    !componentEntries.every(([component]) => typeof component === 'string')
+  )
+    return undefined
+  const components = componentEntries.map(([id, parameters]) => ({
+    id: id as string,
+    parameters,
+  }))
+  const created = parameters.get('created')
+  const expires = parameters.get('expires')
+  const algorithm = parameters.get('alg')
+  const keyId = parameters.get('keyid')
+  const nonce = parameters.get('nonce')
+  const tag = parameters.get('tag')
+  if (
+    !isInteger(created) ||
+    !isInteger(expires) ||
+    !isSignatureAlgorithm(algorithm) ||
+    typeof keyId !== 'string' ||
+    typeof nonce !== 'string' ||
+    typeof tag !== 'string'
+  )
+    return undefined
+  return {
+    algorithm,
+    components,
+    created,
+    expires,
+    keyId,
+    label,
+    nonce,
+    parameters,
+    tag,
+  }
+}
+
+function algorithmFromKey(key: CryptoKey): SignatureAlgorithm {
+  for (const algorithm of Object.values(Algorithms))
+    if (keySupportsAlgorithm(key, algorithm)) return algorithm
+  throw new TypeError('Request attestation requires an Ed25519 or RSA-PSS SHA-512 signing key.')
+}
+
+function isInteger(value: unknown): value is number {
+  return typeof value === 'number' && Number.isInteger(value)
+}
+
+function isSignatureAlgorithm(value: unknown): value is SignatureAlgorithm {
+  return typeof value === 'string' && Object.hasOwn(algorithmDescriptors, value)
+}
+
+function keySupportsAlgorithm(key: CryptoKey, algorithm: SignatureAlgorithm): boolean {
+  const { hash, keyAlgorithm } = algorithmDescriptors[algorithm]
+  return (
+    key.algorithm.name === keyAlgorithm &&
+    (!hash || (key.algorithm as RsaHashedKeyAlgorithm).hash.name === hash)
+  )
+}
+
+function webCryptoAlgorithm(algorithm: SignatureAlgorithm): AlgorithmIdentifier | RsaPssParams {
+  return algorithmDescriptors[algorithm].webCryptoAlgorithm
+}
+
+function signatureBase(request: Request, input: SignatureInput): string {
+  const lines = input.components.map(
+    (component) => `${serializeComponent(component)}: ${componentValue(request, component)}`,
+  )
+  lines.push(`"${Constants.components.signatureParams}": ${serializeInput(input)}`)
+  return lines.join('\n')
+}
+
+function componentValue(request: Request, component: Component): string {
+  const url = new URL(request.url)
+  if (component.id === Constants.components.authority) {
+    if (component.parameters?.size) throw new Error('Unsupported parameters for "@authority".')
+    return url.host
+  }
+  if (component.id === Constants.components.path) {
+    if (component.parameters?.size) throw new Error('Unsupported parameters for "@path".')
+    return url.pathname
+  }
+  if (component.parameters?.size)
+    return componentDictionaryValue(request, component.id, component.parameters)
+  const value = request.headers.get(component.id)
+  if (value === null) throw new Error(`Missing signed HTTP header "${component.id}".`)
+  // RFC 9421 signs the serialized field value, not a Unicode-normalized string.
+  if (!/^[\x20-\x7e]*$/.test(value))
+    throw new Error(`Signed HTTP header "${component.id}" is not ASCII.`)
+  return value
+}
+
+function componentDictionaryValue(
+  request: Request,
+  component: string,
+  parameters: ReadonlyMap<string, BareItem>,
+): string {
+  const key = parameters.get('key')
+  if (typeof key !== 'string' || parameters.size !== 1)
+    throw new Error(`Unsupported parameters for signed HTTP header "${component}".`)
+  const value = request.headers.get(component)
+  if (value === null) throw new Error(`Missing signed HTTP header "${component}".`)
+  let dictionary: Dictionary
+  try {
+    dictionary = parseDictionary(value)
+  } catch {
+    throw new Error(`Signed HTTP header "${component}" is not a structured dictionary.`)
+  }
+  const member = dictionary.get(key)
+  if (!member || isInnerList(member))
+    throw new Error(`Signed HTTP header "${component}" has no member "${key}".`)
+  return serializeItem(member)
+}
+
+function hasComponent(components: readonly Component[], expected: string): boolean {
+  return components.some((component) => component.id === expected)
+}
+
+function haveSameKeys(left: Dictionary, right: Dictionary): boolean {
+  return left.size === right.size && [...left.keys()].every((key) => right.has(key))
+}
+
+function hasExpectedTag(entry: unknown, tags: ReadonlySet<string>): boolean {
+  const value = entry as Item | InnerList
+  if (!isInnerList(value)) return false
+  const tag = value[1].get('tag')
+  return typeof tag === 'string' && tags.has(tag)
+}
+
+function serializeComponent(component: Component): string {
+  return `"${component.id}"${component.parameters?.size ? serializeParameters(new Map(component.parameters)) : ''}`
+}
+
+function toComponent(component: ComponentInput): Component {
+  return typeof component === 'string'
+    ? { id: component }
+    : { id: component.id, parameters: component.parameters && new Map(component.parameters) }
+}
+
+function parseHeaderDictionary(headers: Headers, name: string): Dictionary {
+  const value = headers.get(name)
+  if (!value) return new Map()
+  try {
+    return parseDictionary(value)
+  } catch {
+    throw new Error(`HTTP header "${name}" is not a structured dictionary.`)
+  }
+}
+
+function encode(value: string): Uint8Array {
+  return new TextEncoder().encode(value)
+}
+
+function toArrayBuffer(value: Uint8Array): ArrayBuffer {
+  return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength) as ArrayBuffer
+}

package/src/attestation/internal/SigningContext.ts

@@ -0,0 +1,13 @@
+import { Base64 } from 'ox'
+
+import type * as Types from '../Types.js'
+
+/** Creates the signing context for one outbound HTTP request attempt. */
+export function create(): Types.SigningContext {
+  const bytes = new Uint8Array(64)
+  crypto.getRandomValues(bytes)
+  return Object.freeze({
+    created: Math.floor(Date.now() / 1_000),
+    nonce: Base64.fromBytes(bytes, { pad: false, url: true }),
+  })
+}

package/src/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/bin.js'

package/src/cli/cli.ts

@@ -212,6 +212,7 @@ function findService(
 }
 
 const cli = Cli.create('mppx', {
+  mcp: { tools: { discovery: 'direct' } },
   version: packageJson.version,
   description: 'Make HTTP requests with automatic payment handling',
   usage: [{ suffix: '<url> [options]' }],

package/src/cli/validate/payment.ts

@@ -46,6 +46,20 @@ async function provisionAndPayTestnet(
     await Promise.all(hashes.map((hash) => waitForTransactionReceipt(client, { hash })))
     if (!silent) console.log(pc.dim(`    Using wallet: ${account.address}`))
 
+    // The faucet tx receipt can land before the RPC's balance reads are
+    // consistent with it, so poll briefly for the funded balance to appear
+    // rather than racing straight into the charge.
+    const currency = (challenge.request as Record<string, unknown>).currency
+    if (typeof currency === 'string') {
+      for (let attempt = 0; attempt < 10; attempt++) {
+        const balance = await Actions.token
+          .getBalance(client, { account: account.address, token: currency as Address })
+          .catch(() => undefined)
+        if (balance && balance.amount > 0n) break
+        await new Promise((resolve) => setTimeout(resolve, 500))
+      }
+    }
+
     const methods = [...tempoMethods({ account })]
     return { methods }
   } catch (error) {
@@ -198,7 +212,7 @@ export async function validatePaymentFlow(
         const mppx = Mppx.create({ methods: provisioned.methods, polyfill: false })
         const cred = await mppx.createCredential(fakeResp)
         results.push(check('Payment: submitted', 'ephemeral testnet wallet'))
-        return await sendAndValidateResponse(
+        await sendAndValidateResponse(
           results,
           url,
           endpoint,
@@ -210,17 +224,17 @@ export async function validatePaymentFlow(
         )
       } catch (error) {
         results.push(fail('Payment: create credential', (error as Error).message))
-        return results
       }
     } else {
       results.push(
         fail('Payment: auto-provision wallet', 'Failed to create and fund testnet wallet'),
       )
-      return results
     }
+    options.onResults?.(results)
   }
 
-  // Try each challenge method (skip testnet challenge already handled above)
+  // Try each remaining challenge method (tempo testnet already handled above),
+  // so validate exercises every payment method the server offers, same as mainnet.
   const loaded = await loadConfig().catch(() => undefined)
   const isInteractive = options.interactive
   const stripeKey = process.env.MPPX_STRIPE_SECRET_KEY ?? resolveStripeKey(verbose)

package/src/cli/validate.test.ts

@@ -707,6 +707,22 @@ describe('validate: multi-challenge', () => {
     const { output } = await serve(['validate', server.url])
     expect(output).toContain('Amount is valid integer string (Got: 1.50)')
   })
+
+  test("tempo doesn't block other testnet methods", { timeout: 15_000 }, async () => {
+    // makeChallenge() defaults to a tempo testnet challenge (chainId 42431),
+    // which takes the ephemeral-wallet fast path. That path used to return
+    // immediately, so a server offering evm/stripe alongside tempo would
+    // never have those methods exercised. It should now fall through and
+    // try them too, same as it does for tempo mainnet challenges.
+    const server = await multiChallengeServer([makeChallenge(), makeEvmChallenge()])
+    const { output } = await serve(['validate', server.url, '--outputJson', '--yes'])
+    const jsonStart = output.indexOf('{')
+    const jsonEnd = output.lastIndexOf('}')
+    const result = JSON.parse(output.slice(jsonStart, jsonEnd + 1))
+    const paymentLabels = result.endpoints[0].payment.map((r: { label: string }) => r.label)
+    expect(paymentLabels).toContain('Payment: submitted')
+    expect(paymentLabels.some((l: string) => l.includes('[evm]'))).toBe(true)
+  })
 })
 
 describe('validate: payment methods coverage', () => {

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

@@ -1,6 +1,7 @@
 import type { Account, Address } from 'viem'
 import { describe, expectTypeOf, test } from 'vp/test'
 
+import type * as Attestation from '../attestation/Types.js'
 import * as Challenge from '../Challenge.js'
 import type * as Mcp from '../Mcp.js'
 import * as Method from '../Method.js'
@@ -73,6 +74,22 @@ describe('create.Config', () => {
     expectTypeOf(mppx.fetch).toBeFunction()
   })
 
+  test('accepts request attestation for HTTP transport only', () => {
+    const signer = {} as Attestation.Signer
+    const mppx = Mppx.create({
+      attestation: { webBotAuth: signer },
+      methods: [charge()],
+    })
+    expectTypeOf(mppx.fetch).toBeFunction()
+
+    Mppx.create({
+      // @ts-expect-error request attestation applies to HTTP transport only.
+      attestation: { webBotAuth: signer },
+      methods: [charge()],
+      transport: Transport.mcp(),
+    })
+  })
+
   test('paymentPreferences callback exposes typed method keys', () => {
     const mppx = Mppx.create({
       methods: [tempo({ account: {} as Account })],

package/src/client/Mppx.test.ts

@@ -151,29 +151,29 @@ describe('createCredential', () => {
     })
   }
 
-  test('behavior: routes duplicate tempo/session client methods by sessionProtocol', async () => {
-    const tip1034 = taggedSessionMethod(
-      'v2',
+  test('behavior: routes duplicate tempo/session client methods by challenge predicate', async () => {
+    const primary = taggedSessionMethod(
+      'primary',
       ({ challenge }) =>
         (challenge.request.methodDetails as { sessionProtocol?: string } | undefined)
-          ?.sessionProtocol === 'v2',
+          ?.sessionProtocol === 'primary',
     )
-    const legacy = taggedSessionMethod('v1', ({ challenge }) => {
+    const fallback = taggedSessionMethod('fallback', ({ challenge }) => {
       const sessionProtocol = (
         challenge.request.methodDetails as { sessionProtocol?: string } | undefined
       )?.sessionProtocol
-      return sessionProtocol === undefined || sessionProtocol === 'v1'
+      return sessionProtocol === undefined || sessionProtocol === 'fallback'
     })
-    const mppx = Mppx.create({ polyfill: false, methods: [tip1034, legacy] })
+    const mppx = Mppx.create({ polyfill: false, methods: [primary, fallback] })
 
-    const [newCredential, legacyCredential, oldCredential] = await Promise.all([
-      mppx.createCredential(paymentRequiredResponse(sessionChallenge('new', 'v2'))),
-      mppx.createCredential(paymentRequiredResponse(sessionChallenge('v1', 'v1'))),
-      mppx.createCredential(paymentRequiredResponse(sessionChallenge('old'))),
+    const [primaryCredential, fallbackCredential, unmarkedCredential] = await Promise.all([
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('primary', 'primary'))),
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('fallback', 'fallback'))),
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('unmarked'))),
     ])
-    expect(Credential.deserialize(newCredential).payload).toEqual({ tag: 'v2' })
-    expect(Credential.deserialize(legacyCredential).payload).toEqual({ tag: 'v1' })
-    expect(Credential.deserialize(oldCredential).payload).toEqual({ tag: 'v1' })
+    expect(Credential.deserialize(primaryCredential).payload).toEqual({ tag: 'primary' })
+    expect(Credential.deserialize(fallbackCredential).payload).toEqual({ tag: 'fallback' })
+    expect(Credential.deserialize(unmarkedCredential).payload).toEqual({ tag: 'fallback' })
   })
 
   test('behavior: rejects unknown tempo/session sessionProtocol', async () => {

package/src/client/Mppx.ts

@@ -1,3 +1,5 @@
+import * as AttestationClient from '../attestation/Client.js'
+import type * as Attestation from '../attestation/Types.js'
 import type * as Challenge from '../Challenge.js'
 import * as Expires from '../Expires.js'
 import * as AcceptPayment from '../internal/AcceptPayment.js'
@@ -100,6 +102,7 @@ export function create<
   >,
 >(config: create.Config<methods, transport>): Mppx<methods, transport> {
   const {
+    attestation,
     maxPaymentRetries,
     onChallenge,
     orderChallenges,
@@ -111,6 +114,9 @@ export function create<
   } = config
 
   const rawFetch = config.fetch ?? globalThis.fetch
+  const attestedFetch = attestation
+    ? createAttestedFetch(rawFetch, attestation as Attestation.SignerMap)
+    : rawFetch
   const methods = config.methods.flat() as unknown as FlattenMethods<methods>
   const acceptPayment = AcceptPayment.resolve(methods, config.paymentPreferences)
   const events = Fetch.createEventDispatcher<FlattenMethods<methods>, EventResponseOf<transport>>()
@@ -121,7 +127,7 @@ export function create<
   const config_fetch = {
     acceptPayment,
     acceptPaymentPolicy,
-    ...(config.fetch && { fetch: config.fetch }),
+    ...((config.fetch || attestation) && { fetch: attestedFetch }),
     eventDispatcher: events,
     ...(maxPaymentRetries !== undefined && { maxPaymentRetries }),
     ...(resolvedOnChallenge && { onChallenge: resolvedOnChallenge }),
@@ -188,9 +194,7 @@ export function create<
       context?: unknown,
       options?: createCredential.Options<FlattenMethods<methods>>,
     ) {
-      const challenges = transport.getChallenges
-        ? await transport.getChallenges(response as never)
-        : [await transport.getChallenge(response as never)]
+      const challenges = await transport.getChallenges(response as never)
       const preferences = resolveChallengePreferences(acceptPayment.entries, options?.acceptPayment)
 
       let challenge: Challenge.Challenge | undefined
@@ -287,6 +291,10 @@ export declare namespace create {
     methods extends Methods = Methods,
     transport extends Transport.AnyTransport = Transport.Transport,
   > = {
+    /** Request-attestation signers applied to every outbound HTTP attempt. */
+    attestation?: transport extends Transport.Transport<RequestInit, Response>
+      ? Attestation.SignerMap | undefined
+      : never
     /** Controls when `Accept-Payment` is injected. */
     acceptPaymentPolicy?: Fetch.from.Config['acceptPaymentPolicy'] | undefined
     /** Custom fetch function to wrap. Defaults to `globalThis.fetch`. */
@@ -315,6 +323,19 @@ export declare namespace create {
   }
 }
 
+function createAttestedFetch(
+  fetch: typeof globalThis.fetch,
+  signers: Attestation.SignerMap,
+): typeof globalThis.fetch {
+  const values = Object.values(signers)
+  if (values.length === 0)
+    throw new TypeError('Mppx client attestation must configure at least one signer.')
+  return AttestationClient.wrapFetch(
+    fetch,
+    AttestationClient.composeSigners(...(values as [Attestation.Signer, ...Attestation.Signer[]])),
+  )
+}
+
 /**
  * Union of all context types from all methods that have context schemas.
  * @internal