mppx 0.11.0 → 0.13.1

package/dist/cli/plugins/tempo.js

@@ -12,7 +12,7 @@ import * as Constants from '../../Constants.js';
 import * as Credential from '../../Credential.js';
 import { tempo as tempoMethods } from '../../tempo/client/index.js';
 import { tip20ChannelEscrow } from '../../tempo/session/precompile/Protocol.js';
-import { signVoucher } from '../../tempo/session/precompile/Voucher.js';
+import { signCloseAuthorization, signVoucher } from '../../tempo/session/precompile/Voucher.js';
 import { createDefaultStore, createKeychain, resolveAccountName } from '../account.js';
 import { fetchTokenInfo, fmtBalance, isTempoAccount, isTestnet, link, pc, resolveChain, resolveRpcUrl, } from '../utils.js';
 import { createPlugin } from './plugin.js';
@@ -227,14 +227,21 @@ export function tempo() {
                     const descriptor = _session?.descriptor;
                     if (!descriptor)
                         throw new Error('session descriptor not available');
+                    const voucher = { channelId: channelId, cumulativeAmount };
+                    const signature = await signVoucher(client, account, voucher, escrowContract, chainId);
                     return Credential.serialize({
                         challenge,
                         payload: {
                             action,
                             channelId,
+                            ...(action === 'close'
+                                ? {
+                                    closeSignature: await signCloseAuthorization(client, account, voucher, escrowContract, chainId),
+                                }
+                                : {}),
                             descriptor,
                             cumulativeAmount: cumulativeAmount.toString(),
-                            signature: await signVoucher(client, account, { channelId: channelId, cumulativeAmount }, escrowContract, chainId),
+                            signature,
                         },
                         source: `did:pkh:eip155:${chainId}:${account.address}`,
                     });

package/dist/cli/utils.d.ts

@@ -96,7 +96,17 @@ 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 function isTestnet(chain: Chain): boolean;
-export declare function fetchTokenInfo(client: ReturnType<typeof createClient>, token: Address, account: Address): Promise<{
+/**
+ * Fetches a Tempo token balance and display metadata.
+ *
+ * By default, unavailable decimals fall back to six for display compatibility.
+ * Set `requireDecimals` to throw instead when trusted on-chain decimals cannot
+ * be resolved.
+ */
+export declare function fetchTokenInfo(client: ReturnType<typeof createClient>, token: Address, account: Address, options?: {
+    /** Throws instead of using six decimals when token metadata is unavailable. */
+    requireDecimals?: boolean;
+}): Promise<{
     balance: bigint;
     decimals: number;
     symbol: string;

package/dist/cli/utils.js

@@ -259,14 +259,25 @@ function toBaseUnitAmount(value) {
 export function isTestnet(chain) {
     return chain.id !== tempoMainnet.id;
 }
-export async function fetchTokenInfo(client, token, account) {
+/**
+ * Fetches a Tempo token balance and display metadata.
+ *
+ * By default, unavailable decimals fall back to six for display compatibility.
+ * Set `requireDecimals` to throw instead when trusted on-chain decimals cannot
+ * be resolved.
+ */
+export async function fetchTokenInfo(client, token, account, options = {}) {
     const { Actions } = await import('viem/tempo');
     const [balance, metadata] = await Promise.all([
         Actions.token
             .getBalance(client, { account, token })
             .then(toBaseUnitAmount)
             .catch(() => 0n),
-        Actions.token.getMetadata(client, { token }).catch(() => ({ symbol: token })),
+        Actions.token.getMetadata(client, { token }).catch((error) => {
+            if (options.requireDecimals)
+                throw error;
+            return { symbol: token };
+        }),
     ]);
     const knownSymbols = {
         [pathUsd]: 'PathUSD',
@@ -274,6 +285,8 @@ export async function fetchTokenInfo(client, token, account) {
     };
     const symbol = knownSymbols[token] ?? metadata.symbol;
     const decimals = 'decimals' in metadata && typeof metadata.decimals === 'number' ? metadata.decimals : 6;
+    if (options.requireDecimals && !('decimals' in metadata && typeof metadata.decimals === 'number'))
+        throw new Error('Token decimals are unavailable.');
     return { balance, symbol, decimals, token };
 }
 export async function fetchBalanceLines(address, opts) {

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

@@ -11,6 +11,8 @@ export declare function validateChallenge(baseUrl: string, endpoint: EndpointSpe
     resolvedBody?: string | undefined;
     challenges?: Challenge.Challenge[] | undefined;
 }>;
+/** Validates that challenge realms cover the server hostname. */
+export declare function validateRealmMatchesHost(challenges: Challenge.Challenge[], serverHost: string, results: CheckResult[]): void;
 export declare function validateErrorHandling(baseUrl: string, endpoint: EndpointSpec, options?: {
     body?: string | undefined;
     query?: string[] | undefined;

package/dist/cli/validate/challenge.js

@@ -15,7 +15,14 @@ function detectTestnet(challenge) {
 }
 export async function validateChallenge(baseUrl, endpoint, verbose, options) {
     const results = [];
-    const url = buildUrl(baseUrl, endpoint, options?.query);
+    let url;
+    try {
+        url = buildUrl(baseUrl, endpoint, options?.query);
+    }
+    catch (error) {
+        results.push(fail('Request URL valid', error.message));
+        return { results };
+    }
     const fetchHeaders = parseHeaders(options?.extraHeaders);
     let fetchBody;
     // If the user explicitly provided a body, include it on the first request
@@ -167,11 +174,19 @@ function validateExpiration(challenges, results) {
     const soonest = Math.min(...challenges.map((ch) => new Date(ch.expires).getTime() - now.getTime()));
     results.push(check('Challenge expires in the future', `${Math.round(soonest / 60000)}m from now`));
 }
-function validateRealmMatchesHost(challenges, serverHost, results) {
+/** Validates that challenge realms cover the server hostname. */
+export function validateRealmMatchesHost(challenges, serverHost, results) {
+    const normalizeHostname = (value) => value.toLowerCase().replace(/\.$/, '');
+    const normalizedServerHost = normalizeHostname(serverHost);
     const realms = [...new Set(challenges.map((ch) => ch.realm ?? ''))];
-    const badRealms = realms.filter((r) => r && r !== serverHost && !serverHost.endsWith(`.${r}`));
+    const badRealms = realms.filter((realm) => {
+        const normalizedRealm = normalizeHostname(realm);
+        return (!normalizedRealm ||
+            (normalizedRealm !== normalizedServerHost &&
+                !normalizedServerHost.endsWith(`.${normalizedRealm}`)));
+    });
     if (badRealms.length > 0) {
-        results.push(warn('Realm matches server hostname', `realm="${badRealms[0]}" vs host="${serverHost}"`, 'Set the realm to your production hostname (or base domain) in the challenge.'));
+        results.push(fail('Realm matches server hostname', `realm="${badRealms[0]}" vs host="${serverHost}"`, 'Set the realm to your production hostname (or base domain) in the challenge.'));
     }
     else {
         results.push(check('Realm matches server hostname'));

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

@@ -9,5 +9,6 @@ export declare function fetchDiscoveryDoc(baseUrl: string): Promise<{
 export declare function validateLlmsDoc(baseUrl: string): Promise<CheckResult>;
 export declare function extractEndpointsFromDiscovery(doc: Record<string, unknown>): EndpointSpec[];
 export declare function extractRequestBodyFromDiscovery(doc: Record<string, unknown>, endpoint: EndpointSpec): string | undefined;
+/** Builds an endpoint URL and rejects paths that could escape the discovery document's origin. */
 export declare function buildUrl(baseUrl: string, endpoint: EndpointSpec, query?: string[]): string;
 //# sourceMappingURL=discovery.d.ts.map

package/dist/cli/validate/discovery.js

@@ -117,14 +117,23 @@ export function extractRequestBodyFromDiscovery(doc, endpoint) {
     }
     return undefined;
 }
+/** Builds an endpoint URL and rejects paths that could escape the discovery document's origin. */
 export function buildUrl(baseUrl, endpoint, query) {
+    if (!endpoint.path.startsWith('/') ||
+        endpoint.path.startsWith('//') ||
+        endpoint.path.includes('\\'))
+        throw new Error(`OpenAPI path must be an origin-relative path: ${endpoint.path}`);
     let path = endpoint.path;
     if (endpoint.parameters) {
         path = substitutePathParams(path, endpoint.parameters);
     }
     // Strip leading slash so URL resolves relative to baseUrl's path, not root.
     const relativePath = path.startsWith('/') ? path.slice(1) : path;
-    let url = new URL(relativePath, baseUrl.replace(/\/?$/, '/')).href;
+    const base = new URL(baseUrl.replace(/\/?$/, '/'));
+    const resolved = new URL(relativePath, base);
+    if (resolved.origin !== base.origin)
+        throw new Error(`OpenAPI path must be an origin-relative path: ${endpoint.path}`);
+    let url = resolved.href;
     if (query) {
         const u = new URL(url);
         for (const q of query) {

package/dist/cli/validate/payment.js

@@ -1,5 +1,5 @@
 import * as childProcess from 'node:child_process';
-import { createClient, erc20Abi, http } from 'viem';
+import { createClient, erc20Abi, http, isAddress, zeroAddress, } from 'viem';
 import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
 import { readContract, waitForTransactionReceipt } from 'viem/actions';
 import * as viemChains from 'viem/chains';
@@ -15,6 +15,7 @@ import { isTempoSessionChallenge } from '../../tempo/session/client/Transports.j
 import { resolveAccount, resolveAccountName } from '../account.js';
 import { assertSamePaymentRequest, flattenConfigMethods, loadConfig, preparePayment, resolvePlugin, } from '../internal.js';
 import { fetchTokenInfo, confirm, pc } from '../utils.js';
+import { validateRealmMatchesHost } from './challenge.js';
 import { buildUrl } from './discovery.js';
 import { check, fail, fetchWithTimeout, formatBytes, isValidIntegerAmount, parseHeaders, skip, warn, } from './helpers.js';
 async function provisionAndPayTestnet(challenge, verbose, silent) {
@@ -24,6 +25,16 @@ async function provisionAndPayTestnet(challenge, verbose, silent) {
         const key = generatePrivateKey();
         const account = privateKeyToAccount(key);
         const client = createClient({ chain: tempoModerato, transport: http() });
+        if (isTempoSessionChallenge(challenge)) {
+            const { chainId, operator } = challenge.request.methodDetails ?? {};
+            if (chainId === tempoModerato.id &&
+                typeof operator === 'string' &&
+                isAddress(operator) &&
+                operator !== zeroAddress) {
+                const hashes = await Actions.faucet.fund(client, { account: operator });
+                await Promise.all(hashes.map((hash) => waitForTransactionReceipt(client, { hash })));
+            }
+        }
         const hashes = await Actions.faucet.fund(client, { account });
         await Promise.all(hashes.map((hash) => waitForTransactionReceipt(client, { hash })));
         if (!silent)
@@ -85,16 +96,19 @@ function resolveStripeKey(verbose) {
 }
 async function fetchEvmTokenInfo(chain, token, account) {
     const client = createClient({ chain, transport: http() });
-    const [balance, symbol] = await Promise.all([
-        readContract(client, {
-            address: token,
-            abi: erc20Abi,
-            functionName: 'balanceOf',
-            args: [account],
-        }),
+    const [balance, decimals, symbol] = await Promise.all([
+        account
+            ? readContract(client, {
+                address: token,
+                abi: erc20Abi,
+                functionName: 'balanceOf',
+                args: [account],
+            })
+            : 0n,
+        readContract(client, { address: token, abi: erc20Abi, functionName: 'decimals' }),
         readContract(client, { address: token, abi: erc20Abi, functionName: 'symbol' }).catch(() => undefined),
     ]);
-    return { balance, symbol: symbol ?? undefined };
+    return { balance, decimals, symbol: symbol ?? undefined };
 }
 function resolveEvmChain(chainId) {
     const all = Object.values(viemChains);
@@ -152,6 +166,14 @@ export async function validatePaymentFlow(baseUrl, endpoint, verbose, options) {
         results.push(fail('Payment: parse challenge', 'No Payment challenges in response'));
         return results;
     }
+    const realmResults = [];
+    validateRealmMatchesHost(challenges, new URL(url).hostname, realmResults);
+    const realmFailures = realmResults.filter((result) => result.severity === 'fail');
+    if (realmFailures.length > 0) {
+        results.push(...realmFailures);
+        options.onResults?.(realmFailures);
+        return results;
+    }
     const loaded = await loadConfig().catch(() => undefined);
     // Testnet Tempo: always use ephemeral wallet (zero-setup, free money)
     const tempoTestnetChallenge = challenges.find((ch) => {
@@ -166,18 +188,25 @@ export async function validatePaymentFlow(baseUrl, endpoint, verbose, options) {
     if (tempoTestnetChallenge) {
         const provisioned = await provisionAndPayTestnet(tempoTestnetChallenge, verbose, options.silent);
         if (provisioned) {
-            const fakeResp = new Response(null, {
-                status: 402,
-                headers: {
-                    [Constants.Headers.wwwAuthenticate]: Challenge.serialize(tempoTestnetChallenge),
-                },
-            });
             try {
-                const mppx = Mppx.create({ methods: provisioned.methods, polyfill: false });
-                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, Challenge.credentialHeader(tempoTestnetChallenge));
+                const mppx = Mppx.create({
+                    methods: provisioned.methods,
+                    polyfill: false,
+                    async onChallenge(challenge, { createCredential }) {
+                        assertSamePaymentRequest(tempoTestnetChallenge, challenge);
+                        const context = await preparePayment(challenge, loaded?.config.extensions);
+                        const credential = await createCredential(context);
+                        results.push(check('Payment: submitted', 'ephemeral testnet wallet'));
+                        return credential;
+                    },
+                    fetch: (input, init) => fetchWithTimeout(input, init ?? {}, 30_000),
+                });
+                const response = await mppx.fetch(url, {
+                    method: endpoint.method,
+                    headers: fetchHeaders,
+                    body: fetchBody ?? null,
+                });
+                await validatePaymentResponse(results, response, verbose, tempoModerato);
             }
             catch (error) {
                 results.push(fail('Payment: create credential', error.message));
@@ -257,7 +286,7 @@ async function attemptCryptoPayment(challenge, tag, ctx) {
     const requiredAmount = isValidIntegerAmount(request.amount)
         ? BigInt(request.amount)
         : undefined;
-    const decimals = methodDetails?.decimals ?? request.decimals ?? 6;
+    let decimals = methodDetails?.decimals ?? request.decimals ?? 6;
     const currency = request.currency;
     const { plugin, method: directMethod } = resolvePlugin(challenge, loaded?.config);
     if (!plugin && !directMethod) {
@@ -289,22 +318,30 @@ async function attemptCryptoPayment(challenge, tag, ctx) {
         if (chainId)
             paymentChain = resolveEvmChain(chainId);
     }
+    if (requiredAmount && currency && !paymentChain) {
+        results.push(skip(tag, 'unable to resolve payment chain and verify token decimals'));
+        return;
+    }
     let tokenSymbol;
-    if (walletAddress && requiredAmount && currency && paymentChain) {
+    if (requiredAmount && currency && paymentChain) {
         try {
             let balance;
             if (challenge.method === Constants.Methods.tempo) {
                 const client = createClient({ chain: paymentChain, transport: http() });
-                const info = await fetchTokenInfo(client, currency, walletAddress);
+                const info = await fetchTokenInfo(client, currency, (walletAddress ?? zeroAddress), {
+                    requireDecimals: true,
+                });
                 balance = info.balance;
+                decimals = info.decimals;
                 tokenSymbol = info.symbol;
             }
             else {
                 const info = await fetchEvmTokenInfo(paymentChain, currency, walletAddress);
                 balance = info.balance;
+                decimals = info.decimals;
                 tokenSymbol = info.symbol;
             }
-            if (balance < requiredAmount) {
+            if (walletAddress && balance < requiredAmount) {
                 const requiredDisplay = formatAmount(requiredAmount, decimals);
                 const balanceDisplay = formatAmount(balance, decimals);
                 const symbol = tokenSymbol ?? 'tokens';
@@ -315,6 +352,8 @@ async function attemptCryptoPayment(challenge, tag, ctx) {
         catch (e) {
             if (verbose)
                 console.log(pc.dim(`    Balance check skipped: ${e.message}`));
+            results.push(skip(tag, 'unable to verify token balance and decimals from the payment chain'));
+            return;
         }
     }
     // Prompt

package/dist/client/Methods.d.ts

@@ -4,6 +4,4 @@ export { subscription } from '../tempo/client/Subscription.js';
 export { session, tempo } from '../tempo/client/index.js';
 export { session as sessionMethod } from '../tempo/session/client/Session.js';
 export { sessionManager } from '../tempo/session/client/SessionManager.js';
-export { session as sessionLegacy } from '../tempo/legacy/client/index.js';
-export { sessionManager as sessionLegacyManager } from '../tempo/legacy/client/index.js';
 //# sourceMappingURL=Methods.d.ts.map

package/dist/client/Methods.js

@@ -4,6 +4,4 @@ export { subscription } from '../tempo/client/Subscription.js';
 export { session, tempo } from '../tempo/client/index.js';
 export { session as sessionMethod } from '../tempo/session/client/Session.js';
 export { sessionManager } from '../tempo/session/client/SessionManager.js';
-export { session as sessionLegacy } from '../tempo/legacy/client/index.js';
-export { sessionManager as sessionLegacyManager } from '../tempo/legacy/client/index.js';
 //# sourceMappingURL=Methods.js.map

package/dist/client/Mppx.js

@@ -181,6 +181,7 @@ export function create(config) {
                     context,
                     fetch: attestedFetch,
                     input: preparedHttp.replayRequest,
+                    signal: preparedHttp.replayRequest.signal,
                 });
             return payment.createCredential(context);
         });

package/dist/client/index.d.ts

@@ -1,7 +1,7 @@
 export * as Constants from '../Constants.js';
 export * as Expires from '../Expires.js';
 export * as Fetch from './internal/Fetch.js';
-export { evm, session, sessionManager, sessionMethod, sessionLegacy, sessionLegacyManager, stripe, tempo, } from './Methods.js';
+export { evm, session, sessionManager, sessionMethod, stripe, tempo } from './Methods.js';
 export { createChannelStore, createJsonChannelStore, entryKey, type ChannelStore, type JsonChannelKv, } from '../tempo/session/client/ChannelStore.js';
 export type { ChargeContext } from '../tempo/client/Charge.js';
 export type { ResolveAccount, ResolveAccountCall, ResolveAccountInfo, ResolveAccountOperation, } from '../tempo/client/ResolveAccount.js';

package/dist/client/index.js

@@ -1,7 +1,7 @@
 export * as Constants from '../Constants.js';
 export * as Expires from '../Expires.js';
 export * as Fetch from './internal/Fetch.js';
-export { evm, session, sessionManager, sessionMethod, sessionLegacy, sessionLegacyManager, stripe, tempo, } from './Methods.js';
+export { evm, session, sessionManager, sessionMethod, stripe, tempo } from './Methods.js';
 export { createChannelStore, createJsonChannelStore, entryKey, } from '../tempo/session/client/ChannelStore.js';
 export * as Mppx from './Mppx.js';
 export * as Transport from './Transport.js';

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

@@ -171,6 +171,8 @@ export declare function createEventDispatcher<methods extends readonly Method.An
 /** @internal */
 export declare function unwrapFetch(fetch: typeof globalThis.fetch): typeof globalThis.fetch;
 /** @internal */
+export declare function resolveRequestSignal(input: RequestInfo | URL, init: RequestInit | undefined): AbortSignal | undefined;
+/** @internal */
 export declare function validateCredentialHeaderValue(credential: string): void;
 /** @internal */
 /** @internal */

package/dist/client/internal/Fetch.js

@@ -122,6 +122,7 @@ export function from(config) {
                             context: credentialContext,
                             fetch: baseFetch,
                             input: paymentInput,
+                            signal: resolveRequestSignal(input, init),
                         }),
                     };
                     const promise = attempt
@@ -576,8 +577,13 @@ function cloneRequestInput(input) {
         return input;
     }
 }
-function resolveRequestSignal(input, init) {
-    return init?.signal ?? (input instanceof Request ? input.signal : undefined);
+/** @internal */
+export function resolveRequestSignal(input, init) {
+    if (init?.signal === null)
+        return undefined;
+    if (init?.signal !== undefined)
+        return init.signal;
+    return input instanceof Request ? input.signal : undefined;
 }
 /** @internal */
 function isWrappedFetch(fetch) {

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

@@ -7,6 +7,7 @@ export type HandlerParameters = {
     context?: unknown;
     fetch: typeof globalThis.fetch;
     input: RequestInfo | URL;
+    signal?: AbortSignal | undefined;
 };
 /** Internal client-method challenge hook. */
 export type Handler = (parameters: HandlerParameters) => MaybePromise<void>;

package/dist/evm/Types.js

@@ -87,7 +87,7 @@ export function authorizationDomain(parameters) {
 }
 /** Computes the Payment-auth EVM challenge hash used as the EIP-3009 nonce. */
 export function challengeHash(challenge) {
-    return Hash.keccak256(Bytes.fromString(`${challenge.id}${challenge.realm}`), {
+    return Hash.keccak256(Bytes.fromString(JSON.stringify([challenge.id, challenge.realm])), {
         as: 'Hex',
     });
 }

package/dist/evm/server/Charge.js

@@ -171,6 +171,7 @@ function createPaths(config) {
 function createMppPath() {
     const transport = ServerTransport.http();
     return {
+        credentialHeaders: transport.credentialHeaders ?? [],
         bindCredential: (options) => transport.bindCredential?.(options) ?? options.credential,
         captureRequest: transport.captureRequest,
         getCredential: transport.getCredential,
@@ -181,10 +182,14 @@ function createMppPath() {
 function httpTransport(paths) {
     return ServerTransport.from({
         name: 'evm-http',
+        credentialHeaders: [
+            ...new Set([...paths.mpp.credentialHeaders, ...paths.x402.credentialHeaders]),
+        ],
         captureRequest: paths.mpp.captureRequest,
         getCredential(input) {
             return paths.mpp.getCredential(input) ?? paths.x402.getCredential(input);
         },
+        matchCredential: paths.x402.matchCredential,
         bindCredential(options) {
             if (X402.isPendingCredential(options.credential))
                 return paths.x402.bindCredential(options);

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

@@ -2,8 +2,158 @@ import type { NoExtraKeys } from '../../internal/types.js';
 import * as Assets from '../Assets.js';
 import * as Chains from '../Chains.js';
 import { charge as charge_ } from './Charge.js';
-/** Creates EVM server methods from shared charge parameters. */
-export declare function evm<const parameters extends evm.Parameters>(parameters: NoExtraKeys<parameters, evm.Parameters>): readonly [import("../../Method.js").Server<{
+/**
+ * Creates ordered EVM charge offers from shared parameters.
+ *
+ * Pass `currencies: [token]` for one asset or an ordered list for multiple assets.
+ * Viem token definitions resolve against `chainId`; known assets carry their own
+ * network. Unsupported chain entries are skipped and duplicate chain/address
+ * pairs are removed. An empty resolved list throws.
+ *
+ * Token definitions need explicit EIP-3009 domain metadata. Use
+ * `evm.assets.fromToken(token, { chainId, transfer })` for per-token domains.
+ * A token registry entry alone does not establish EIP-3009 support.
+ *
+ * @example
+ * ```ts
+ * import { evm } from 'mppx/server'
+ *
+ * evm({
+ *   currencies: [evm.assets.base.USDC],
+ *   recipient: '0x742d35Cc6634c0532925a3b844bC9e7595F8fE00',
+ *   settle: async ({ payload }) => settleAuthorization(payload),
+ * })
+ * ```
+ */
+export declare function evm<const parameters extends evm.Parameters>(parameters: NoExtraKeys<parameters, evm.Parameters>): [import("../../Method.js").Server<{
+    readonly name: "evm";
+    readonly intent: "charge";
+    readonly schema: {
+        credential: {
+            payload: import("zod/mini").ZodMiniObject<{
+                from: import("zod/mini").ZodMiniString<string>;
+                nonce: import("zod/mini").ZodMiniString<string>;
+                signature: import("zod/mini").ZodMiniString<string>;
+                to: import("zod/mini").ZodMiniString<string>;
+                type: import("zod/mini").ZodMiniLiteral<"authorization">;
+                validAfter: import("zod/mini").ZodMiniString<string>;
+                validBefore: import("zod/mini").ZodMiniString<string>;
+                value: import("zod/mini").ZodMiniString<string>;
+            }, import("zod/v4/core").$strip>;
+        };
+        request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
+            amount: import("zod/mini").ZodMiniString<string>;
+            chainId: import("zod/mini").ZodMiniNumber<number>;
+            currency: import("zod/mini").ZodMiniString<string>;
+            credentialTypes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniEnum<{
+                authorization: "authorization";
+            }>>>;
+            decimals: import("zod/mini").ZodMiniNumber<number>;
+            description: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            externalId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            permit2Address: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            recipient: import("zod/mini").ZodMiniString<string>;
+            splits: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+                amount: import("zod/mini").ZodMiniString<string>;
+                recipient: import("zod/mini").ZodMiniString<string>;
+            }, import("zod/v4/core").$strip>>>;
+        }, import("zod/v4/core").$strip>, import("zod/mini").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;
+            };
+            recipient: `0x${string}`;
+        }, {
+            amount: string;
+            chainId: number;
+            currency: string;
+            credentialTypes?: "authorization"[] | undefined;
+            decimals: number;
+            description?: string | undefined;
+            externalId?: string | undefined;
+            permit2Address?: string | undefined;
+            recipient: string;
+            splits?: {
+                amount: string;
+                recipient: string;
+            }[] | undefined;
+        }>>;
+    };
+}, charge_.Defaults, import("../../server/Transport.js").Http, {}, string | undefined>, ...import("../../Method.js").Server<{
+    readonly name: "evm";
+    readonly intent: "charge";
+    readonly schema: {
+        credential: {
+            payload: import("zod/mini").ZodMiniObject<{
+                from: import("zod/mini").ZodMiniString<string>;
+                nonce: import("zod/mini").ZodMiniString<string>;
+                signature: import("zod/mini").ZodMiniString<string>;
+                to: import("zod/mini").ZodMiniString<string>;
+                type: import("zod/mini").ZodMiniLiteral<"authorization">;
+                validAfter: import("zod/mini").ZodMiniString<string>;
+                validBefore: import("zod/mini").ZodMiniString<string>;
+                value: import("zod/mini").ZodMiniString<string>;
+            }, import("zod/v4/core").$strip>;
+        };
+        request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
+            amount: import("zod/mini").ZodMiniString<string>;
+            chainId: import("zod/mini").ZodMiniNumber<number>;
+            currency: import("zod/mini").ZodMiniString<string>;
+            credentialTypes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniEnum<{
+                authorization: "authorization";
+            }>>>;
+            decimals: import("zod/mini").ZodMiniNumber<number>;
+            description: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            externalId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            permit2Address: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            recipient: import("zod/mini").ZodMiniString<string>;
+            splits: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+                amount: import("zod/mini").ZodMiniString<string>;
+                recipient: import("zod/mini").ZodMiniString<string>;
+            }, import("zod/v4/core").$strip>>>;
+        }, import("zod/v4/core").$strip>, import("zod/mini").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;
+            };
+            recipient: `0x${string}`;
+        }, {
+            amount: string;
+            chainId: number;
+            currency: string;
+            credentialTypes?: "authorization"[] | undefined;
+            decimals: number;
+            description?: string | undefined;
+            externalId?: string | undefined;
+            permit2Address?: string | undefined;
+            recipient: string;
+            splits?: {
+                amount: string;
+                recipient: string;
+            }[] | undefined;
+        }>>;
+    };
+}, charge_.Defaults, import("../../server/Transport.js").Http, {}, string | undefined>[]] | readonly [import("../../Method.js").Server<{
     readonly name: "evm";
     readonly intent: "charge";
     readonly schema: {
@@ -69,7 +219,18 @@ export declare function evm<const parameters extends evm.Parameters>(parameters:
     };
 }, charge_.Defaults, import("../../server/Transport.js").Http, {}, string | undefined>];
 export declare namespace evm {
-    type Parameters = charge_.Parameters;
+    /** Accepted EVM currency metadata, including chain-indexed definitions from `viem/tokens`. */
+    type Currency = Assets.Currency;
+    /** Shared EVM settlement parameters and ordered accepted currencies. */
+    type Parameters = Omit<charge_.Parameters, 'currency'> & ({
+        /** Ordered accepted currencies. A one-element list accepts a single asset. */
+        currencies: readonly Currency[];
+        currency?: undefined;
+    } | {
+        /** @deprecated Use `currencies: [currency]` instead. */
+        currency: Currency;
+        currencies?: undefined;
+    });
     /** Creates an EVM `charge` server method. */
     const charge: typeof charge_;
     /** Known EVM asset metadata for public config. */