mppx 0.8.15 → 0.8.18

package/CHANGELOG.md

@@ -1,5 +1,96 @@
 # mppx
 
+## 0.8.18
+
+### Patch Changes
+
+- 61f847e: Added first-party machine-token payments for Tempo charges across push, pull, relay, and fee-sponsored settlement.
+- 981389d: Changed Stripe PaymentIntent idempotency keys to use the SDK-independent `mpp_` prefix.
+- adcf3b5: Normalized Tempo transactions before broadcast so accepted recovery ID encodings matched the node's canonical transaction hash.
+- e59c031: Added support for composing native claim implementations with Redis and Upstash store adapters.
+- 349543a: Added CI interoperability coverage against the Coinbase x402 resource server and facilitator implementations.
+- 4915654: Bundled the CLI runtime and removed source files, source maps, and source export conditions from the published package.
+- 9774481: Fixed deserialization of challenges with mixed-case auth-param names.
+- e240845: Fixed explicit session stream charges being discarded by prepaid units.
+- bc3c626: `stripe.create()`: `defaultMethods()` now returns sync SPT-only when no `depositAddresses` is provided, and uses `Promise.allSettled` in the function resolver path to gracefully degrade when individual networks fail.
+- c004d2c: Fixed hosted fee-payer sponsorship for server-driven session settlement and close transactions.
+- dc27415: Added lightweight core server and Stripe SPT entrypoints that excluded unrelated payment rails.
+- 3fd4a16: Added implicit machine-token funding to Tempo sessions and moved Tempo charges and sessions to the unified machineUSD deployment. Clients use machineUSD when a verified route and sufficient balance are available and otherwise pay the challenged token. Configured fee-token overrides were bound into session challenges, and concurrent session requests rechecked top-up requirements after serialized opens.
+- a85d55a: Hardened machine-token session flows after #800: kept stored machine channels instead of evicting them on failed retries, advertised close snapshots for signature-verified close credentials, accepted sponsored fees in the payment currency alongside a configured `feeToken`, and restored balance-aware fee-token selection for direct-channel settlement.
+- 106ba18: Fixed challenge parsing for extension parameters named after `Object.prototype` properties.
+- a74b20b: Discovery: unknown fields next to `offers` in `x-payment-info` are ignored instead of failing validation (only the spec-defined flat fields conflict with `offers`).
+- b5f6bce: Removed obsolete MPP version metadata from Stripe charge PaymentIntents.
+- 3de6560: Required server-advertised Tempo session escrows to match the canonical address unless clients enable `allowCustomEscrow`.
+- 4c9ce16: Added client signing support for standard x402 exact EIP-3009 offers without requiring mppx route-binding extensions.
+- c326dc9: Fixed Tempo session fallback closes with stale receipts and rejected invalid close accounting.
+- 81ba763: Escape characters above Latin-1 in challenge auth-params so serialized challenges are always valid HTTP header values. Previously a charge `description` containing an em dash, smart quote, or emoji made `Response` construction throw (`Cannot convert argument to a ByteString`) in fetch-compliant runtimes when the challenge was written to the `WWW-Authenticate` header.
+- ae68a55: Fixed scoped EVM charges rejecting every spec-compliant x402 client, which made
+  each route served through `Proxy` unpayable over x402.
+
+  A route scope lands in `challenge.meta`, and the x402 path treated any route
+  metadata as a demand for mppx's own `extensions.mppx` binding plus an EIP-3009
+  nonce equal to an unexported `sha256(accepted | resource | extensions)`. That
+  derivation is not part of the x402 spec, so a client mppx did not write cannot
+  produce it: the charge re-challenged forever with `Credential is malformed.`
+  `Proxy` attaches a derived scope to every charge it serves, so this applied to
+  everything behind it whether or not an operator set `scope`.
+
+  Such a credential is now bound the way x402 itself binds — by comparing the
+  echoed `resource` and `accepted` — instead of being rejected. A credential that
+  does carry `extensions.mppx` is still verified in full, including the
+  route-bound nonce, so mppx's own client is unaffected. Body binding is unchanged:
+  `challenge.digest` is verified against the request body either way.
+
+  The trade is that route scope on the x402 rail is advisory for clients that don't
+  implement mppx's binding. `resource` and `accepted` sit outside the EIP-3009
+  signature, so two charges sharing a URL and a price are no longer distinguishable
+  by scope alone. Cross-URL reuse is still refused. Operators who need scope
+  enforced can restore the previous behaviour per method:
+
+  ```ts
+  evm({
+    currency: evm.assets.base.USDC,
+    recipient,
+    x402: { facilitator, routeBinding: 'required' },
+  })
+  ```
+
+## 0.8.17
+
+### Patch Changes
+
+- 52d8701: Reject sub-cent amounts via `canOffer` before issuing 402 challenge on stripe-managed crypto rails. Add `metadata` parameter to `stripe.create()` for forwarding key-value pairs to Stripe PaymentIntents.
+- b7ab48e: Changed Tempo relay idempotency keys to use the `mpp_` prefix.
+
+## 0.8.16
+
+### Patch Changes
+
+- c58ee80: Added composable TAP and Web Bot Auth HTTPS-directory profile signers and verifiers with Ed25519 and RSA-PSS SHA-512 support, explicit replay storage, typed verification outcomes, and shared per-attempt signing context.
+- 1d7749a: Added first-class client and server request-attestation configuration to `Mppx.create()`.
+- e2b2a8a: Removed the legacy Tempo session server implementation and server compatibility exports while retaining the v1 client for existing sessions. See the [session upgrade guide](https://mpp.dev/blog/sessions-improved) for migration instructions.
+- 4637603: Aligned published and workspace dependency versions with shared pnpm catalog pins.
+- 4834ef1: Added configurable upstream error recovery hooks to proxy services and preserved request bodies across retries.
+- 00b0063: Fix js-yaml audit vulnerability (CVE-2026-59870) by bumping override to 4.3.1.
+- 81a5c6b: Fix `Method.toServer()` to pass through `onPaymentSuccess` from options.
+- f7f8e58: Fixed multi-challenge parsing when quoted parameter values contained the Payment scheme name.
+- 8e370ba: Added structured sponsor budget configuration and support for externally enforced sponsor budgets.
+- 40f430a: Multi-method intent handler: `.charge()` now works when multiple methods share an intent, internally composing all matching methods into one handler that respects `selectOffers`.
+- 1272520: Disabled the `no-underscore-dangle` lint rule.
+- 5ff5cb7: Fixed equality checks between equivalent hex and Tempo-formatted addresses.
+- 71b8884: Add per-method `onPaymentSuccess` hook to `ComposableHooks`. Routed through the server event dispatcher for error isolation.
+- 641aa4d: Kept discovery metadata aligned with runtime challenges by preserving composed offers, dispatching nested compositions, and deriving prices from canonical payment requests.
+- cd71f9e: Made attestation verifiers accept the core `AtomicStore` directly and shared its optimized `Store.tryClaim` replay primitive with Tempo charges.
+- f3a9369: Updated production dependencies.
+- 3d7ed4b: Removed obsolete compatibility shims for legacy viem Tempo call builders.
+- 47d6df7: Added server- and method-level filtering with immutable snapshots for composed HTTP payment offers across every server method constructor, including Stripe currency minimums.
+- 30f8a12: Added a session-bound WebSocket server helper that reused the configured store and settlement policy, and applied that policy to plain HTTP responses from SSE-enabled methods. Fixed automatic settlement schedules after committed Tempo session SSE and WebSocket charges.
+- 9f0afe0: Added a stable CLI launcher for workspace dependency installation.
+- bdaea3a: Standardized client transports on `getChallenges` and removed the singular `getChallenge` hook.
+- 4b3b1c0: Add `stripe.create()` machine payments API with auto deposit address resolution, PI recording, and unified `.charge()` handler.
+- fd38304: Added non-mutating credential validation and broadcast hooks to the Tempo session server method.
+- 8f9f8cb: Fixed body-bearing EVM routes to advertise `PAYMENT-REQUIRED` alongside MPP challenges and accept standard x402 payments when mppx route binding is not required.
+
 ## 0.8.15
 
 ### Patch Changes

package/README.md

@@ -52,6 +52,7 @@ const mppx = Mppx.create({
   methods: [
     tempo({
       currency: '0x20c0000000000000000000000000000000000000',
+      machineTokenEnabled: true,
       recipient: '0x742d35Cc6634c0532925a3b844bC9e7595F8fE00',
     }),
   ],
@@ -83,6 +84,11 @@ Mppx.create({
 const res = await fetch('https://mpp.dev/api/ping/paid')
 ```
 
+The client API is the same for PathUSD, USDC.e, and machineUSD. A server advertises
+`machineTokenEnabled`; the client uses machineUSD when a verified route and sufficient balance
+are available, and otherwise pays the token requested by the challenge. Sessions keep the selected
+rail until the channel closes.
+
 ## Examples
 
 | Example                                                | Description                                          |
@@ -117,11 +123,20 @@ mppx sessions list
 mppx sessions view <channel-id>
 mppx sessions close <channel-id>
 mppx sessions close --all --yes
+
+# explicitly trust a custom session escrow advertised by the server
+mppx example.com -M allowCustomEscrow=true
 ```
 
 `--session auto` is the default. Pass `new` to open another channel or a channel ID to select one
 explicitly.
 
+Tempo session clients accept only the canonical escrow contract by default. A server may advertise
+its configured custom escrow in the payment challenge, but the client rejects it unless
+`-M allowCustomEscrow=true` is supplied. This opt-in trusts the server-selected address; clients
+that do not support custom escrows should leave it unset. See the
+[session escrow trust documentation](./src/tempo/session/README.md#escrow-configuration-and-trust).
+
 You can also install globally to use the `mppx` CLI from anywhere:
 
 ```bash

package/dist/Challenge.js

@@ -180,7 +180,15 @@ export function serialize(challenge) {
 function authParam(name, value) {
     if (/[\r\n]/.test(value))
         throw new Error('Invalid quoted-string value.');
-    return `${name}="${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+    const escaped = value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        // Header values must be ByteStrings (code points ≤ 0xFF): escape anything
+        // above Latin-1 (em dashes, smart quotes, emoji in descriptions) so the
+        // serialized challenge is always a legal header value instead of crashing
+        // Response construction.
+        .replace(/[\u0100-\uffff]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`);
+    return `${name}="${escaped}"`;
 }
 /**
  * Deserializes a WWW-Authenticate header value to a challenge.
@@ -220,38 +228,17 @@ export function deserialize(value, options) {
 /** @internal Extracts the `Payment` scheme from a WWW-Authenticate value that may contain multiple schemes. */
 function extractPaymentAuthParams(header) {
     const token = Constants.Schemes.payment;
-    let inQuotes = false;
-    let escaped = false;
-    for (let i = 0; i < header.length; i++) {
-        const char = header[i];
-        if (inQuotes) {
-            if (escaped)
-                escaped = false;
-            else if (char === '\\')
-                escaped = true;
-            else if (char === '"')
-                inQuotes = false;
-            continue;
-        }
-        if (char === '"') {
-            inQuotes = true;
-            continue;
-        }
-        if (!startsWithSchemeToken(header, i, token))
-            continue;
-        const prefix = header.slice(0, i);
-        if (prefix.trim() && !prefix.trimEnd().endsWith(','))
-            continue;
-        let paramsStart = i + token.length;
-        while (paramsStart < header.length && /\s/.test(header[paramsStart] ?? ''))
-            paramsStart++;
-        return header.slice(paramsStart);
-    }
-    return null;
+    const [start] = findSchemeStarts(header, token);
+    if (start === undefined)
+        return null;
+    let paramsStart = start + token.length;
+    while (paramsStart < header.length && /\s/.test(header[paramsStart] ?? ''))
+        paramsStart++;
+    return header.slice(paramsStart);
 }
 /** @internal Parses auth-params with support for escaped quoted-string values. */
 function parseAuthParams(input) {
-    const result = {};
+    const result = Object.create(null);
     let i = 0;
     while (i < input.length) {
         while (i < input.length && /[\s,]/.test(input[i] ?? ''))
@@ -261,7 +248,7 @@ function parseAuthParams(input) {
         const keyStart = i;
         while (i < input.length && /[A-Za-z0-9_-]/.test(input[i] ?? ''))
             i++;
-        const key = input.slice(keyStart, i);
+        const key = input.slice(keyStart, i).toLowerCase();
         if (!key)
             throw new Error('Malformed auth-param.');
         while (i < input.length && /\s/.test(input[i] ?? ''))
@@ -300,7 +287,16 @@ function readQuotedAuthParamValue(input, start) {
         i++;
         if (escaped) {
             parts ??= [];
-            parts.push(char);
+            // `\\uXXXX` unescapes characters above Latin-1. Unambiguous: serializers
+            // always double raw backslashes, so a bare `\\u` only ever comes from
+            // the unicode escape in `authParam`.
+            const hex = char === 'u' ? input.slice(i, i + 4) : undefined;
+            if (hex && /^[0-9A-Fa-f]{4}$/.test(hex)) {
+                parts.push(String.fromCharCode(Number.parseInt(hex, 16)));
+                i += 4;
+            }
+            else
+                parts.push(char);
             segmentStart = i;
             escaped = false;
             continue;
@@ -323,11 +319,42 @@ function readQuotedAuthParamValue(input, start) {
 }
 /** @internal */
 function startsWithSchemeToken(value, index, token) {
-    if (!value.slice(index).toLowerCase().startsWith(token.toLowerCase()))
+    if (value.slice(index, index + token.length).toLowerCase() !== token.toLowerCase())
         return false;
     const next = value[index + token.length];
     return Boolean(next && /\s/.test(next));
 }
+/** @internal Finds auth scheme boundaries while ignoring quoted-string contents. */
+function findSchemeStarts(value, token) {
+    const starts = [];
+    let inQuotes = false;
+    let escaped = false;
+    for (let i = 0; i < value.length; i++) {
+        const char = value[i];
+        if (inQuotes) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === '"')
+                inQuotes = false;
+            continue;
+        }
+        if (char === '"') {
+            inQuotes = true;
+            continue;
+        }
+        if (!startsWithSchemeToken(value, i, token))
+            continue;
+        let boundary = i - 1;
+        while (boundary >= 0 && /\s/.test(value[boundary] ?? ''))
+            boundary--;
+        if (boundary >= 0 && value[boundary] !== ',')
+            continue;
+        starts.push(i);
+    }
+    return starts;
+}
 /**
  * Extracts the challenge from a Headers object.
  *
@@ -422,12 +449,7 @@ export function fromHeadersList(headers, options) {
  * @returns An array of deserialized challenges.
  */
 export function deserializeList(value, options) {
-    // Find the start index of each `Payment ` scheme prefix.
-    const starts = [];
-    const schemePattern = new RegExp(`${Constants.Schemes.payment}\\s+`, 'gi');
-    for (const match of value.matchAll(schemePattern)) {
-        starts.push(match.index);
-    }
+    const starts = findSchemeStarts(value, Constants.Schemes.payment);
     if (starts.length === 0)
         throw new Error('No Payment schemes found.');
     // Slice each scheme from its `Payment ` prefix up to the next scheme boundary,

package/dist/Constants.d.ts

@@ -1,39 +1,39 @@
 /** HTTP header names used by the Payment authentication scheme. */
 export declare const Headers: {
-    readonly acceptPayment: "Accept-Payment";
-    readonly authorization: "Authorization";
-    readonly paymentReceipt: "Payment-Receipt";
-    readonly paymentSession: "Payment-Session";
-    readonly paymentSessionSnapshot: "Payment-Session-Snapshot";
-    readonly wwwAuthenticate: "WWW-Authenticate";
+    readonly acceptPayment: 'Accept-Payment';
+    readonly authorization: 'Authorization';
+    readonly paymentReceipt: 'Payment-Receipt';
+    readonly paymentSession: 'Payment-Session';
+    readonly paymentSessionSnapshot: 'Payment-Session-Snapshot';
+    readonly wwwAuthenticate: 'WWW-Authenticate';
 };
 /** Authentication scheme names used by mppx transports. */
 export declare const Schemes: {
-    readonly payment: "Payment";
+    readonly payment: 'Payment';
 };
 /** Payment method names used by built-in mppx methods. */
 export declare const Methods: {
-    readonly evm: "evm";
-    readonly stripe: "stripe";
-    readonly tempo: "tempo";
+    readonly evm: 'evm';
+    readonly stripe: 'stripe';
+    readonly tempo: 'tempo';
 };
 /** Payment intent names used by built-in mppx methods. */
 export declare const Intents: {
-    readonly charge: "charge";
-    readonly session: "session";
-    readonly subscription: "subscription";
+    readonly charge: 'charge';
+    readonly session: 'session';
+    readonly subscription: 'subscription';
 };
 /** Method detail object keys used by built-in methods. */
 export declare const MethodDetailKeys: {
-    readonly sessionProtocol: "sessionProtocol";
-    readonly sessionSnapshot: "sessionSnapshot";
+    readonly sessionProtocol: 'sessionProtocol';
+    readonly sessionSnapshot: 'sessionSnapshot';
 };
 /** Tempo session protocol versions advertised under `request.methodDetails`. */
 export declare const SessionProtocols: {
     /** Legacy contract-backed Tempo session protocol. */
-    readonly v1: "v1";
+    readonly v1: 'v1';
     /** TIP-1034 precompile-backed Tempo session protocol. */
-    readonly v2: "v2";
+    readonly v2: 'v2';
 };
 /** Known Tempo session protocol version markers. */
 export type SessionProtocol = (typeof SessionProtocols)[keyof typeof SessionProtocols];

package/dist/Errors.d.ts

@@ -1,8 +1,8 @@
 /** Default hint messages for payment errors. */
 export declare const Hints: {
-    readonly paymentRequired: "Use a supported wallet to pay for this resource using one of the supported payment methods returned in the WWW-Authenticate header. See https://mpp.dev/tools/wallet.md";
-    readonly malformedCredential: "Use a supported wallet to construct valid credentials for one of the supported payment methods returned in the WWW-Authenticate header. See https://mpp.dev/tools/wallet.md";
-    readonly methodUnsupported: "Use a supported wallet to pay for this resource using one of the supported payment methods returned in the WWW-Authenticate header. See https://mpp.dev/tools/wallet.md";
+    readonly paymentRequired: 'Use a supported wallet to pay for this resource using one of the supported payment methods returned in the WWW-Authenticate header. See https://mpp.dev/tools/wallet.md';
+    readonly malformedCredential: 'Use a supported wallet to construct valid credentials for one of the supported payment methods returned in the WWW-Authenticate header. See https://mpp.dev/tools/wallet.md';
+    readonly methodUnsupported: 'Use a supported wallet to pay for this resource using one of the supported payment methods returned in the WWW-Authenticate header. See https://mpp.dev/tools/wallet.md';
 };
 /**
  * Base class for all payment-related errors.

package/dist/Method.d.ts

@@ -1,6 +1,6 @@
 import type * as Challenge from './Challenge.js';
 import * as Credential from './Credential.js';
-import type { ExactPartial, LooseOmit, MaybePromise } from './internal/types.js';
+import type { DeepReadonly, ExactPartial, LooseOmit, MaybePromise } from './internal/types.js';
 import type * as Receipt from './Receipt.js';
 import type * as Html from './server/internal/html/config.js';
 import type * as Transport from './server/Transport.js';
@@ -142,7 +142,7 @@ export type Validation<method extends Method = Method, details = unknown> = Read
 /**
  * A server-side configured method with verification logic.
  */
-export type Server<method extends Method = Method, defaults extends ExactPartial<z.input<method['schema']['request']>> = {}, transportOverride = undefined, extensions extends object = {}, alias extends string | undefined = string | undefined> = method & {
+export type Server<method extends Method = Method, defaults extends ExactPartial<z.input<method['schema']['request']>> = {}, transportOverride = undefined, extensions extends object = {}, alias extends string | undefined = string | undefined> = method & ComposableHooks<method> & {
     alias?: alias | undefined;
     authorize?: AuthorizeFn<method> | undefined;
     defaults?: defaults | undefined;
@@ -163,6 +163,38 @@ export type Server<method extends Method = Method, defaults extends ExactPartial
     verify: VerifyFn<method>;
 };
 export type AnyServer = Server<any, any, any, any, any>;
+/**
+ * Decides whether a configured method offer is available for an HTTP request.
+ *
+ * Called once per configured offer during composition. The payment request is
+ * schema-normalized and deeply immutable. `input` is cloned so its body can be
+ * safely inspected unless the upstream body was already consumed or locked, in
+ * which case the clone preserves request metadata without a body. Returning
+ * `false` removes only this method's offer. Successfully matched credential
+ * dispatch does not invoke this hook.
+ */
+export type CanOfferFn<method extends Method> = (parameters: {
+    input: globalThis.Request;
+    request: DeepReadonly<z.output<method['schema']['request']>>;
+}) => MaybePromise<boolean>;
+/** Hooks supported by every composable server method constructor. */
+/**
+ * Optional per-method hook invoked after a payment succeeds.
+ *
+ * Called after verification completes successfully. Use this for side-effects
+ * like recording the payment in an external system.
+ */
+export type OnPaymentSuccessFn<method extends Method> = (parameters: {
+    input?: globalThis.Request;
+    receipt: DeepReadonly<Receipt.Receipt>;
+    request: DeepReadonly<z.output<method['schema']['request']>>;
+}) => MaybePromise<void>;
+export type ComposableHooks<method extends Method> = {
+    /** Decides whether this method's configured offer is available for an HTTP request. */
+    canOffer?: CanOfferFn<method> | undefined;
+    /** Invoked after a successful payment on this method. */
+    onPaymentSuccess?: OnPaymentSuccessFn<method> | undefined;
+};
 /** Credential creation function for a single method. */
 export type CreateCredentialFn<method extends Method, context = unknown> = (parameters: {
     challenge: Challenge.Challenge<z.output<method['schema']['request']>, method['intent'], method['name']>;
@@ -252,8 +284,6 @@ export declare function validateCredential<const methods extends readonly AnySer
  * hosts that issue challenges must verify that binding separately.
  */
 export declare function broadcastCredential<const methods extends readonly AnyServer[]>(methods: methods, input: string | Credential.Credential): Promise<Receipt.Receipt>;
-/** @internal */
-export declare function selectServerMethod(methods: readonly AnyServer[], challenge: Challenge.Challenge): AnyServer | undefined;
 /**
  * Optional respond function for a server-side method.
  *
@@ -318,7 +348,7 @@ export declare namespace toServer {
     type Alias<options> = options extends {
         alias: infer alias extends string;
     } ? alias : undefined;
-    type Options<method extends Method, defaults extends RequestDefaults<method> = {}, transportOverride extends Transport.AnyTransport | undefined = undefined, extensions extends object = {}, alias extends string | undefined = undefined> = {
+    type Options<method extends Method, defaults extends RequestDefaults<method> = {}, transportOverride extends Transport.AnyTransport | undefined = undefined, extensions extends object = {}, alias extends string | undefined = undefined> = ComposableHooks<method> & {
         alias?: alias | undefined;
         authorize?: AuthorizeFn<method> | undefined;
         defaults?: defaults | undefined;

package/dist/Method.js

@@ -1,4 +1,3 @@
-import * as Constants from './Constants.js';
 import * as Credential from './Credential.js';
 import * as Errors from './Errors.js';
 import * as Expires from './Expires.js';
@@ -68,11 +67,9 @@ export async function broadcastCredential(methods, input) {
 /**
  * Parses a submitted credential into the inputs required for method execution.
  *
- * Dispatch is based on the challenge method and intent. When more than one
- * server method handles the same wire identity, session protocol details select
- * the appropriate implementation. The helper then asserts challenge expiry and
- * parses the method-specific credential payload before returning the selected
- * method and the unmodified challenge request.
+ * Dispatch is based on the challenge method and intent. The helper then asserts
+ * challenge expiry and parses the method-specific credential payload before
+ * returning the selected method and the unmodified challenge request.
  *
  * This intentionally does not verify that the challenge was issued by a
  * particular host, authorize the caller or requested resource, validate the
@@ -82,7 +79,7 @@ export async function broadcastCredential(methods, input) {
 function prepareCredential(methods, input) {
     const credential = typeof input === 'string' ? Credential.deserialize(input) : input;
     const candidates = methods.filter((method) => method.name === credential.challenge.method && method.intent === credential.challenge.intent);
-    const method = selectServerMethod(candidates, credential.challenge);
+    const method = candidates[0];
     if (!method)
         throw new Errors.InvalidChallengeError({
             id: credential.challenge.id,
@@ -102,20 +99,6 @@ function prepareCredential(methods, input) {
         request: credential.challenge.request,
     };
 }
-/** @internal */
-export function selectServerMethod(methods, challenge) {
-    if (methods.length <= 1)
-        return methods[0];
-    if (challenge.method !== Constants.Methods.tempo ||
-        challenge.intent !== Constants.Intents.session)
-        return methods[0];
-    const sessionProtocol = Constants.getMethodDetail(challenge.request.methodDetails, Constants.MethodDetailKeys.sessionProtocol);
-    if (sessionProtocol === undefined || sessionProtocol === Constants.SessionProtocols.v1)
-        return methods.find((method) => method.alias === 'sessionLegacy') ?? methods[0];
-    if (sessionProtocol === Constants.SessionProtocols.v2)
-        return methods.find((method) => method.alias === undefined) ?? methods[0];
-    return undefined;
-}
 /**
  * Extends a method with client-side credential creation logic.
  *
@@ -157,7 +140,7 @@ export function toClient(method, options) {
  * ```
  */
 export function toServer(method, options) {
-    const { alias, authorize, defaults, extensions, html, preflight, request, respond, broadcast, stableBinding, transport, validate, verify, } = options;
+    const { alias, authorize, canOffer, defaults, extensions, html, onPaymentSuccess, preflight, request, respond, broadcast, stableBinding, transport, validate, verify, } = options;
     const effectiveVerify = verify ??
         (async (parameters) => {
             if (validate)
@@ -172,9 +155,11 @@ export function toServer(method, options) {
         ...method,
         alias,
         authorize,
+        canOffer,
         defaults,
         extensions,
         html,
+        onPaymentSuccess,
         preflight,
         request,
         respond,

package/dist/Store.d.ts

@@ -1,3 +1,4 @@
+import type { MaybePromise } from './internal/types.js';
 export type StoreItemMap = Record<string, unknown>;
 /**
  * Describes the outcome of an atomic {@link Update} callback.
@@ -27,6 +28,13 @@ export type Change<value, result> = {
  * must be synchronous and free of side effects.
  */
 export type Update<itemMap extends StoreItemMap = StoreItemMap> = <key extends keyof itemMap & string, result>(key: key, fn: (current: itemMap[key] | null) => Change<itemMap[key], result>) => Promise<result>;
+/** Attempts to atomically record first use of a replay key through its expiry. */
+export type TryClaim<itemMap extends StoreItemMap = StoreItemMap> = <key extends keyof itemMap & string>(key: key, expires: number) => MaybePromise<boolean>;
+/** Persisted marker used by the {@link tryClaim} fallback. */
+export type ReplayMarker = {
+    expires: number;
+    type: 'mppx:replay';
+};
 /** Base key-value actions available on every {@link Store}. */
 export type StoreActions<itemMap extends StoreItemMap = StoreItemMap> = {
     get: <key extends keyof itemMap & string>(key: key) => Promise<itemMap[key] | null>;
@@ -36,6 +44,8 @@ export type StoreActions<itemMap extends StoreItemMap = StoreItemMap> = {
 /** Atomic actions that can be provided via the `extended` slot. */
 export type AtomicActions<itemMap extends StoreItemMap = StoreItemMap> = {
     update: Update<itemMap>;
+    /** Optional single-operation fast path for recording expiring replay keys. */
+    tryClaim?: TryClaim<itemMap> | undefined;
 };
 /**
  * Async key-value store.
@@ -54,6 +64,15 @@ export type Store<itemMap extends StoreItemMap = StoreItemMap, extended extends
  * Equivalent to `Store<itemMap, AtomicActions<itemMap>>`.
  */
 export type AtomicStore<itemMap extends StoreItemMap = StoreItemMap> = Store<itemMap, AtomicActions<itemMap>>;
+/**
+ * Attempts to atomically record first use of a replay key through its expiry.
+ *
+ * Returns `true` when this call recorded the key and `false` when it was already
+ * recorded and unexpired. `expires` is a Unix timestamp in milliseconds.
+ * Uses the adapter's optimized primitive when available and otherwise falls
+ * back to {@link AtomicStore.update}.
+ */
+export declare function tryClaim<itemMap extends StoreItemMap, key extends keyof itemMap & string>(store: AtomicStore<itemMap>, key: key, expires: number): MaybePromise<boolean>;
 /** Options shared by store constructors. */
 export type Options = {
     /** Prefix prepended to every backing store key. */

package/dist/Store.js

@@ -15,6 +15,35 @@
  * `AtomicActions`, just like Viem's `PublicClient = Client<..., PublicActions>`.
  */
 import { Json } from 'ox';
+/**
+ * Attempts to atomically record first use of a replay key through its expiry.
+ *
+ * Returns `true` when this call recorded the key and `false` when it was already
+ * recorded and unexpired. `expires` is a Unix timestamp in milliseconds.
+ * Uses the adapter's optimized primitive when available and otherwise falls
+ * back to {@link AtomicStore.update}.
+ */
+export function tryClaim(store, key, expires) {
+    if (store.tryClaim)
+        return store.tryClaim(key, expires);
+    return store.update(key, (current) => {
+        if (current !== null && (!isReplayMarker(current) || current.expires > Date.now()))
+            return { op: 'noop', result: false };
+        return {
+            op: 'set',
+            value: { expires, type: 'mppx:replay' },
+            result: true,
+        };
+    });
+}
+function isReplayMarker(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'expires' in value &&
+        typeof value.expires === 'number' &&
+        'type' in value &&
+        value.type === 'mppx:replay');
+}
 const keyPrefixCache = new WeakMap();
 export function from(store, options) {
     return withKeyPrefix(store, options?.keyPrefix);
@@ -44,6 +73,13 @@ function withKeyPrefix(store, keyPrefix = '') {
                 },
             }
             : {}),
+        ...('tryClaim' in store && typeof store.tryClaim === 'function'
+            ? {
+                tryClaim(key, expires) {
+                    return store.tryClaim(prefixedKey(key), expires);
+                },
+            }
+            : {}),
     });
     const cachedByPrefix = keyPrefixCache.get(store) ?? new Map();
     cachedByPrefix.set(keyPrefix, prefixed);
@@ -107,6 +143,13 @@ export function memory(options) {
                 store.delete(key);
             return change.result;
         },
+        tryClaim(key, expires) {
+            const current = store.has(key) ? Json.parse(store.get(key)) : null;
+            if (current !== null && (!isReplayMarker(current) || current.expires > Date.now()))
+                return false;
+            store.set(key, Json.stringify({ expires, type: 'mppx:replay' }));
+            return true;
+        },
     }, options);
 }
 export function redis(client, options) {

package/dist/attestation/Client.d.ts

@@ -0,0 +1,17 @@
+import type * as Types from './Types.js';
+/**
+ * Combines request signers using one shared context per call.
+ *
+ * The returned signer creates a fresh context unless its caller supplies one,
+ * allowing every signature on one HTTP attempt to share a nonce and timestamp.
+ */
+export declare function composeSigners(...signers: readonly [Types.Signer, ...Types.Signer[]]): Types.Signer<'composed'>;
+/**
+ * Wraps a fetch implementation so every outbound request is attested.
+ *
+ * Configure this wrapper as the underlying `fetch` passed to `mppx/client`
+ * `Fetch.from()`. MPPX then uses it for both the initial request and its
+ * automatic request containing an `Authorization: Payment` credential.
+ */
+export declare function wrapFetch(fetch: typeof globalThis.fetch, signer: Types.Signer): typeof globalThis.fetch;
+//# sourceMappingURL=Client.d.ts.map