mppx 0.9.2 → 0.10.0

package/dist/tempo/session/client/CredentialState.d.ts

@@ -113,6 +113,8 @@ export type ResolveChallengeContextParameters = {
     challenge: Challenge.Challenge;
     /** Optional local escrow override. */
     escrowOverride?: Address | undefined;
+    /** Permitted payment chains, checked before resolution when known and again before signing. */
+    allowedChainIds?: readonly number[] | undefined;
     /** Resolves the viem client for the challenge chain. */
     getClient(parameters: {
         chainId?: number | undefined;

package/dist/tempo/session/client/CredentialState.js

@@ -1,5 +1,6 @@
 import { isAddress, parseUnits, } from 'viem';
 import * as Constants from '../../../Constants.js';
+import { assertAllowedChainId, assertChainId } from '../../../viem/Client.js';
 import * as z from '../../../zod.js';
 import * as AutoSwap from '../../internal/auto-swap.js';
 import * as Chain from '../precompile/Chain.js';
@@ -126,10 +127,15 @@ function readSuggestedDeposit(value) {
 }
 /** Resolves raw challenge fields into the typed data required by client credential planning. */
 export async function resolveChallengeContext(parameters) {
-    const { allowCustomEscrow, challenge, escrowOverride, getClient } = parameters;
+    const { allowCustomEscrow, challenge, escrowOverride, allowedChainIds, getClient } = parameters;
     const methodDetails = readMethodDetails(challenge);
-    const client = await getClient({ chainId: methodDetails.chainId });
-    const chainId = methodDetails.chainId ?? client.chain?.id;
+    if (methodDetails.chainId !== undefined || allowedChainIds?.length === 0)
+        assertAllowedChainId(allowedChainIds, methodDetails.chainId);
+    const requestedChainId = methodDetails.chainId ?? (allowedChainIds?.length === 1 ? allowedChainIds[0] : undefined);
+    const client = await getClient({ chainId: requestedChainId });
+    assertChainId(client, requestedChainId);
+    const chainId = requestedChainId ?? client.chain?.id;
+    assertAllowedChainId(allowedChainIds, chainId);
     if (!chainId)
         throw new Error('No chainId configured for TIP-1034 session challenge.');
     const escrow = resolveEscrow(challenge, escrowOverride, allowCustomEscrow);

package/dist/tempo/session/client/Session.d.ts

@@ -137,6 +137,12 @@ export declare namespace session {
         decimals?: number | undefined;
         /** Exact TIP20EscrowChannel address pin. Takes precedence over `allowCustomEscrow`. */
         escrow?: Address | undefined;
+        /**
+         * Chains permitted for session credentials. Omitted allows any chain; empty rejects all.
+         * A single entry supplies the chain when omitted by the challenge. Otherwise the
+         * challenge or resolved client must select an allowed chain.
+         */
+        allowedChainIds?: readonly number[] | undefined;
         /** Maximum channel deposit in human-readable units. Caps server-suggested opens and automatic top-ups. */
         maxDeposit?: string | undefined;
         /**

package/dist/tempo/session/client/Session.js

@@ -77,7 +77,7 @@ function acknowledgesOpen(outcome, challenge, opened) {
  * channel descriptor).
  */
 export function session(parameters = {}) {
-    const { account, allowCustomEscrow = false, autoSwap: autoSwapParameter, channelStore, decimals = defaults.decimals, escrow: escrowOverride, getClient: getClientParameter, maxDeposit: maxDepositParameter, topUpAmount: topUpAmountParameter, onChannelUpdate, resolveAccount, } = parameters;
+    const { account, allowCustomEscrow = false, autoSwap: autoSwapParameter, channelStore, decimals = defaults.decimals, escrow: escrowOverride, allowedChainIds, getClient: getClientParameter, maxDeposit: maxDepositParameter, topUpAmount: topUpAmountParameter, onChannelUpdate, resolveAccount, } = parameters;
     const getClient = Client.getResolver({
         chain: tempo_chain,
         getClient: getClientParameter,
@@ -120,6 +120,7 @@ export function session(parameters = {}) {
                 allowCustomEscrow,
                 challenge,
                 escrowOverride,
+                allowedChainIds,
                 getClient,
             });
             const attempt = MethodResponse.getAttempt(parameters);
@@ -237,6 +238,7 @@ export function session(parameters = {}) {
             allowCustomEscrow,
             challenge,
             escrowOverride,
+            allowedChainIds,
             getClient,
         });
         const channel = await store.get(resolved.key);
@@ -278,6 +280,7 @@ export function session(parameters = {}) {
             allowCustomEscrow,
             challenge,
             escrowOverride,
+            allowedChainIds,
             getClient,
         })).key;
         let channel = await store.get(channelKey);

package/dist/tempo/session/client/SessionManager.d.ts

@@ -3,6 +3,7 @@ import { type Address } from 'viem';
 import * as Account from '../../../viem/Account.js';
 import * as Client from '../../../viem/Client.js';
 import { type ChannelStore } from '../client/ChannelStore.js';
+import { type SessionContext } from '../client/CredentialState.js';
 import { session as sessionPlugin } from '../client/Session.js';
 import type { SessionReceipt } from '../precompile/Protocol.js';
 import { deserializeSnapshot as deserializeSessionSnapshot, serializeSnapshot as serializeSessionSnapshot } from '../Snapshot.js';
@@ -48,6 +49,8 @@ export type PaymentResponse = Response & {
     /** Local cumulative voucher authorization in raw token units. */
     cumulative: bigint;
 };
+/** @internal Merges manager-wide context without allowing it to replace an operation's fields. */
+export declare function mergeSessionCredentialContext(credentialContext: unknown, operationContext: SessionContext): SessionContext;
 /**
  * Creates a session manager that handles the full client payment lifecycle:
  * channel open, incremental vouchers, SSE streaming, and channel close.
@@ -76,8 +79,16 @@ export declare namespace sessionManager {
         decimals?: number | undefined;
         /** Exact TIP20EscrowChannel address pin. Takes precedence over `allowCustomEscrow`. */
         escrow?: Address | undefined;
+        /**
+         * Chains permitted for sessions, bootstrap proofs, and snapshots. Omitted allows any
+         * chain; empty rejects all. A single entry supplies an omitted challenge chain;
+         * otherwise the challenge or resolved client must select an allowed chain.
+         */
+        allowedChainIds?: readonly number[] | undefined;
         /** Fetch implementation used for HTTP probes, management posts, and paid retries. */
         fetch?: typeof globalThis.fetch | undefined;
+        /** Base context supplied to every session credential created by the manager. */
+        credentialContext?: unknown;
         /** Maximum deposit in human-readable units (e.g. `'10'` for 10 tokens). Converted to raw units via `decimals`. */
         maxDeposit?: string | undefined;
         /**

package/dist/tempo/session/client/SessionManager.js

@@ -10,7 +10,7 @@ import * as Client from '../../../viem/Client.js';
 import { charge as chargePlugin } from '../../client/Charge.js';
 import * as defaults from '../../internal/defaults.js';
 import { createChannelStore, entryKey } from '../client/ChannelStore.js';
-import { hydrateSessionSnapshot } from '../client/CredentialState.js';
+import { hydrateSessionSnapshot, sessionContextSchema, } from '../client/CredentialState.js';
 import { session as sessionPlugin } from '../client/Session.js';
 import * as Channel from '../precompile/Channel.js';
 import { deserializeSessionReceipt } from '../precompile/Protocol.js';
@@ -60,6 +60,12 @@ function requestInitWithSessionHint(input, init, channelId) {
         },
     };
 }
+/** @internal Merges manager-wide context without allowing it to replace an operation's fields. */
+export function mergeSessionCredentialContext(credentialContext, operationContext) {
+    if (credentialContext === undefined)
+        return operationContext;
+    return { ...sessionContextSchema.parse(credentialContext), ...operationContext };
+}
 function resolveSessionManagerConfig(parameters) {
     const decimals = parameters.decimals ?? 6;
     const WebSocket = parameters.webSocket ??
@@ -83,6 +89,9 @@ function resolveSessionManagerConfig(parameters) {
  * `channelStore` can persist reusable channels between manager instances.
  */
 export function sessionManager(parameters) {
+    const clientChainId = parameters.client?.chain?.id;
+    if (clientChainId !== undefined || parameters.allowedChainIds?.length === 0)
+        Client.assertAllowedChainId(parameters.allowedChainIds, clientChainId);
     const allowCustomEscrow = parameters.allowCustomEscrow ?? false;
     const config = resolveSessionManagerConfig(parameters);
     const getClient = Client.getResolver({
@@ -92,6 +101,9 @@ export function sessionManager(parameters) {
     });
     const getAccount = Account.getResolver({ account: parameters.account });
     const runtime = createSessionManagerRuntime();
+    const credentialContext = parameters.credentialContext === undefined
+        ? undefined
+        : mergeSessionCredentialContext(parameters.credentialContext, {});
     const receipts = createSessionReceiptCoordinator({
         getSocketSession: () => runtime.socketSession,
     });
@@ -197,6 +209,7 @@ export function sessionManager(parameters) {
         getClient: parameters.client ? () => parameters.client : parameters.getClient,
         resolveAccount: parameters.resolveAccount,
         escrow: parameters.escrow,
+        allowedChainIds: parameters.allowedChainIds,
         decimals: config.decimals,
         maxDeposit: parameters.maxDeposit,
         topUpAmount: parameters.topUpAmount,
@@ -219,6 +232,7 @@ export function sessionManager(parameters) {
     });
     MethodResponse.unregister(method);
     const chargeMethod = chargePlugin({
+        allowedChainIds: parameters.allowedChainIds,
         account: parameters.account,
         getClient: parameters.client ? () => parameters.client : parameters.getClient,
     });
@@ -248,7 +262,10 @@ export function sessionManager(parameters) {
         },
     });
     function createSessionCredential(challenge, context) {
-        return method.createCredential({ challenge, context });
+        return method.createCredential({
+            challenge,
+            context: mergeSessionCredentialContext(credentialContext, context),
+        });
     }
     function updateSpentFromReceipt(receipt) {
         applySessionReceiptToRuntime({
@@ -278,7 +295,9 @@ export function sessionManager(parameters) {
         if (!header)
             return undefined;
         const snapshot = deserializeSessionSnapshot(header);
+        Client.assertAllowedChainId(parameters.allowedChainIds, snapshot.chainId);
         const client = await getClient({ chainId: snapshot.chainId });
+        Client.assertChainId(client, snapshot.chainId);
         const defaultAccount = getAccount(client);
         const account = (await parameters.resolveAccount?.({
             account: defaultAccount,
@@ -535,6 +554,8 @@ export function sessionManager(parameters) {
             use.trackCreates = true;
             const liveHint = runtime.channel?.opened ? runtime.channel.channelId : undefined;
             let effectiveInit = requestInitWithSessionHint(input, init, liveHint);
+            if (credentialContext)
+                effectiveInit = { ...effectiveInit, context: credentialContext };
             // Stored channels may be stale, so retry once after evicting the resumed entry.
             let canRetryResumed = !previous.channel?.opened;
             async function retryWithoutResumed() {

package/dist/tempo/session/precompile/Chain.js

@@ -318,6 +318,7 @@ async function prepareFeePayerCallTransaction(client, parameters) {
         account,
         calls: [{ to, data }],
         feePayer: true,
+        nonceKey: 'expiring',
         ...(feeToken ? { feeToken } : {}),
     });
 }
@@ -329,6 +330,8 @@ function sendPrecompileContractCall(client, parameters) {
         ...(account ? { account } : {}),
         to,
         data,
+        // Server processes can share a signer without sharing viem's concurrency detection.
+        nonceKey: 'expiring',
         ...(feePayer ? { feePayer } : {}),
         ...(feeToken ? { feeToken } : {}),
     });

package/dist/tempo/subscription/KeyAuthorization.d.ts

@@ -1,3 +1,4 @@
+import { Hex } from 'ox';
 import { KeyAuthorization } from 'ox/tempo';
 import { type Address } from 'viem';
 import type * as Methods from '../Methods.js';
@@ -42,6 +43,8 @@ export declare function getSubscriptionRpcAllowedCalls(request: Pick<Subscriptio
         readonly recipients: readonly [`0x${string}`];
     }];
 }];
+/** Decodes the server-issued challenge identifier for use as a signed Tempo witness. */
+export declare function getSubscriptionChallengeWitness(challengeId: string): Hex.Hex;
 /**
  * Creates and signs a Tempo key authorization for subscription payments when the account can sign
  * arbitrary hashes locally.
@@ -53,6 +56,7 @@ export declare function signSubscriptionKeyAuthorization(parameters: {
             hash: `0x${string}`;
         }) => Promise<`0x${string}`>) | undefined;
     };
+    challengeId: string;
     chainId: number;
     request: Pick<SubscriptionRequest, 'amount' | 'currency' | 'periodCount' | 'periodUnit' | 'recipient' | 'subscriptionExpires'>;
 }): Promise<{
@@ -96,7 +100,7 @@ export declare function signSubscriptionKeyAuthorization(parameters: {
         version?: undefined;
     } | {
         metadata: {
-            authenticatorData: import("ox/Hex").Hex;
+            authenticatorData: Hex.Hex;
             clientDataJSON: string;
         };
         signature: {
@@ -133,6 +137,7 @@ export declare function signSubscriptionKeyAuthorization(parameters: {
         readonly recipients: readonly `0x${string}`[];
     }[];
     readonly type: "p256" | "secp256k1" | "webAuthn";
+    readonly witness: `0x${string}`;
 } | undefined>;
 /**
  * Verifies that a subscription credential contains a key authorization scoped to the requested
@@ -140,6 +145,7 @@ export declare function signSubscriptionKeyAuthorization(parameters: {
  */
 export declare function verifySubscriptionKeyAuthorization(parameters: {
     accessKey?: SubscriptionAccessKey | undefined;
+    challengeId: string;
     chainId: number;
     payload: SubscriptionCredentialPayload;
     request: SubscriptionRequest;

package/dist/tempo/subscription/KeyAuthorization.js

@@ -1,3 +1,4 @@
+import { Base64, Hex } from 'ox';
 import { KeyAuthorization, SignatureEnvelope } from 'ox/tempo';
 import { isAddress, isAddressEqual } from 'viem';
 import { VerificationFailedError } from '../../Errors.js';
@@ -104,16 +105,29 @@ export function getSubscriptionRpcAllowedCalls(request) {
         },
     ];
 }
+/** Decodes the server-issued challenge identifier for use as a signed Tempo witness. */
+export function getSubscriptionChallengeWitness(challengeId) {
+    try {
+        const witness = Hex.fromBytes(Base64.toBytes(challengeId));
+        if (Hex.size(witness) !== 32)
+            throw new Error('invalid challenge id size');
+        return witness;
+    }
+    catch {
+        throw new VerificationFailedError({ reason: 'challenge id must encode 32 bytes' });
+    }
+}
 /**
  * Creates and signs a Tempo key authorization for subscription payments when the account can sign
  * arbitrary hashes locally.
  */
 export async function signSubscriptionKeyAuthorization(parameters) {
-    const { accessKey, account, chainId, request } = parameters;
+    const { accessKey, account, challengeId, chainId, request } = parameters;
     if (typeof account.sign !== 'function')
         return undefined;
     const authorization = createUnsignedAuthorization({
         accessKey,
+        challengeId,
         chainId,
         request,
     });
@@ -135,7 +149,7 @@ export async function signSubscriptionKeyAuthorization(parameters) {
  * token, recipient, amount, period, expiry, chain, and server-issued access key.
  */
 export function verifySubscriptionKeyAuthorization(parameters) {
-    const { accessKey, chainId, payload, request } = parameters;
+    const { accessKey, challengeId, chainId, payload, request } = parameters;
     if (payload.type !== 'keyAuthorization') {
         throw new VerificationFailedError({ reason: 'invalid keyAuthorization payload' });
     }
@@ -146,6 +160,9 @@ export function verifySubscriptionKeyAuthorization(parameters) {
         authorization,
         chainId,
     });
+    if (authorization.witness?.toLowerCase() !== getSubscriptionChallengeWitness(challengeId)) {
+        throw new VerificationFailedError({ reason: 'keyAuthorization challenge mismatch' });
+    }
     assertAuthorizationExpiry(authorization, request);
     assertAuthorizationLimit(getSingleTokenLimit(authorization), request);
     assertAuthorizationScopes(authorization.scopes, request);
@@ -159,7 +176,7 @@ export function verifySubscriptionKeyAuthorization(parameters) {
     };
 }
 function createUnsignedAuthorization(parameters) {
-    const { accessKey, chainId, request } = parameters;
+    const { accessKey, challengeId, chainId, request } = parameters;
     return KeyAuthorization.from({
         address: normalizeAddress(accessKey.accessKeyAddress, 'accessKeyAddress'),
         chainId: BigInt(chainId),
@@ -173,6 +190,7 @@ function createUnsignedAuthorization(parameters) {
         ],
         scopes: getSubscriptionScopes(request),
         type: accessKey.keyType,
+        witness: getSubscriptionChallengeWitness(challengeId),
     });
 }
 function deserializeAuthorization(signature) {

package/dist/validation/core.d.ts

@@ -37,6 +37,7 @@ export type ValidateResult = {
         passed: number;
         failed: number;
         warnings: number;
+        suggested: number;
         skipped: number;
     };
     suggestions: string[];

package/dist/validation/core.js

@@ -1,6 +1,6 @@
 import * as viemChains from 'viem/chains';
 import { validateChallenge, validateErrorHandling } from '../cli/validate/challenge.js';
-import { buildUrl, extractEndpointsFromDiscovery, extractRequestBodyFromDiscovery, fetchDiscoveryDoc, } from '../cli/validate/discovery.js';
+import { buildUrl, extractEndpointsFromDiscovery, extractRequestBodyFromDiscovery, fetchDiscoveryDoc, validateLlmsDoc, } from '../cli/validate/discovery.js';
 import { isValidIntegerAmount, parseEndpointArg, resolveBodyForEndpoint, } from '../cli/validate/helpers.js';
 import { missingDiscoverySuggestion } from '../cli/validate/messages.js';
 import { validatePaymentFlow } from '../cli/validate/payment.js';
@@ -123,7 +123,7 @@ export async function validate(options) {
                 break;
         }
     }
-    const summary = { passed: 0, failed: 0, warnings: 0, skipped: 0 };
+    const summary = { passed: 0, failed: 0, warnings: 0, suggested: 0, skipped: 0 };
     if (discovery) {
         for (const r of discovery.checks) {
             if (r.severity === 'pass')
@@ -132,6 +132,8 @@ export async function validate(options) {
                 summary.failed++;
             else if (r.severity === 'warn')
                 summary.warnings++;
+            else if (r.severity === 'suggested')
+                summary.suggested++;
             else if (r.severity === 'skip')
                 summary.skipped++;
         }
@@ -144,6 +146,8 @@ export async function validate(options) {
                 summary.failed++;
             else if (r.severity === 'warn')
                 summary.warnings++;
+            else if (r.severity === 'suggested')
+                summary.suggested++;
             else if (r.severity === 'skip')
                 summary.skipped++;
         }
@@ -189,6 +193,7 @@ async function runDiscovery(baseUrl, options) {
     let discoveryDoc = null;
     let found = false;
     let valid = false;
+    checks.push(await validateLlmsDoc(baseUrl));
     // Try the user's path first, then root, then /api.
     const origin = new URL(baseUrl).origin;
     let candidates;

package/dist/viem/Client.d.ts

@@ -25,4 +25,8 @@ export declare namespace getResolver {
         }) => MaybePromise<Client>) | undefined;
     };
 }
+/** Rejects a resolved client whose known chain conflicts with the requested payment chain. */
+export declare function assertChainId(client: Client, chainId: number | undefined): void;
+/** Rejects disallowed or unknown payment chains when an allowlist is configured. */
+export declare function assertAllowedChainId(allowedChainIds: readonly number[] | undefined, chainId: number | undefined): void;
 //# sourceMappingURL=Client.d.ts.map

package/dist/viem/Client.js

@@ -50,6 +50,8 @@ export function getResolver(parameters) {
             return Object.assign({}, resolvedClient, {
                 chain: {
                     ...chain,
+                    // Serializer defaults must not replace an explicitly requested network.
+                    ...(params.chainId !== undefined ? { id: params.chainId } : {}),
                     ...resolvedClient.chain,
                     formatters: resolvedClient.chain?.formatters ?? chain.formatters,
                     prepareTransactionRequest: resolvedClient.chain?.prepareTransactionRequest ?? chain.prepareTransactionRequest,
@@ -76,4 +78,15 @@ export function getResolver(parameters) {
         });
     };
 }
+/** Rejects a resolved client whose known chain conflicts with the requested payment chain. */
+export function assertChainId(client, chainId) {
+    if (chainId !== undefined && client.chain?.id !== undefined && client.chain.id !== chainId)
+        throw new Error(`Chain ID mismatch: expected ${chainId}, got ${client.chain.id}.`);
+}
+/** Rejects disallowed or unknown payment chains when an allowlist is configured. */
+export function assertAllowedChainId(allowedChainIds, chainId) {
+    if (allowedChainIds !== undefined &&
+        (chainId === undefined || !allowedChainIds.includes(chainId)))
+        throw new Error(`Chain ID not allowed: ${chainId ?? 'unknown'}.`);
+}
 //# sourceMappingURL=Client.js.map

package/dist/x402/client/Exact.d.ts

@@ -28,8 +28,8 @@ export type Signer = Account & {
     signTypedData?: (parameters: any) => Promise<`0x${string}`>;
 };
 export type Config = {
-    /** Account used to sign exact EVM payment payloads. */
-    account: Account;
+    /** Account used to sign exact EVM payment payloads, unless supplied in credential context. */
+    account?: Account | undefined;
     /** Optional token decimals used to parse `maxAmount` when currency metadata is not provided. */
     decimals?: number | undefined;
     /** Optional maximum display-unit amount the client is willing to pay. */

package/dist/x402/client/Exact.js

@@ -8,7 +8,7 @@ import * as Types from '../Types.js';
  */
 export async function createCredential(parameters) {
     const account = (parameters.context?.account ?? parameters.config.account);
-    if (!account.signTypedData)
+    if (!account?.signTypedData)
         throw new Error('x402 exact requires a typed-data signer.');
     const request = parameters.challenge.request;
     const accepted = Types.toPaymentRequirements(request);

package/dist/x402/server/EvmCharge.d.ts

@@ -52,6 +52,8 @@ export declare function resolveOptions(parameters: {
 export declare function createPath(config: ResolvedOptions): Path;
 /** Settles a verified EVM authorization through an x402 facilitator. */
 export declare function settleWithFacilitator(parameters: ResolvedOptions): SettleWithFacilitator;
+/** Checks an EVM authorization with the facilitator without settling it. */
+export declare function verifyWithFacilitator(parameters: ResolvedOptions, authorization: Parameters<SettleWithFacilitator>[0]): Promise<void>;
 export type SettleWithFacilitator = (parameters: {
     credential: Credential.Credential<Types.AuthorizationPayload>;
     payload: Types.AuthorizationPayload;

package/dist/x402/server/EvmCharge.js

@@ -174,34 +174,11 @@ export function createPath(config) {
 }
 /** Settles a verified EVM authorization through an x402 facilitator. */
 export function settleWithFacilitator(parameters) {
-    const { facilitator, maxTimeoutSeconds } = parameters;
+    const { facilitator } = parameters;
     if (!facilitator)
         throw new Error('EVM authorization x402 requires `facilitator`.');
-    return async ({ payload, request }) => {
-        const paymentRequirements = toPaymentRequirements(request, {
-            ...parameters,
-            maxTimeoutSeconds,
-        });
-        const paymentPayload = {
-            accepted: paymentRequirements,
-            payload: {
-                authorization: {
-                    from: payload.from,
-                    nonce: payload.nonce,
-                    to: payload.to,
-                    validAfter: payload.validAfter,
-                    validBefore: payload.validBefore,
-                    value: payload.value,
-                },
-                signature: payload.signature,
-            },
-            x402Version: 2,
-        };
-        const verified = await facilitator.verify(paymentPayload, paymentRequirements);
-        if (!verified.isValid)
-            throw new VerificationFailedError({
-                reason: verified.invalidMessage ?? verified.invalidReason ?? 'EVM facilitator verify failed',
-            });
+    return async (authorization) => {
+        const { paymentPayload, paymentRequirements } = facilitatorPayment(parameters, authorization);
         const settled = await facilitator.settle(paymentPayload, paymentRequirements);
         if (!settled.success)
             throw new VerificationFailedError({
@@ -212,6 +189,37 @@ export function settleWithFacilitator(parameters) {
         };
     };
 }
+/** Checks an EVM authorization with the facilitator without settling it. */
+export async function verifyWithFacilitator(parameters, authorization) {
+    const { facilitator } = parameters;
+    if (!facilitator)
+        throw new Error('EVM authorization x402 requires `facilitator`.');
+    const { paymentPayload, paymentRequirements } = facilitatorPayment(parameters, authorization);
+    const verified = await facilitator.verify(paymentPayload, paymentRequirements);
+    if (!verified.isValid)
+        throw new VerificationFailedError({
+            reason: verified.invalidMessage ?? verified.invalidReason ?? 'EVM facilitator verify failed',
+        });
+}
+function facilitatorPayment(parameters, { payload, request }) {
+    const paymentRequirements = toPaymentRequirements(request, parameters);
+    const paymentPayload = {
+        accepted: paymentRequirements,
+        payload: {
+            authorization: {
+                from: payload.from,
+                nonce: payload.nonce,
+                to: payload.to,
+                validAfter: payload.validAfter,
+                validBefore: payload.validBefore,
+                value: payload.value,
+            },
+            signature: payload.signature,
+        },
+        x402Version: 2,
+    };
+    return { paymentPayload, paymentRequirements };
+}
 /** Returns whether a credential was converted from an x402 payment payload. */
 export function isCredential(credential) {
     return credential[x402Credential] === true;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mppx",
   "type": "module",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "main": "./dist/index.js",
   "license": "MIT",
   "homepage": "https://github.com/wevm/mppx#readme",