mppx 0.9.2 → 0.10.0

package/dist/client/Mppx.js

@@ -1,8 +1,11 @@
 import * as AttestationClient from '../attestation/Client.js';
+import * as Constants from '../Constants.js';
 import * as Expires from '../Expires.js';
 import * as AcceptPayment from '../internal/AcceptPayment.js';
 import * as Fetch from './internal/Fetch.js';
+import * as MethodChallenge from './internal/MethodChallenge.js';
 import * as Transport from './Transport.js';
+const preparedPaymentMethods = new WeakMap();
 /**
  * Creates a client-side payment handler from an array of methods.
  *
@@ -28,9 +31,12 @@ export function create(config) {
     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)
+    const rawFetch = Fetch.unwrapFetch(config.fetch ?? globalThis.fetch);
+    const attestationSigner = attestation
+        ? createAttestationSigner(attestation)
+        : undefined;
+    const attestedFetch = attestationSigner
+        ? AttestationClient.wrapFetch(rawFetch, attestationSigner)
         : rawFetch;
     const methods = config.methods.flat();
     const acceptPayment = AcceptPayment.resolve(methods, config.paymentPreferences);
@@ -117,7 +123,7 @@ export function create(config) {
                     throw error;
                 }
             });
-            return Object.freeze({
+            const prepared = Object.freeze({
                 challenge: selectedChallenge,
                 challenges: challengeSnapshots,
                 createCredential: createPreparedCredential,
@@ -127,6 +133,8 @@ export function create(config) {
                     return transport.setCredential(request, credential, { challenge: transportChallenge });
                 },
             });
+            preparedPaymentMethods.set(prepared, selectedMethod);
+            return prepared;
         }
         catch (error) {
             await events.emit('payment.failed', createPaymentFailedPayload({
@@ -139,6 +147,51 @@ export function create(config) {
             throw error;
         }
     }
+    async function prepareRequest(input, init, options) {
+        const { maxRedirects = 20, ...paymentOptions } = options ?? {};
+        const preparedHttp = await prepareHttpRequest({
+            acceptPayment: acceptPayment.header,
+            acceptPaymentPolicy,
+            fetch: rawFetch,
+            init,
+            input,
+            maxRedirects,
+            signer: attestationSigner,
+        });
+        const requestInit = requestToInit(preparedHttp.replayRequest, preparedHttp.body);
+        if (!(await transport.isPaymentRequired(preparedHttp.response, requestInit)))
+            throw new Error('Response does not require payment.');
+        const payment = (await preparePayment(preparedHttp.response, {
+            ...paymentOptions,
+            request: requestInit,
+        }));
+        const paymentMethod = preparedPaymentMethods.get(payment) ?? payment.method;
+        const createRequestCredential = memoizeCreateCredential(async (context) => {
+            if (MethodChallenge.has(paymentMethod))
+                await MethodChallenge.handle(paymentMethod, {
+                    challenge: payment.challenge,
+                    context,
+                    fetch: attestedFetch,
+                    input: preparedHttp.replayRequest,
+                });
+            return payment.createCredential(context);
+        });
+        return Object.freeze({
+            ...payment,
+            createCredential: createRequestCredential,
+            request: preparedHttp.request,
+            response: preparedHttp.response,
+            redirects: preparedHttp.redirects,
+            async pay(context) {
+                const credential = await createRequestCredential(context);
+                const paidInit = payment.setCredential(requestToInit(preparedHttp.replayRequest, preparedHttp.body), credential);
+                return attestedFetch(preparedHttp.replayRequest.url, {
+                    ...paidInit,
+                    redirect: 'manual',
+                });
+            },
+        });
+    }
     return {
         fetch,
         rawFetch,
@@ -150,6 +203,7 @@ export function create(config) {
         onPaymentFailed,
         onPaymentResponse,
         preparePayment,
+        prepareRequest: prepareRequest,
         async createCredential(response, context, options) {
             const prepared = await preparePayment(response, options);
             return prepared.createCredential(context);
@@ -173,11 +227,131 @@ export function create(config) {
 export function restore() {
     Fetch.restore();
 }
-function createAttestedFetch(fetch, signers) {
+function createAttestationSigner(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));
+    return AttestationClient.composeSigners(...values);
+}
+const redirectStatuses = new Set([301, 302, 303, 307, 308]);
+const bodyHeaders = [
+    'content-encoding',
+    'content-language',
+    'content-length',
+    'content-location',
+    'content-type',
+    'transfer-encoding',
+];
+const crossOriginHeaders = [
+    'authorization',
+    'cookie',
+    'cookie2',
+    'host',
+    'payment-authorization',
+    'payment-signature',
+    'proxy-authorization',
+    'x-payment',
+];
+async function prepareHttpRequest(parameters) {
+    const { acceptPayment, acceptPaymentPolicy, fetch, init, input, maxRedirects, signer } = parameters;
+    if (!Number.isInteger(maxRedirects) || maxRedirects < 0)
+        throw new TypeError('maxRedirects must be a non-negative integer.');
+    let request = new Request(input, { ...init, redirect: 'manual' });
+    const explicitAcceptPayment = request.headers.has(Constants.Headers.acceptPayment);
+    let body = await replayBody(request, init?.body);
+    const redirects = [];
+    for (;;) {
+        request = withAcceptPayment(request, acceptPayment, explicitAcceptPayment, acceptPaymentPolicy);
+        const sentRequest = signer ? await signer.sign(request.clone()) : request.clone();
+        const response = await fetch(sentRequest);
+        if (response.type === 'opaqueredirect' || response.status === 0)
+            throw new Error('prepareRequest requires a runtime that exposes manual redirect responses.');
+        if (!redirectStatuses.has(response.status))
+            return {
+                body,
+                replayRequest: request,
+                request: sentRequest,
+                response,
+                redirects: Object.freeze(redirects),
+            };
+        const location = response.headers.get('location');
+        if (!location)
+            return {
+                body,
+                replayRequest: request,
+                request: sentRequest,
+                response,
+                redirects: Object.freeze(redirects),
+            };
+        if (redirects.length >= maxRedirects) {
+            await response.body?.cancel();
+            throw new Error(`Payment request exceeded ${maxRedirects} redirects.`);
+        }
+        const from = new URL(request.url);
+        const to = new URL(location, from);
+        if (from.protocol === 'https:' && to.protocol !== 'https:') {
+            await response.body?.cancel();
+            throw new Error(`Payment request refused HTTPS downgrade redirect to ${to.href}`);
+        }
+        const headers = new Headers(request.headers);
+        let method = request.method;
+        const switchesToGet = ((response.status === 301 || response.status === 302) && method === 'POST') ||
+            (response.status === 303 && method !== 'GET' && method !== 'HEAD');
+        if (switchesToGet) {
+            method = 'GET';
+            body = undefined;
+            for (const header of bodyHeaders)
+                headers.delete(header);
+        }
+        if (from.origin !== to.origin)
+            for (const header of [...headers.keys()]) {
+                const value = headers.get(header) ?? '';
+                if (crossOriginHeaders.includes(header) || value.startsWith('Payment '))
+                    headers.delete(header);
+            }
+        redirects.push(Object.freeze({ from: from.href, status: response.status, to: to.href }));
+        await response.body?.cancel();
+        request = new Request(to, requestInit(request, headers, method, body));
+    }
+}
+function requestToInit(request, body) {
+    return requestInit(request, new Headers(request.headers), request.method, body);
+}
+async function replayBody(request, suppliedBody) {
+    if (typeof suppliedBody === 'string')
+        return suppliedBody;
+    if (!request.body)
+        return undefined;
+    const accept = request.headers.get('accept')?.toLowerCase() ?? '';
+    if (request.headers.has('mcp-method') ||
+        (accept.includes('application/json') && accept.includes('text/event-stream')))
+        return request.clone().text();
+    return request.clone().arrayBuffer();
+}
+function withAcceptPayment(request, acceptPayment, explicit, policy) {
+    if (explicit)
+        return request;
+    const headers = new Headers(request.headers);
+    headers.delete(Constants.Headers.acceptPayment);
+    if (acceptPayment && Fetch.shouldInjectForPolicy(request, policy))
+        headers.set(Constants.Headers.acceptPayment, acceptPayment);
+    return new Request(request, { headers });
+}
+function requestInit(request, headers, method, body) {
+    return {
+        ...(body ? { body } : {}),
+        cache: request.cache,
+        credentials: request.credentials,
+        headers,
+        integrity: request.integrity,
+        keepalive: request.keepalive,
+        method,
+        mode: request.mode,
+        redirect: 'manual',
+        referrer: request.referrer,
+        referrerPolicy: request.referrerPolicy,
+        signal: request.signal,
+    };
 }
 function memoizeCreateCredential(createCredential) {
     let promise;

package/dist/client/internal/Fetch.d.ts

@@ -168,6 +168,12 @@ export declare function normalizeHeaders(headers: unknown): Record<string, strin
  */
 export declare function createEventDispatcher<methods extends readonly Method.AnyClient[] = readonly Method.AnyClient[], response = Response>(): ClientEventDispatcher<methods, response>;
 /** @internal */
+/** @internal */
+export declare function unwrapFetch(fetch: typeof globalThis.fetch): typeof globalThis.fetch;
+/** @internal */
 export declare function validateCredentialHeaderValue(credential: string): void;
+/** @internal */
+/** @internal */
+export declare function shouldInjectForPolicy(input: RequestInfo | URL, policy: NonNullable<from.Config['acceptPaymentPolicy']>): boolean;
 export {};
 //# sourceMappingURL=Fetch.d.ts.map

package/dist/client/internal/Fetch.js

@@ -558,7 +558,8 @@ function getCallerHeaders(input, headers) {
     return new Headers(input instanceof Request ? input.headers : undefined);
 }
 /** @internal */
-function unwrapFetch(fetch) {
+/** @internal */
+export function unwrapFetch(fetch) {
     let current = fetch;
     while (current[MPPX_FETCH_WRAPPER]) {
         current = current[MPPX_FETCH_WRAPPER];
@@ -620,7 +621,8 @@ async function resolveChallengeOrder(candidates, orderChallenges) {
     return orderChallenges ? orderChallenges(candidates) : candidates;
 }
 /** @internal */
-function shouldInjectForPolicy(input, policy) {
+/** @internal */
+export function shouldInjectForPolicy(input, policy) {
     if (policy === 'always')
         return true;
     if (policy === 'never')

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

@@ -81,8 +81,8 @@ export declare namespace charge {
         signTypedData?: (parameters: any) => Promise<`0x${string}`>;
     };
     type Parameters = {
-        /** Account used to sign EVM charge credentials. */
-        account: Account;
+        /** Account used to sign credentials. May instead be supplied to `createCredential` after payment preparation. */
+        account?: Account | undefined;
         /** EIP-3009 token domain metadata for custom currencies. */
         authorization?: Types.AuthorizationConfig | undefined;
         /** Optional token decimals used to parse `maxAmount` when currency metadata is not provided. */

package/dist/evm/client/Charge.js

@@ -34,7 +34,7 @@ export function charge(parameters) {
                     context,
                 });
             const account = (context?.account ?? parameters.account);
-            if (!account.signTypedData)
+            if (!account?.signTypedData)
                 throw new Error('EVM authorization requires a typed-data signer.');
             const request = challenge.request;
             assertPolicy(parameters, request);

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

@@ -1,5 +1,6 @@
 import type * as Credential from '../../Credential.js';
 import * as Method from '../../Method.js';
+import * as ServerTransport from '../../server/Transport.js';
 import * as X402 from '../../x402/server/EvmCharge.js';
 import * as Assets from '../Assets.js';
 import * as Methods from '../Methods.js';
@@ -8,11 +9,15 @@ import * as Types from '../Types.js';
  * Creates an EVM charge server method.
  *
  * Speaks the native Payment-auth `evm/charge` wire format.
+ * Supports non-mutating `validateCredential` checks before settlement through
+ * `broadcastCredential`. Validation checks the signature and payment terms, and
+ * checks the facilitator when using facilitator-backed settlement. Custom
+ * settlers remain responsible for chain-state checks and replay protection.
  */
-export declare function charge(parameters: charge.NativeConfig): Method.Server<typeof Methods.charge, charge.Defaults>;
+export declare function charge(parameters: charge.NativeConfig): Method.Server<typeof Methods.charge, charge.Defaults, ServerTransport.Http>;
 export declare namespace charge {
     type Parameters = NativeConfig;
-    type Native = Method.Server<typeof Methods.charge, Defaults>;
+    type Native = Method.Server<typeof Methods.charge, Defaults, ServerTransport.Http>;
     type NativeConfig = BaseConfig & CurrencyConfig & RecipientConfig & Method.ComposableHooks<typeof Methods.charge>;
     type BaseConfig = {
         /** EIP-3009 token domain metadata. Required for raw addresses and viem tokens; inferred for known assets. */

package/dist/evm/server/Charge.js

@@ -22,7 +22,7 @@ export function charge(parameters) {
             recipient: config.recipient,
         },
         transport,
-        async verify({ credential }) {
+        async validate({ credential }) {
             const payload = credential.payload;
             const request = credential.challenge.request;
             const chainId = request.methodDetails.chainId;
@@ -70,11 +70,34 @@ export function charge(parameters) {
             if (credential.source && credential.source !== source) {
                 throw new VerificationFailedError({ reason: 'EVM authorization source mismatch' });
             }
-            const settled = await config.settle({
+            const authorization = {
                 credential,
                 payload,
                 request,
                 source,
+            };
+            await config.validate?.(authorization);
+            return {
+                challenge: credential.challenge,
+                credential,
+                details: { payer: getAddress(payload.from) },
+                intent: Methods.charge.intent,
+                method: Methods.charge.name,
+                request: credential.challenge.request,
+                source,
+            };
+        },
+        async broadcast({ credential }) {
+            const payload = credential.payload;
+            const request = credential.challenge.request;
+            const settled = await config.settle({
+                credential,
+                payload,
+                request,
+                source: Types.toSource({
+                    address: getAddress(payload.from),
+                    chainId: request.methodDetails.chainId,
+                }),
             });
             return Receipt.from({
                 method: Types.paymentMethod,
@@ -133,6 +156,9 @@ function resolveConfig(config) {
         decimals,
         recipient: getAddress(recipient),
         settle,
+        validate: !config.settle && x402.facilitator
+            ? (parameters) => X402.verifyWithFacilitator(x402, parameters)
+            : undefined,
         x402,
     };
 }

package/dist/evm/server/Methods.d.ts

@@ -67,7 +67,7 @@ export declare function evm<const parameters extends evm.Parameters>(parameters:
             }[] | undefined;
         }>>;
     };
-}, charge_.Defaults, undefined, {}, string | undefined>];
+}, charge_.Defaults, import("../../server/Transport.js").Http, {}, string | undefined>];
 export declare namespace evm {
     type Parameters = charge_.Parameters;
     /** Creates an EVM `charge` server method. */

package/dist/internal/version.d.ts

@@ -0,0 +1,5 @@
+/** Current mppx package version. */
+export declare const version = "0.10.0";
+/** Canonical SDK identifier for this mppx release. */
+export declare const sdkIdentifier = "mppx/0.10.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/internal/version.js

@@ -0,0 +1,6 @@
+// Generated by scripts/sync-version.ts.
+/** Current mppx package version. */
+export const version = '0.10.0';
+/** Canonical SDK identifier for this mppx release. */
+export const sdkIdentifier = `mppx/${version}`;
+//# sourceMappingURL=version.js.map

package/dist/server/Mppx.d.ts

@@ -134,15 +134,16 @@ export type Mppx<methods extends Methods = Methods, transport extends Transport.
     onPaymentFailed(handler: ServerEventHandler<FlattenMethods<methods>, transport, 'payment.failed'>): Unsubscribe;
     /** Register a handler for successful verified payments. */
     onPaymentSuccess(handler: ServerEventHandler<FlattenMethods<methods>, transport, 'payment.success'>): Unsubscribe;
-} & (transport extends Transport.Http ? {
+} & (transport extends Transport.Http | Transport.Mcp | Transport.McpSdk ? {
     /**
      * Combines multiple method handlers into a single route handler that presents
-     * all methods to the client via multiple `WWW-Authenticate` headers.
+     * all methods through HTTP headers or an MCP payment-required challenge list.
      *
      * Each entry is a `[method, options]` tuple where `method` is one of the
      * server methods passed to `Mppx.create()`, looked up by `name`+`intent`.
      *
-     * Only available on HTTP transports.
+     * Available on HTTP, MCP JSON-RPC, and MCP SDK transports. MCP handlers
+     * accept the transport's input and return its challenge and receipt types.
      * No-credential authorize hooks run in entry order; the first 200 response
      * wins, and earlier hooks may have already run side effects.
      *
@@ -174,7 +175,7 @@ export type Mppx<methods extends Methods = Methods, transport extends Transport.
      * })
      * ```
      */
-    compose(...entries: ComposeEntry<FlattenMethods<methods>>[]): ComposedHandler;
+    compose(...entries: ComposeEntry<FlattenMethods<methods>>[]): ComposedHandler<transport>;
 } : {}) & Handlers<FlattenMethods<methods>, transport> & {
     /**
      * Generate Challenge objects for registered methods without going through
@@ -364,7 +365,7 @@ declare namespace MethodFn {
     };
 }
 /** A configured handler — the return value of e.g. `mppx.charge({ ... })`. @internal */
-type ConfiguredHandler = ((input: Request) => Promise<MethodFn.Response<Transport.Http>>) & {
+type ConfiguredHandler<transport extends Transport.AnyTransport = Transport.Http> = ((input: Transport.InputOf<transport>) => Promise<MethodFn.Response<transport>>) & {
     _internal: {
         _method: Method.AnyServer;
         description?: string | undefined;
@@ -377,7 +378,7 @@ type ConfiguredHandler = ((input: Request) => Promise<MethodFn.Response<Transpor
         _stableBinding?: Method.StableBindingFn<Method.Method> | undefined;
     };
 };
-type ComposedHandler = ((input: Request) => Promise<MethodFn.Response<Transport.Http>>) & {
+type ComposedHandler<transport extends Transport.AnyTransport = Transport.Http> = ((input: Transport.InputOf<transport>) => Promise<MethodFn.Response<transport>>) & {
     _internal?: {
         offers: readonly ConfiguredHandler['_internal'][];
     };

package/dist/server/Mppx.js

@@ -7,6 +7,7 @@ import * as Errors from '../Errors.js';
 import * as Expires from '../Expires.js';
 import * as AcceptPayment from '../internal/AcceptPayment.js';
 import * as Env from '../internal/env.js';
+import * as Mcp from '../Mcp.js';
 import * as PaymentRequest from '../PaymentRequest.js';
 import * as x402_Header from '../x402/Header.js';
 import * as x402_Types from '../x402/Types.js';
@@ -70,6 +71,7 @@ export function create(config) {
             serverEvents.on('payment.success', (async (ctx) => {
                 if (ctx.method.name === mi.name && ctx.method.intent === mi.intent) {
                     await mi.onPaymentSuccess({
+                        challenge: ctx.challenge,
                         input: ctx.input,
                         receipt: ctx.receipt,
                         request: ctx.request,
@@ -339,8 +341,9 @@ export function create(config) {
     }
     const verifyCredentialFn = broadcastCredentialFn;
     function composeFn(...entries) {
-        if (transport.name !== 'http')
-            throw new Error('compose() only supports HTTP transport');
+        const isMcp = transport.name === 'mcp' || transport.name === 'mcp-sdk';
+        if (transport.name !== 'http' && !isMcp)
+            throw new Error('compose() only supports HTTP and MCP transports');
         if (entries.length === 0)
             throw new Error('compose() requires at least one entry');
         const configured = entries.map(([methodOrKey, options]) => {
@@ -352,8 +355,15 @@ export function create(config) {
             const handlerFn = handlers[key];
             if (!handlerFn)
                 throw new Error(`No handler for "${key}". Is this method in your methods array?`);
+            const method = handlerFn._method;
+            if (isMcp && method?.transport && method.transport.name !== transport.name)
+                throw new Error('MCP compose() requires methods using the configured MCP transport');
+            if (isMcp && method?.canOffer)
+                throw new Error('MCP compose() does not support HTTP canOffer hooks');
             return handlerFn(options);
         });
+        if (isMcp)
+            return composeMcpHandlers(configured, transport);
         return composeHandlers(configured, undefined, selectOffers);
     }
     function onChallengeCreated(handler) {
@@ -1657,6 +1667,78 @@ function getConfiguredOffers(handler) {
         return internal.offers;
     return [internal];
 }
+/** Dispatches one MCP credential or gathers unsigned offers in their configured order. */
+function composeMcpHandlers(handlers, transport) {
+    return async (input) => {
+        let credential;
+        try {
+            const parsed = transport.getCredential(input);
+            credential = parsed ? hydrateCredentialMeta(parsed) : null;
+        }
+        catch {
+            // Let the method emit the normal malformed-credential error and retry challenge.
+            return handlers[0](input);
+        }
+        if (credential) {
+            const candidates = handlers.filter((handler) => {
+                const internal = handler._internal;
+                return (internal.name === credential.challenge.method &&
+                    internal.intent === credential.challenge.intent);
+            });
+            const match = candidates.find((handler) => {
+                const internal = handler._internal;
+                try {
+                    const mismatch = internal._stableBinding
+                        ? getRequestBindingMismatch(getStableBinding(internal._canonicalRequest, internal._stableBinding), getStableBinding(credential.challenge.request, internal._stableBinding))
+                        : getPinnedRequestBindingMismatch(internal._canonicalRequest, credential.challenge.request);
+                    return !mismatch && opaqueValuesMatch(internal.meta, credential.challenge.meta);
+                }
+                catch {
+                    return false;
+                }
+            });
+            // Verification and settlement belong to exactly one handler, including failures.
+            return (match ?? candidates[0] ?? handlers[0])(input);
+        }
+        const challenges = [];
+        let first;
+        for (const handler of handlers) {
+            const result = await handler(input);
+            if (result.status === 200)
+                return result;
+            const response = result.challenge;
+            const error = 'code' in response ? response : response.error;
+            // Request-hook and configuration failures must retain their original error semantics.
+            if (!error || error.code !== Mcp.paymentRequiredCode)
+                return result;
+            const data = error.data;
+            if (!data?.challenges?.length)
+                return result;
+            first ??= response;
+            challenges.push(...data.challenges);
+        }
+        if (!first)
+            throw new Error('compose() requires at least one handler');
+        if ('code' in first) {
+            const { McpError } = await import('@modelcontextprotocol/sdk/types.js');
+            return {
+                status: 402,
+                challenge: new McpError(first.code, 'Payment Required', {
+                    ...first.data,
+                    challenges,
+                }),
+            };
+        }
+        return {
+            status: 402,
+            challenge: {
+                jsonrpc: first.jsonrpc,
+                id: first.id,
+                error: { ...first.error, data: { ...first.error.data, challenges } },
+            },
+        };
+    };
+}
 function isComposedHandlerMetadata(internal) {
     return 'offers' in internal && !('_canonicalRequest' in internal);
 }

package/dist/server/internal/html/config.js

@@ -106,9 +106,7 @@ export function render(options) {
                 ${data.challenge.description
             ? `data-description="${sanitize(data.challenge.description)}"`
             : ''}
-                ${data.challenge.expires
-            ? `data-expires="${sanitize(data.challenge.expires)}"`
-            : ''}
+                ${data.challenge.expires ? `data-expires="${sanitize(data.challenge.expires)}"` : ''}
                 ${data.challenge.expires ? `data-expires-label="${sanitize(text.expires)}"` : ''}
               >
                 ${sanitize(data.label)}

package/dist/stripe/Methods.d.ts

@@ -1,4 +1,5 @@
 import * as z from '../zod.js';
+import * as PaymentIntent from './internal/payment-intent.js';
 /**
  * Stripe charge intent for one-time payments via Shared Payment Tokens (SPTs).
  *
@@ -22,7 +23,7 @@ export declare const charge: {
             externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
             metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
             networkId: z.ZodMiniString<string>;
-            paymentIntentOptions: z.ZodMiniOptional<z.ZodMiniObject<{
+            paymentIntentOptions: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
                 customer: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 hooks: z.ZodMiniOptional<z.ZodMiniObject<{
                     inputs: z.ZodMiniObject<{
@@ -33,7 +34,7 @@ export declare const charge: {
                 }, z.core.$strip>>;
                 metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
                 receipt_email: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodMiniCustom<PaymentIntent.ResolveOptions, PaymentIntent.ResolveOptions>]>>;
             paymentMethodTypes: z.ZodMiniArray<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
@@ -55,7 +56,7 @@ export declare const charge: {
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
-            paymentIntentOptions?: {
+            paymentIntentOptions?: PaymentIntent.ResolveOptions | {
                 customer?: string | undefined;
                 hooks?: {
                     inputs: {

package/dist/stripe/Methods.js

@@ -1,6 +1,6 @@
-import { parseUnits } from 'viem';
 import * as Method from '../Method.js';
 import * as z from '../zod.js';
+import { parseUnits } from './internal/parse-units.js';
 import * as PaymentIntent from './internal/payment-intent.js';
 /**
  * Stripe charge intent for one-time payments via Shared Payment Tokens (SPTs).
@@ -25,18 +25,21 @@ export const charge = Method.from({
             externalId: z.optional(z.string()),
             metadata: z.optional(z.record(z.string(), z.string())),
             networkId: z.string(),
-            paymentIntentOptions: z.optional(PaymentIntent.Schema),
+            paymentIntentOptions: z.optional(PaymentIntent.InputSchema),
             paymentMethodTypes: z.array(z.string()).check(z.minLength(1)),
             recipient: z.optional(z.string()),
-        }), z.transform(({ amount, decimals, metadata, networkId, paymentIntentOptions: _, paymentMethodTypes, ...rest }) => ({
-            ...rest,
-            amount: parseUnits(amount, decimals).toString(),
-            methodDetails: {
-                networkId,
-                paymentMethodTypes,
-                ...(metadata !== undefined && { metadata }),
-            },
-        }))),
+        }), z.transform(({ amount, decimals, metadata, networkId, paymentIntentOptions, paymentMethodTypes, ...rest }) => {
+            void paymentIntentOptions;
+            return {
+                ...rest,
+                amount: parseUnits(amount, decimals).toString(),
+                methodDetails: {
+                    networkId,
+                    paymentMethodTypes,
+                    ...(metadata !== undefined && { metadata }),
+                },
+            };
+        })),
     },
 });
 //# sourceMappingURL=Methods.js.map