mppx 0.9.1 → 0.9.3

package/dist/cli/plugins/plugin.d.ts

@@ -33,8 +33,8 @@ export interface Plugin {
         methods: Method.AnyClient[];
         /** Optional context to pass to createCredential */
         credentialContext?: unknown;
-        /** Override credential creation entirely (e.g., delegating to an external CLI) */
-        createCredential?: ((response: Response) => Promise<string>) | undefined;
+        /** Override credential creation entirely (e.g., delegating to an external CLI). */
+        createCredential?: ((response: Response, credentialContext?: unknown) => Promise<string>) | undefined;
     }>;
     /**
      * Modify the credential request before sending.

package/dist/cli/plugins/x402.d.ts

@@ -0,0 +1,3 @@
+/** Pays recognized x402 exact EVM challenges with the configured CLI account. */
+export declare function x402(): import("./plugin.js").Plugin;
+//# sourceMappingURL=x402.d.ts.map

package/dist/cli/plugins/x402.js

@@ -0,0 +1,61 @@
+import * as viemChains from 'viem/chains';
+import { evm as evmMethods, assets as evmAssets } from '../../evm/client/index.js';
+import * as Assets from '../../x402/Assets.js';
+import * as x402_ChallengeBrand from '../../x402/internal/ChallengeBrand.js';
+import { resolveAccount } from '../account.js';
+import { createPlugin } from './plugin.js';
+const knownAssets = [
+    ...Object.entries(evmAssets.base),
+    ...Object.entries(evmAssets.baseSepolia),
+    ...Object.entries(evmAssets.celo),
+    ...Object.entries(evmAssets.celoSepolia),
+];
+/** Pays recognized x402 exact EVM challenges with the configured CLI account. */
+export function x402() {
+    return createPlugin({
+        method: 'evm',
+        supports: isSupportedChallenge,
+        async setup({ challenge, options }) {
+            const request = challenge.request;
+            const chain = request.network ? resolveEvmChain(Assets.toChainId(request.network)) : undefined;
+            const known = request.network && request.asset
+                ? knownAssets.find(([, asset]) => Assets.matches(asset, request.asset, request.network))
+                : undefined;
+            const name = request.extra?.name;
+            const version = request.extra?.version;
+            const currency = request.asset && request.network && typeof name === 'string' && typeof version === 'string'
+                ? Assets.define({
+                    address: request.asset,
+                    decimals: known?.[1].decimals ?? 6,
+                    network: request.network,
+                    transfer: { name, type: 'eip3009', version },
+                })
+                : undefined;
+            const account = await resolveAccount(options.account);
+            return {
+                explorerUrl: chain?.blockExplorers?.default?.url,
+                methods: [...evmMethods({ account, ...(currency && { currencies: [currency] }) })],
+                tokenDecimals: known?.[1].decimals ?? 6,
+                tokenSymbol: known?.[0] ?? '',
+            };
+        },
+    });
+}
+/** Returns whether the CLI can create an x402 credential for this challenge. */
+function isSupportedChallenge(challenge) {
+    if (!x402_ChallengeBrand.is(challenge))
+        return false;
+    const request = challenge.request;
+    const transfer = request.extra;
+    const transferMethod = transfer?.assetTransferMethod;
+    return (request.scheme === 'exact' &&
+        typeof request.asset === 'string' &&
+        typeof request.network === 'string' &&
+        typeof transfer?.name === 'string' &&
+        typeof transfer?.version === 'string' &&
+        (transferMethod === undefined || transferMethod === 'eip3009'));
+}
+function resolveEvmChain(chainId) {
+    return Object.values(viemChains).find((chain) => chain.id === chainId);
+}
+//# sourceMappingURL=x402.js.map

package/dist/cli/sessions/request.d.ts

@@ -17,6 +17,7 @@ export type PersistentSessionRequestOptions = {
 export type PersistentSessionRequestParameters = {
     challenge: TempoSessionChallenge;
     challengeResponse: Response;
+    credentialContext?: unknown;
     endpoint: string;
     fetch: typeof globalThis.fetch;
     fetchInput: RequestInfo | URL;

package/dist/cli/sessions/request.js

@@ -198,6 +198,7 @@ export async function runPersistentSessionRequest(parameters) {
             bootstrap: false,
             client,
             channelStore,
+            credentialContext: parameters.credentialContext,
             decimals: sessionDecimals(parameters.challenge),
             maxDeposit: resolveSessionMaxDeposit(parameters.challenge, parameters.methodOptions, isTestnet(chain)),
             fetch: async (input, init) => {

package/dist/cli/validate/payment.js

@@ -12,7 +12,7 @@ import * as Receipt from '../../Receipt.js';
 import { tempo as tempoMethods } from '../../tempo/client/index.js';
 import { chainId as tempoChainIds } from '../../tempo/internal/defaults.js';
 import { resolveAccount, resolveAccountName } from '../account.js';
-import { loadConfig, resolvePlugin } from '../internal.js';
+import { loadConfig, preparePayment, resolvePlugin } from '../internal.js';
 import { fetchTokenInfo, confirm, pc } from '../utils.js';
 import { buildUrl } from './discovery.js';
 import { check, fail, fetchWithTimeout, formatBytes, isValidIntegerAmount, parseHeaders, skip, warn, } from './helpers.js';
@@ -151,6 +151,7 @@ export async function validatePaymentFlow(baseUrl, endpoint, verbose, options) {
         results.push(fail('Payment: parse challenge', 'No Payment challenges in response'));
         return results;
     }
+    const loaded = await loadConfig().catch(() => undefined);
     // Testnet Tempo: always use ephemeral wallet (zero-setup, free money)
     const tempoTestnetChallenge = challenges.find((ch) => {
         if (ch.method !== Constants.Methods.tempo)
@@ -170,7 +171,8 @@ export async function validatePaymentFlow(baseUrl, endpoint, verbose, options) {
             });
             try {
                 const mppx = Mppx.create({ methods: provisioned.methods, polyfill: false });
-                const cred = await mppx.createCredential(fakeResp);
+                const credentialContext = await preparePayment(tempoTestnetChallenge, loaded?.config.extensions);
+                const cred = await mppx.createCredential(fakeResp, credentialContext);
                 results.push(check('Payment: submitted', 'ephemeral testnet wallet'));
                 await sendAndValidateResponse(results, url, endpoint, cred, fetchHeaders, fetchBody, verbose, tempoModerato);
             }
@@ -185,7 +187,6 @@ export async function validatePaymentFlow(baseUrl, endpoint, verbose, options) {
     }
     // Try each remaining challenge method (tempo testnet already handled above),
     // so validate exercises every payment method the server offers, same as mainnet.
-    const loaded = await loadConfig().catch(() => undefined);
     const isInteractive = options.interactive;
     const stripeKey = process.env.MPPX_STRIPE_SECRET_KEY ?? resolveStripeKey(verbose);
     const isStripeTestKey = stripeKey?.startsWith('sk_test_') || stripeKey?.startsWith('rk_test_');
@@ -338,6 +339,7 @@ async function attemptCryptoPayment(challenge, tag, ctx) {
     }
     let methods;
     let createCredentialFn;
+    let credentialContext;
     if (plugin) {
         try {
             const pluginResult = await plugin.setup({
@@ -347,6 +349,7 @@ async function attemptCryptoPayment(challenge, tag, ctx) {
             });
             methods = pluginResult.methods;
             createCredentialFn = pluginResult.createCredential;
+            credentialContext = pluginResult.credentialContext;
         }
         catch (error) {
             results.push(skip(tag, error.message));
@@ -356,7 +359,7 @@ async function attemptCryptoPayment(challenge, tag, ctx) {
     else {
         methods = [directMethod];
     }
-    const credential = await createAndSend(challenge, methods, createCredentialFn, tag, results);
+    const credential = await createAndSend(challenge, methods, createCredentialFn, tag, results, loaded?.config.extensions, credentialContext);
     if (!credential)
         return;
     plugin?.prepareCredentialRequest?.({ challenge, credential, headers: fetchHeaders });
@@ -401,6 +404,7 @@ async function attemptStripePayment(challenge, tag, ctx) {
     }
     let methods;
     let createCredentialFn;
+    let credentialContext;
     try {
         const methodOpts = { paymentMethod: 'pm_card_visa' };
         if (stripeKey)
@@ -412,12 +416,13 @@ async function attemptStripePayment(challenge, tag, ctx) {
         });
         methods = pluginResult.methods;
         createCredentialFn = pluginResult.createCredential;
+        credentialContext = pluginResult.credentialContext;
     }
     catch (error) {
         results.push(skip(tag, error.message));
         return;
     }
-    const credential = await createAndSend(challenge, methods, createCredentialFn, tag, results);
+    const credential = await createAndSend(challenge, methods, createCredentialFn, tag, results, loaded?.config.extensions, credentialContext);
     if (!credential)
         return;
     plugin.prepareCredentialRequest?.({ challenge, credential, headers: fetchHeaders });
@@ -438,19 +443,20 @@ async function attemptStripePayment(challenge, tag, ctx) {
     }
     await sendAndValidateResponse(results, url, endpoint, credential, fetchHeaders, fetchBody, verbose, undefined);
 }
-async function createAndSend(challenge, methods, createCredentialFn, tag, results) {
+async function createAndSend(challenge, methods, createCredentialFn, tag, results, extensions, initialCredentialContext) {
     const fakeResponse = new Response(null, {
         status: 402,
         headers: { [Constants.Headers.wwwAuthenticate]: Challenge.serialize(challenge) },
     });
     try {
+        const credentialContext = await preparePayment(challenge, extensions, initialCredentialContext);
         let credential;
         if (createCredentialFn) {
-            credential = await createCredentialFn(fakeResponse);
+            credential = await createCredentialFn(fakeResponse, credentialContext);
         }
         else {
             const mppx = Mppx.create({ methods, polyfill: false });
-            credential = await mppx.createCredential(fakeResponse);
+            credential = await mppx.createCredential(fakeResponse, credentialContext);
         }
         results.push(check(`${tag}: submitted`));
         return credential;

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.9.3";
+/** Canonical SDK identifier for this mppx release. */
+export declare const sdkIdentifier = "mppx/0.9.3";
+//# 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.9.3';
+/** Canonical SDK identifier for this mppx release. */
+export const sdkIdentifier = `mppx/${version}`;
+//# sourceMappingURL=version.js.map

package/dist/middlewares/internal/mppx.js

@@ -21,9 +21,23 @@ export function wrap(mppx, wrapper) {
         };
         Object.assign(wrapWithMeta, methodFn);
         result[key] = wrapWithMeta;
-        // Also set shorthand intent key if Mppx registered it (no collision)
-        if (!reservedMppxKeys.has(mi.intent) && mppx[mi.intent])
-            result[mi.intent] = wrapWithMeta;
+        // Also set shorthand intent key, using the core-composed handler on collisions.
+        if (!reservedMppxKeys.has(mi.intent) && mppx[mi.intent]) {
+            const intentFn = mppx[mi.intent];
+            if (intentFn === methodFn)
+                result[mi.intent] = wrapWithMeta;
+            else {
+                const wrapIntentWithMeta = (options) => {
+                    const configured = intentFn(options);
+                    const handler = wrapper(intentFn, options);
+                    if (configured._internal)
+                        handler._internal = configured._internal;
+                    return handler;
+                };
+                Object.assign(wrapIntentWithMeta, intentFn);
+                result[mi.intent] = wrapIntentWithMeta;
+            }
+        }
         // Build nested handlers: wrapped.tempo.charge(...)
         if (!result[mi.name] || typeof result[mi.name] !== 'object')
             result[mi.name] = {};

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,9 +23,18 @@ 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<{
-                metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
-            }, z.core.$strip>>;
+            paymentIntentOptions: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+                customer: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                hooks: z.ZodMiniOptional<z.ZodMiniObject<{
+                    inputs: z.ZodMiniObject<{
+                        tax: z.ZodMiniObject<{
+                            calculation: z.ZodMiniString<string>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                }, 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.ZodMiniCustom<PaymentIntent.ResolveOptions, PaymentIntent.ResolveOptions>]>>;
             paymentMethodTypes: z.ZodMiniArray<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
@@ -46,8 +56,17 @@ export declare const charge: {
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
-            paymentIntentOptions?: {
-                metadata: Record<string, string>;
+            paymentIntentOptions?: PaymentIntent.ResolveOptions | {
+                customer?: string | undefined;
+                hooks?: {
+                    inputs: {
+                        tax: {
+                            calculation: string;
+                        };
+                    };
+                } | undefined;
+                metadata?: Record<string, string> | undefined;
+                receipt_email?: string | undefined;
             } | undefined;
             paymentMethodTypes: string[];
             recipient?: string | undefined;

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