mppx 0.8.15 → 0.8.18

package/dist/cli/sessions/store.js

@@ -6,6 +6,7 @@ import * as Challenge from '../../Challenge.js';
 import { resolveEscrow } from '../../tempo/session/client/ChannelOps.js';
 import { deserializeEntry, entryKey, serializeEntry, } from '../../tempo/session/client/ChannelStore.js';
 import { isTempoSessionChallenge, } from '../../tempo/session/client/Transports.js';
+import * as Channel from '../../tempo/session/precompile/Channel.js';
 import * as z from '../../zod.js';
 const sessionStateVersion = 1;
 /** Invalid, corrupt, or inconsistent persistent session state. */
@@ -47,6 +48,10 @@ const storedChannelSchema = z.object({
     escrow: z.address(),
     chainId: z.number(),
     opened: z.boolean(),
+    paymentScope: z.optional(z.object({
+        payee: z.address(),
+        token: z.address(),
+    })),
 });
 const accountSchema = z.object({
     name: z.optional(z.string()),
@@ -113,8 +118,8 @@ export function sessionScopeKey(scope) {
 export function sessionScope(channel) {
     return {
         payer: channel.descriptor.payer,
-        payee: channel.descriptor.payee,
-        token: channel.descriptor.token,
+        payee: channel.paymentScope?.payee ?? channel.descriptor.payee,
+        token: channel.paymentScope?.token ?? channel.descriptor.token,
         escrow: channel.escrow,
         chainId: channel.chainId,
     };
@@ -180,9 +185,9 @@ export function createSessionRegistry(options = {}) {
         const file = channelFile(paths, normalizedId);
         const previousValue = await readJson(file);
         const previous = previousValue === undefined ? undefined : parseStoredSession(previousValue, file);
+        const challenge = parseSessionChallenge(input.challenge, file);
         if (previous)
             assertSameSession(previous, input, file);
-        const challenge = parseSessionChallenge(input.challenge, file);
         assertChallengeMatchesChannel(challenge, channel, file);
         const receipt = input.receipt
             ? sanitizeReceipt(input.receipt, channel.channelId, file)
@@ -531,30 +536,39 @@ function channelIdentity(channel) {
         ])),
         escrow: channel.escrow.toLowerCase(),
         chainId: channel.chainId,
+        paymentScope: channel.paymentScope
+            ? {
+                payee: channel.paymentScope.payee.toLowerCase(),
+                token: channel.paymentScope.token.toLowerCase(),
+            }
+            : undefined,
     };
 }
 function assertChallengeMatchesChannel(challenge, channel, file) {
+    const expectedChannelId = Channel.computeId({
+        ...channel.descriptor,
+        chainId: channel.chainId,
+        escrow: channel.escrow,
+    });
+    if (expectedChannelId.toLowerCase() !== channel.channelId.toLowerCase())
+        throw stateError(file, 'Session channel ID does not match its descriptor.');
     const payee = normalizeAddress(challenge.request.recipient, 'challenge recipient', file);
     const token = normalizeAddress(challenge.request.currency, 'challenge currency', file);
-    if (payee !== channel.descriptor.payee.toLowerCase())
-        throw stateError(file, 'Session challenge payee does not match the channel.');
-    if (token !== channel.descriptor.token.toLowerCase())
-        throw stateError(file, 'Session challenge token does not match the channel.');
-    if (resolveEscrow(challenge).toLowerCase() !== channel.escrow.toLowerCase())
+    const scope = normalizeScope(sessionScope(channel));
+    if (resolveEscrow(challenge, channel.escrow).toLowerCase() !== channel.escrow.toLowerCase())
         throw stateError(file, 'Session challenge escrow does not match the channel.');
     if (isObject(challenge.request.methodDetails)) {
         const methodDetails = challenge.request.methodDetails;
         if (methodDetails.chainId !== undefined && methodDetails.chainId !== channel.chainId)
             throw stateError(file, 'Session challenge chain does not match the channel.');
     }
+    if (payee !== scope.payee)
+        throw stateError(file, 'Session challenge payee does not match the channel.');
+    if (token !== scope.token)
+        throw stateError(file, 'Session challenge token does not match the channel.');
 }
 function assertChannelScope(channel, scope, file) {
-    const normalized = normalizeScope(scope);
-    if (channel.descriptor.payer.toLowerCase() !== normalized.payer ||
-        channel.descriptor.payee.toLowerCase() !== normalized.payee ||
-        channel.descriptor.token.toLowerCase() !== normalized.token ||
-        channel.escrow.toLowerCase() !== normalized.escrow ||
-        channel.chainId !== normalized.chainId)
+    if (sessionScopeKey(sessionScope(channel)) !== sessionScopeKey(scope))
         throw stateError(file, 'Session channel does not match the selected payment scope.');
 }
 function selectLatestReceipt(previous, next) {

package/dist/cli/utils.d.ts

@@ -94,7 +94,7 @@ export declare function chainName(chain: {
 export declare const pathUsd: Address;
 export declare const usdc: Address;
 export declare const mainnetTokens: readonly [`0x${string}`, `0x${string}`];
-export declare const testnetTokens: readonly ["0x20c0000000000000000000000000000000000000", "0x20c0000000000000000000000000000000000001", "0x20c0000000000000000000000000000000000002", "0x20c0000000000000000000000000000000000003"];
+export declare const testnetTokens: readonly ['0x20c0000000000000000000000000000000000000', '0x20c0000000000000000000000000000000000001', '0x20c0000000000000000000000000000000000002', '0x20c0000000000000000000000000000000000003'];
 export declare function isTestnet(chain: Chain): boolean;
 export declare function fetchTokenInfo(client: ReturnType<typeof createClient>, token: Address, account: Address): Promise<{
     balance: bigint;

package/dist/cli/validate/index.d.ts

@@ -5,13 +5,13 @@ declare const validate: Cli.Cli<{
             url: string;
         };
         options: {
-            verbose: number;
-            yes: boolean;
-            outputJson: boolean;
             endpoint?: string | undefined;
             body?: string | undefined;
             query?: string[] | undefined;
             header?: string[] | undefined;
+            verbose: number;
+            yes: boolean;
+            outputJson: boolean;
         };
     };
 }, undefined, undefined, undefined>;

package/dist/client/Mppx.d.ts

@@ -1,3 +1,4 @@
+import type * as Attestation from '../attestation/Types.js';
 import type * as Challenge from '../Challenge.js';
 import * as AcceptPayment from '../internal/AcceptPayment.js';
 import type * as Method from '../Method.js';
@@ -78,6 +79,8 @@ export declare namespace createCredential {
 export declare function restore(): void;
 export declare namespace create {
     type Config<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`. */

package/dist/client/Mppx.js

@@ -1,3 +1,4 @@
+import * as AttestationClient from '../attestation/Client.js';
 import * as Expires from '../Expires.js';
 import * as AcceptPayment from '../internal/AcceptPayment.js';
 import * as Fetch from './internal/Fetch.js';
@@ -24,10 +25,13 @@ import * as Transport from './Transport.js';
  * ```
  */
 export function create(config) {
-    const { maxPaymentRetries, onChallenge, orderChallenges, polyfill = true, acceptPaymentPolicy = polyfill && typeof globalThis.location !== 'undefined'
+    const { attestation, maxPaymentRetries, onChallenge, orderChallenges, polyfill = true, acceptPaymentPolicy = polyfill && typeof globalThis.location !== 'undefined'
         ? 'same-origin'
         : 'always', transport = Transport.http(), } = config;
     const rawFetch = config.fetch ?? globalThis.fetch;
+    const attestedFetch = attestation
+        ? createAttestedFetch(rawFetch, attestation)
+        : rawFetch;
     const methods = config.methods.flat();
     const acceptPayment = AcceptPayment.resolve(methods, config.paymentPreferences);
     const events = Fetch.createEventDispatcher();
@@ -35,7 +39,7 @@ export function create(config) {
     const config_fetch = {
         acceptPayment,
         acceptPaymentPolicy,
-        ...(config.fetch && { fetch: config.fetch }),
+        ...((config.fetch || attestation) && { fetch: attestedFetch }),
         eventDispatcher: events,
         ...(maxPaymentRetries !== undefined && { maxPaymentRetries }),
         ...(resolvedOnChallenge && { onChallenge: resolvedOnChallenge }),
@@ -69,9 +73,7 @@ export function create(config) {
         onPaymentFailed,
         onPaymentResponse,
         async createCredential(response, context, options) {
-            const challenges = transport.getChallenges
-                ? await transport.getChallenges(response)
-                : [await transport.getChallenge(response)];
+            const challenges = await transport.getChallenges(response);
             const preferences = resolveChallengePreferences(acceptPayment.entries, options?.acceptPayment);
             let challenge;
             let mi;
@@ -134,6 +136,12 @@ export function create(config) {
 export function restore() {
     Fetch.restore();
 }
+function createAttestedFetch(fetch, signers) {
+    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));
+}
 function memoizeCreateCredential(createCredential) {
     let promise;
     return (context) => {

package/dist/client/Transport.d.ts

@@ -14,10 +14,8 @@ export type Transport<in out request = unknown, in out response = unknown> = {
      * 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, when the transport supports multiple offers. */
-    getChallenges?: (response: response, request?: request) => Challenge.Challenge[] | Promise<Challenge.Challenge[]>;
-    /** Extracts the challenge from a payment-required response. */
-    getChallenge: (response: response, request?: request) => Challenge.Challenge | Promise<Challenge.Challenge>;
+    /** 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;
 };
@@ -42,7 +40,7 @@ export type RequestOf<transport extends Transport> = transport extends Transport
  * const custom = Transport.from({
  *   name: 'custom',
  *   isPaymentRequired(response) { ... },
- *   getChallenge(response) { ... },
+ *   getChallenges(response) { ... },
  *   setCredential(request, credential) { ... },
  * })
  * ```

package/dist/client/Transport.js

@@ -14,7 +14,7 @@ import { x402 as x402Protocol } from './internal/protocols/X402.js';
  * const custom = Transport.from({
  *   name: 'custom',
  *   isPaymentRequired(response) { ... },
- *   getChallenge(response) { ... },
+ *   getChallenges(response) { ... },
  *   setCredential(request, credential) { ... },
  * })
  * ```
@@ -59,16 +59,6 @@ export function http() {
         getChallenges(response, request) {
             return collect(response, request);
         },
-        getChallenge(response, request) {
-            const pick = (challenges) => {
-                const challenge = challenges[0];
-                if (!challenge)
-                    throw new Error('No challenge in response.');
-                return challenge;
-            };
-            const challenges = collect(response, request);
-            return challenges instanceof Promise ? challenges.then(pick) : pick(challenges);
-        },
         setCredential(request, credential, options) {
             const protocol = options?.challenge ? protocolForChallenge.get(options.challenge) : undefined;
             const fallback = protocols[0];
@@ -99,12 +89,6 @@ export function mcp() {
         getChallenges(response) {
             return mcpPaymentRequiredChallenges(response);
         },
-        getChallenge(response) {
-            const challenge = mcpPaymentRequiredChallenges(response)[0];
-            if (!challenge)
-                throw new Error('No challenge in response.');
-            return challenge;
-        },
         setCredential(request, credential) {
             const parsed = Credential.deserialize(credential);
             return {

package/dist/client/internal/Fetch.js

@@ -69,9 +69,7 @@ export function from(config) {
         let preparedCredential;
         try {
             for (let retry = 0; retry < maxPaymentRetries; retry++) {
-                challenges = transport.getChallenges
-                    ? await transport.getChallenges(response, transportRequest)
-                    : [await transport.getChallenge(response, transportRequest)];
+                challenges = await transport.getChallenges(response, transportRequest);
                 const candidates = AcceptPayment.selectChallengeCandidates(challenges, methods, paymentPreferences.entries);
                 const orderedCandidates = await resolveChallengeOrder(candidates, requestOrderChallenges ??
                     orderChallenges);
@@ -210,9 +208,7 @@ export function from(config) {
             }
             challenges = undefined;
             try {
-                challenges = transport.getChallenges
-                    ? await transport.getChallenges(response, transportRequest)
-                    : [await transport.getChallenge(response, transportRequest)];
+                challenges = await transport.getChallenges(response, transportRequest);
             }
             catch { }
             await settleAttempt(preparedCredential, {

package/dist/discovery/Discovery.js

@@ -26,7 +26,8 @@ export const PaymentInfo = z.pipe(z
     method: z.optional(z.string()),
     offers: z.optional(z.array(PaymentOffer).check(z.minLength(1))),
 })
-    .check(z.refine((value) => value.offers === undefined || Object.keys(value).every((key) => key === 'offers'), 'Cannot mix offers with flat payment info fields')), z.transform((value) => {
+    .check(z.refine((value) => value.offers === undefined ||
+    Object.keys(value).every((key) => key === 'offers' || !paymentInfoFieldNames.has(key)), 'Cannot mix offers with flat payment info fields')), z.transform((value) => {
     if (value.offers)
         return { offers: value.offers };
     const offer = {};

package/dist/discovery/OpenApi.d.ts

@@ -1,11 +1,9 @@
 import type * as Method from '../Method.js';
 import { type ServiceInfo } from './Discovery.js';
+import * as Metadata from './internal/Metadata.js';
+/** Payment handler carrying metadata used to generate discovery documents. */
 export type DiscoveryHandler = ((...args: any[]) => unknown) & {
-    _internal?: {
-        _canonicalRequest: Record<string, unknown>;
-        intent: string;
-        name: string;
-    };
+    _internal?: Metadata.Metadata;
 };
 export type LegacyRouteConfig = {
     intent: string;

package/dist/discovery/OpenApi.js

@@ -1,4 +1,6 @@
+import * as PaymentRequest from '../PaymentRequest.js';
 import { PaymentInfo } from './Discovery.js';
+import * as Metadata from './internal/Metadata.js';
 /**
  * Generates an OpenAPI 3.1.0 discovery document from an mppx instance
  * and route configuration.
@@ -79,11 +81,9 @@ function resolveRoute(route, methodsByKey) {
         return {
             method: route.method,
             path: route.path,
-            payment: paymentInfoFromCanonical({
-                canonicalRequest: internal._canonicalRequest,
-                intent: internal.intent,
-                method: internal.name,
-            }),
+            payment: {
+                offers: Metadata.offers(internal).map(Metadata.paymentOffer),
+            },
             ...(route.requestBody ? { requestBody: route.requestBody } : {}),
             ...(route.summary ? { summary: route.summary } : {}),
         };
@@ -92,42 +92,21 @@ function resolveRoute(route, methodsByKey) {
     if (!mi) {
         throw new Error(`Unknown intent "${route.intent}" for route ${route.method.toUpperCase()} ${route.path}. Available: ${[...methodsByKey.keys()].join(', ')}`);
     }
+    const { description, ...options } = route.options;
+    const metadata = {
+        _canonicalRequest: PaymentRequest.fromMethod(mi, options),
+        ...(typeof description === 'string' ? { description } : {}),
+        intent: mi.intent,
+        name: mi.name,
+    };
     return {
         method: route.method,
         path: route.path,
-        payment: paymentInfoFromCanonical({
-            canonicalRequest: route.options,
-            intent: mi.intent,
-            method: mi.name,
-        }),
+        payment: Metadata.paymentOffer(metadata),
         ...(route.requestBody ? { requestBody: route.requestBody } : {}),
         ...(route.summary ? { summary: route.summary } : {}),
     };
 }
-function paymentInfoFromCanonical(route) {
-    const { canonicalRequest, intent, method } = route;
-    const methodDetails = (canonicalRequest.methodDetails ?? {});
-    const amount = pickString(canonicalRequest.amount) ?? pickString(methodDetails.amount) ?? null;
-    const currency = pickString(canonicalRequest.currency) ?? pickString(methodDetails.currency);
-    const description = pickString(canonicalRequest.description);
-    const base = {
-        amount,
-        ...(currency ? { currency } : {}),
-        ...(description ? { description } : {}),
-        intent,
-        method,
-    };
-    // Forward any extra canonical params that aren't already covered.
-    const reserved = new Set(['amount', 'currency', 'description', 'methodDetails']);
-    for (const [key, value] of Object.entries(canonicalRequest)) {
-        if (!reserved.has(key) && value !== undefined)
-            base[key] = value;
-    }
-    return base;
-}
-function pickString(value) {
-    return typeof value === 'string' ? value : undefined;
-}
 function withBasePath(basePath, path) {
     if (!basePath)
         return path;

package/dist/discovery/internal/Metadata.d.ts

@@ -0,0 +1,20 @@
+/** Metadata retained by one explicitly configured payment handler. */
+export type Offer = {
+    _canonicalRequest: Record<string, unknown>;
+    description?: string | undefined;
+    intent: string;
+    name: string;
+};
+/** Metadata retained by a single or composed payment handler. */
+export type Metadata = Offer | {
+    offers: readonly Offer[];
+};
+/** Returns every explicitly configured offer from discovery metadata. */
+export declare function offers(metadata: Metadata): readonly Offer[];
+/** Converts configured handler metadata into a discovery payment offer. */
+export declare function paymentOffer(metadata: Offer): Record<string, unknown>;
+/** Returns whether metadata represents a composed handler. */
+export declare function isComposed(metadata: Metadata): metadata is Extract<Metadata, {
+    offers: unknown;
+}>;
+//# sourceMappingURL=Metadata.d.ts.map

package/dist/discovery/internal/Metadata.js

@@ -0,0 +1,36 @@
+/** Returns every explicitly configured offer from discovery metadata. */
+export function offers(metadata) {
+    if (isComposed(metadata))
+        return metadata.offers;
+    return [metadata];
+}
+/** Converts configured handler metadata into a discovery payment offer. */
+export function paymentOffer(metadata) {
+    const { _canonicalRequest: request, intent, name: method } = metadata;
+    const methodDetails = (request.methodDetails ?? {});
+    const amount = pickString(request.amount) ?? pickString(methodDetails.amount) ?? null;
+    const currency = pickString(request.currency) ?? pickString(methodDetails.currency);
+    const description = pickString(metadata.description) ?? pickString(request.description);
+    const offer = {
+        amount,
+        ...(currency ? { currency } : {}),
+        ...(description ? { description } : {}),
+        intent,
+        method,
+    };
+    // Preserve extension fields emitted by method request schemas.
+    const reserved = new Set(['amount', 'currency', 'description', 'methodDetails']);
+    for (const [key, value] of Object.entries(request)) {
+        if (!reserved.has(key) && value !== undefined)
+            offer[key] = value;
+    }
+    return offer;
+}
+/** Returns whether metadata represents a composed handler. */
+export function isComposed(metadata) {
+    return 'offers' in metadata && !('_canonicalRequest' in metadata);
+}
+function pickString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+//# sourceMappingURL=Metadata.js.map

package/dist/evm/Methods.d.ts

@@ -4,8 +4,8 @@ export declare const charge: {
     readonly name: "evm";
     readonly intent: "charge";
     readonly schema: {
-        readonly credential: {
-            readonly payload: z.ZodMiniObject<{
+        credential: {
+            payload: z.ZodMiniObject<{
                 from: z.ZodMiniString<string>;
                 nonce: z.ZodMiniString<string>;
                 signature: z.ZodMiniString<string>;
@@ -16,7 +16,7 @@ export declare const charge: {
                 value: z.ZodMiniString<string>;
             }, z.core.$strip>;
         };
-        readonly request: z.ZodMiniPipe<z.ZodMiniObject<{
+        request: z.ZodMiniPipe<z.ZodMiniObject<{
             amount: z.ZodMiniString<string>;
             chainId: z.ZodMiniNumber<number>;
             currency: z.ZodMiniString<string>;
@@ -33,31 +33,31 @@ export declare const charge: {
                 recipient: z.ZodMiniString<string>;
             }, z.core.$strip>>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
+            description?: string | undefined;
+            externalId?: string | undefined;
             amount: string;
             currency: `0x${string}`;
             methodDetails: {
+                chainId: number;
+                credentialTypes: string[];
+                decimals: number;
+                permit2Address?: `0x${string}` | undefined;
                 splits?: {
                     amount: string;
                     recipient: string;
                 }[] | undefined;
-                permit2Address?: `0x${string}` | undefined;
-                chainId: number;
-                credentialTypes: string[];
-                decimals: number;
             };
             recipient: `0x${string}`;
-            description?: string | undefined;
-            externalId?: string | undefined;
         }, {
             amount: string;
             chainId: number;
             currency: string;
-            decimals: number;
-            recipient: string;
             credentialTypes?: "authorization"[] | undefined;
+            decimals: number;
             description?: string | undefined;
             externalId?: string | undefined;
             permit2Address?: string | undefined;
+            recipient: string;
             splits?: {
                 amount: string;
                 recipient: string;

package/dist/evm/Types.d.ts

@@ -1,14 +1,14 @@
 import * as z from '../zod.js';
 /** Payment method name for Payment-auth EVM challenges. */
-export declare const paymentMethod: "evm";
+export declare const paymentMethod: 'evm';
 /** Payment intent name for one-time EVM charges. */
-export declare const chargeIntent: "charge";
+export declare const chargeIntent: 'charge';
 /** CAIP-2 namespace prefix for EVM networks. */
-export declare const evmNetworkPrefix: "eip155:";
+export declare const evmNetworkPrefix: 'eip155:';
 /** EIP-3009 transfer authorization method identifier. */
-export declare const eip3009: "eip3009";
+export declare const eip3009: 'eip3009';
 /** EVM charge credential types supported by this package. */
-export declare const credentialTypes: readonly ["authorization"];
+export declare const credentialTypes: readonly ['authorization'];
 /** EIP-3009 domain metadata for `transferWithAuthorization` signatures. */
 export declare const AuthorizationConfigSchema: z.ZodMiniObject<{
     name: z.ZodMiniString<string>;
@@ -98,23 +98,23 @@ export type ChargePayload = z.infer<typeof ChargePayloadSchema>;
 /** EIP-712 type definition for EIP-3009 `transferWithAuthorization`. */
 export declare const authorizationTypes: {
     readonly TransferWithAuthorization: readonly [{
-        readonly name: "from";
-        readonly type: "address";
+        readonly name: 'from';
+        readonly type: 'address';
     }, {
-        readonly name: "to";
-        readonly type: "address";
+        readonly name: 'to';
+        readonly type: 'address';
     }, {
-        readonly name: "value";
-        readonly type: "uint256";
+        readonly name: 'value';
+        readonly type: 'uint256';
     }, {
-        readonly name: "validAfter";
-        readonly type: "uint256";
+        readonly name: 'validAfter';
+        readonly type: 'uint256';
     }, {
-        readonly name: "validBefore";
-        readonly type: "uint256";
+        readonly name: 'validBefore';
+        readonly type: 'uint256';
     }, {
-        readonly name: "nonce";
-        readonly type: "bytes32";
+        readonly name: 'nonce';
+        readonly type: 'bytes32';
     }];
 };
 /** Returns the EIP-712 domain for an EIP-3009 authorization signature. */

package/dist/evm/client/Charge.d.ts

@@ -13,8 +13,8 @@ export declare function charge(parameters: charge.Parameters): Method.Client<{
     readonly name: "evm";
     readonly intent: "charge";
     readonly schema: {
-        readonly credential: {
-            readonly payload: z.ZodMiniObject<{
+        credential: {
+            payload: z.ZodMiniObject<{
                 from: z.ZodMiniString<string>;
                 nonce: z.ZodMiniString<string>;
                 signature: z.ZodMiniString<string>;
@@ -25,7 +25,7 @@ export declare function charge(parameters: charge.Parameters): Method.Client<{
                 value: z.ZodMiniString<string>;
             }, z.core.$strip>;
         };
-        readonly request: z.ZodMiniPipe<z.ZodMiniObject<{
+        request: z.ZodMiniPipe<z.ZodMiniObject<{
             amount: z.ZodMiniString<string>;
             chainId: z.ZodMiniNumber<number>;
             currency: z.ZodMiniString<string>;
@@ -42,31 +42,31 @@ export declare function charge(parameters: charge.Parameters): Method.Client<{
                 recipient: z.ZodMiniString<string>;
             }, z.core.$strip>>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
+            description?: string | undefined;
+            externalId?: string | undefined;
             amount: string;
             currency: `0x${string}`;
             methodDetails: {
+                chainId: number;
+                credentialTypes: string[];
+                decimals: number;
+                permit2Address?: `0x${string}` | undefined;
                 splits?: {
                     amount: string;
                     recipient: string;
                 }[] | undefined;
-                permit2Address?: `0x${string}` | undefined;
-                chainId: number;
-                credentialTypes: string[];
-                decimals: number;
             };
             recipient: `0x${string}`;
-            description?: string | undefined;
-            externalId?: string | undefined;
         }, {
             amount: string;
             chainId: number;
             currency: string;
-            decimals: number;
-            recipient: string;
             credentialTypes?: "authorization"[] | undefined;
+            decimals: number;
             description?: string | undefined;
             externalId?: string | undefined;
             permit2Address?: string | undefined;
+            recipient: string;
             splits?: {
                 amount: string;
                 recipient: string;

package/dist/evm/client/Charge.js

@@ -15,6 +15,14 @@ import * as Types from '../Types.js';
  */
 export function charge(parameters) {
     return Method.toClient(Methods.charge, {
+        canHandleChallenge({ challenge }) {
+            if (!isX402Challenge(challenge))
+                return true;
+            return x402_Exact.canHandleChallenge({
+                challenge: challenge,
+                config: parameters,
+            });
+        },
         context: z.object({
             account: z.optional(z.custom()),
         }),