mppx 0.8.19 → 0.9.0

package/dist/tempo/session/server/RequestState.js

@@ -3,10 +3,9 @@ import * as Constants from '../../../Constants.js';
 import { VerificationFailedError } from '../../../Errors.js';
 import * as Methods from '../../Methods.js';
 import { captureRequestBodyProbe, isSessionContentRequest, } from '../../server/internal/request-body.js';
-import { tip20ChannelEscrow, uint96, } from '../precompile/Protocol.js';
-import * as Voucher from '../precompile/Voucher.js';
+import { tip20ChannelEscrow } from '../precompile/Protocol.js';
 import * as ChannelStore from './ChannelStore.js';
-import { requireSessionCredentialAction, requireSessionCredentialPayload, } from './CredentialVerification.js';
+import { requireSessionCredentialAction } from './CredentialVerification.js';
 import { resolveCredentialFeePayer, resolveRequestFeePayer, } from './Settlement.js';
 /** Normalizes a session channel ID hint when one is present. */
 export function normalizeSessionChannelId(value) {
@@ -30,27 +29,6 @@ function normalizeResolvedSessionChannelId(value) {
         return undefined;
     return ChannelStore.normalizeChannelId(value);
 }
-/** Returns a close credential's channel once its voucher signature verifies. */
-async function verifiedCloseCredentialChannel(credential, store) {
-    try {
-        const payload = requireSessionCredentialPayload(credential?.payload);
-        if (payload.action !== 'close')
-            return undefined;
-        const channelId = payload.channelId;
-        const channel = await store.getChannel(channelId);
-        if (!channel || !ChannelStore.isPrecompileState(channel))
-            return undefined;
-        const verified = Voucher.verifyVoucher(channel.escrowContract, channel.chainId, {
-            channelId,
-            cumulativeAmount: uint96(BigInt(payload.cumulativeAmount)),
-            signature: payload.signature,
-        }, channel.authorizedSigner);
-        return verified ? { channelId, channel } : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** Resolves the channel ID used to build server-side session bootstrap hints. */
 export async function resolveSessionChannelId(parameters) {
     const { capturedRequest, credential, request, resolveChannelId, source, store } = parameters;
@@ -69,10 +47,10 @@ export async function resolveSessionChannelId(parameters) {
 }
 /** Builds server bootstrap hints for a reusable precompile session channel. */
 export async function resolveSessionSnapshot(parameters) {
-    const { amount, channelId, expected, matchPaymentFields, store } = parameters;
+    const { amount, channelId, expected, store } = parameters;
     if (!channelId)
         return undefined;
-    const channel = parameters.channel ?? (await store.getChannel(ChannelStore.normalizeChannelId(channelId)));
+    const channel = await store.getChannel(ChannelStore.normalizeChannelId(channelId));
     if (!channel || !ChannelStore.isPrecompileState(channel))
         return undefined;
     if (channel.finalized)
@@ -83,18 +61,8 @@ export async function resolveSessionSnapshot(parameters) {
         return undefined;
     if (channel.highestVoucher.cumulativeAmount !== channel.highestVoucherAmount)
         return undefined;
-    if (expected && !matchesSnapshotPaymentFields(channel, expected)) {
-        // The snapshot is an optional reuse hint: a failing matcher (for example a
-        // transient RPC error during the route check) must omit the hint rather
-        // than fail challenge issuance or bootstrap preflight.
-        let matched = false;
-        try {
-            matched = (await matchPaymentFields?.(channel, expected)) ?? false;
-        }
-        catch { }
-        if (!matched)
-            return undefined;
-    }
+    if (expected && !matchesSnapshotPaymentFields(channel, expected))
+        return undefined;
     const requiredCumulative = channel.spent + amount;
     return {
         acceptedCumulative: channel.highestVoucherAmount.toString(),
@@ -149,7 +117,6 @@ function isCanonicalSessionMethodDetails(value) {
         (value.feePayer === undefined || typeof value.feePayer === 'boolean') &&
         (value.feeToken === undefined ||
             (typeof value.feeToken === 'string' && isAddress(value.feeToken, { strict: false }))) &&
-        (value.machineTokenEnabled === undefined || typeof value.machineTokenEnabled === 'boolean') &&
         (value.minVoucherDelta === undefined || typeof value.minVoucherDelta === 'string') &&
         (value.operator === undefined ||
             (typeof value.operator === 'string' && isAddress(value.operator, { strict: false }))) &&
@@ -191,7 +158,7 @@ export async function resolveRequestChainId(parameters) {
 }
 /** Resolves request-time TIP-1034 details and server bootstrap hints for a challenge. */
 export async function resolveSessionPaymentRequest(parameters) {
-    const { capturedRequest, credential, decimals, defaultFeePayer, getClient, matchSnapshotPaymentFields, parameterChainId, parameterEscrowContract, parameterFeePayer, request, resolveChannelId, source, store, } = parameters;
+    const { capturedRequest, credential, decimals, defaultFeePayer, getClient, parameterChainId, parameterEscrowContract, parameterFeePayer, request, resolveChannelId, source, store, } = parameters;
     const chainId = await resolveRequestChainId({
         getClient,
         parameterChainId,
@@ -205,24 +172,16 @@ export async function resolveSessionPaymentRequest(parameters) {
     const escrowContract = resolveRequestEscrowContract(request.escrowContract, parameterEscrowContract);
     const operator = resolveRequestOperator(request.operator);
     const requestAmount = parseUnits(request.amount, decimals);
-    // A close credential names the channel it settles; advertising that channel's
-    // snapshot on the retry challenge lets clients without a configured
-    // `resolveChannelId` learn the exact capture amount a machine-token close
-    // voucher must match. Only trusted once the voucher signature verifies, and
-    // matched with close semantics so retired routes stay closable.
-    const verifiedClose = await verifiedCloseCredentialChannel(credential, store);
-    const channelId = verifiedClose?.channelId ??
-        (await resolveSessionChannelId({
-            capturedRequest,
-            credential,
-            request,
-            resolveChannelId,
-            source,
-            store,
-        }));
+    const channelId = await resolveSessionChannelId({
+        capturedRequest,
+        credential,
+        request,
+        resolveChannelId,
+        source,
+        store,
+    });
     const sessionSnapshot = await resolveSessionSnapshot({
         amount: capturedRequest && !isSessionContentRequest(capturedRequest) ? 0n : requestAmount,
-        channel: verifiedClose?.channel,
         channelId,
         expected: {
             chainId,
@@ -230,9 +189,6 @@ export async function resolveSessionPaymentRequest(parameters) {
             escrowContract,
             recipient: readChallengeAddress(request.recipient, 'recipient'),
         },
-        matchPaymentFields: matchSnapshotPaymentFields && (verifiedClose || request.machineTokenEnabled)
-            ? (channel, expected) => matchSnapshotPaymentFields(channel, expected, verifiedClose ? { action: 'close' } : undefined)
-            : undefined,
         store,
     });
     const { operator: _operator, ...requestWithoutOperator } = request;

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

@@ -36,7 +36,6 @@ export declare function session<const parameters extends session.Parameters>(p?:
         credential: {
             payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"open">;
-                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 authorizedSigner: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
@@ -53,18 +52,15 @@ export declare function session<const parameters extends session.Parameters>(p?:
                 type: import("zod/mini").ZodMiniLiteral<"transaction">;
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"voucher">;
-                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
                 descriptor: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<import("../precompile/Protocol.js").ChannelDescriptor, import("../precompile/Protocol.js").ChannelDescriptor>>;
                 signature: import("zod/mini").ZodMiniString<string>;
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"close">;
-                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
                 descriptor: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<import("../precompile/Protocol.js").ChannelDescriptor, import("../precompile/Protocol.js").ChannelDescriptor>>;
-                refundSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 signature: import("zod/mini").ZodMiniString<string>;
             }, import("zod/v4/core").$strip>], "action">;
         };
@@ -77,7 +73,6 @@ export declare function session<const parameters extends session.Parameters>(p?:
             escrowContract: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             feePayer: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniBoolean<boolean>, import("zod/mini").ZodMiniCustom<import("viem").Account, import("viem").Account>]>, import("zod/mini").ZodMiniTransform<boolean, boolean | import("viem").Account>>>;
             feeToken: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
-            machineTokenEnabled: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniBoolean<boolean>>;
             minVoucherDelta: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             operator: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             recipient: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
@@ -101,7 +96,6 @@ export declare function session<const parameters extends session.Parameters>(p?:
                 chainId?: number | undefined;
                 feePayer?: boolean | undefined;
                 feeToken?: string | undefined;
-                machineTokenEnabled?: boolean | undefined;
                 operator?: string | undefined;
                 sessionProtocol?: "v1" | "v2" | undefined;
                 sessionSnapshot?: import("../Snapshot.js").SessionSnapshot | undefined;
@@ -115,7 +109,6 @@ export declare function session<const parameters extends session.Parameters>(p?:
             escrowContract?: string | undefined;
             feePayer?: boolean | undefined;
             feeToken?: string | undefined;
-            machineTokenEnabled?: boolean | undefined;
             minVoucherDelta?: string | undefined;
             operator?: string | undefined;
             recipient?: string | undefined;
@@ -185,8 +178,6 @@ export declare namespace session {
         settlementSchedule?: SettlementSchedule | undefined;
         /** Optional fee token for management and server-driven settle/close transactions. */
         feeToken?: Address | undefined;
-        /** Enables first-party machine-token funding when the configured deployment is available. */
-        machineTokenEnabled?: boolean | undefined;
     } & Account.resolve.Parameters & Client.getResolver.Parameters & Defaults & Method.ComposableHooks<typeof Methods.session>;
     /** Defaults derived from `session()` parameters for handler type inference. */
     type DeriveDefaults<parameters extends Parameters> = types.DeriveDefaults<parameters, Defaults, {

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

@@ -5,7 +5,7 @@
  * and one-shot settlement. Each incoming request carries a session credential
  * with a cumulative voucher that the server validates and records.
  */
-import { isAddress, isAddressEqual } from 'viem';
+import { isAddress } from 'viem';
 import { tempo as tempo_chain } from 'viem/chains';
 import * as Challenge from '../../../Challenge.js';
 import * as Constants from '../../../Constants.js';
@@ -16,7 +16,6 @@ import * as Store from '../../../Store.js';
 import * as Client from '../../../viem/Client.js';
 import * as Account from '../../internal/account.js';
 import * as defaults from '../../internal/defaults.js';
-import * as MachineTokenSession from '../../internal/machine-token-session.js';
 import * as Methods from '../../Methods.js';
 import * as ChargeServer from '../../server/Charge.js';
 import * as Transport from '../../server/internal/transport.js';
@@ -179,9 +178,6 @@ async function handleBootstrapPreflight(parameters) {
             escrowContract: resolveBootstrapEscrowContract(parameters.paymentRequest, parameters.parameterEscrowContract),
             recipient: readBootstrapAddress(request.recipient, 'recipient'),
         },
-        matchPaymentFields: parameters.paymentRequest.machineTokenEnabled
-            ? parameters.matchSnapshotPaymentFields
-            : undefined,
         store: parameters.store,
     });
     const headers = new Headers({ 'Cache-Control': 'no-store' });
@@ -194,33 +190,19 @@ async function handleBootstrapPreflight(parameters) {
 /** Creates a server-side TIP20EscrowChannel precompile session payment method. */
 export function session(p) {
     const parameters = p;
-    const { amount, channelStateTtl = 5_000, currency = defaults.resolveCurrency(parameters), decimals = defaults.decimals, machineTokenEnabled, operator, store: rawStore = Store.memory(), suggestedDeposit, unitType, } = parameters;
+    const { amount, channelStateTtl = 5_000, currency = defaults.resolveCurrency(parameters), decimals = defaults.decimals, operator, store: rawStore = Store.memory(), suggestedDeposit, unitType, } = parameters;
     const settlementSchedule = resolveSettlementSchedule(parameters.settlementSchedule, decimals);
     const onSessionSettlement = parameters.onSessionSettlement;
     const store = ChannelStore.fromStore(rawStore);
     const lastOnChainVerified = new Map();
-    const { account, feePayer, feePayerUrl, recipient } = Account.resolve(parameters);
-    const configuredFeePayer = feePayer ?? feePayerUrl;
-    const settlementFeePayer = feePayer ?? (feePayerUrl ? true : undefined);
+    const { account, feePayer, remoteFeePayer, recipient } = Account.resolve(parameters);
+    const configuredFeePayer = feePayer ?? (remoteFeePayer || parameters.feePayer === true ? true : undefined);
     const getClient = Client.getResolver({
         chain: tempo_chain,
-        feePayerUrl,
+        remoteFeePayer,
         getClient: parameters.getClient,
         rpcUrl: defaults.rpcUrl,
     });
-    const matchSnapshotPaymentFields = async (channel, expected, options) => {
-        if (channel.chainId !== expected.chainId ||
-            !isAddressEqual(channel.escrowContract, expected.escrowContract) ||
-            !isAddressEqual(expected.escrowContract, tip20ChannelEscrow))
-            return false;
-        return !!(await MachineTokenSession.matchRoute(await getClient({ chainId: expected.chainId }), {
-            active: options?.action !== 'close',
-            chainId: expected.chainId,
-            descriptor: channel.descriptor,
-            merchant: expected.recipient,
-            targetToken: expected.currency,
-        }));
-    };
     const settleScheduled = async (channel) => {
         if (!isSettlementDue(channel, settlementSchedule))
             return undefined;
@@ -228,7 +210,7 @@ export function session(p) {
             account,
             channel,
             client: await getClient({ chainId: channel.chainId }),
-            ...(settlementFeePayer ? { feePayer: settlementFeePayer } : {}),
+            ...(configuredFeePayer ? { feePayer: configuredFeePayer } : {}),
             feePayerPolicy: parameters.feePayerPolicy,
             feeToken: parameters.feeToken,
             onSessionSettlement,
@@ -350,7 +332,6 @@ export function session(p) {
             amount,
             currency,
             decimals,
-            machineTokenEnabled,
             operator,
             recipient,
             suggestedDeposit,
@@ -371,7 +352,6 @@ export function session(p) {
                     defaultRecipient: recipient,
                     expires,
                     getClient,
-                    matchSnapshotPaymentFields,
                     parameterChainId: parameters.chainId,
                     parameterEscrowContract: parameters.escrowContract,
                     paymentRequest: options,
@@ -389,25 +369,16 @@ export function session(p) {
                 decimals,
                 defaultFeePayer: feePayer,
                 getClient,
-                matchSnapshotPaymentFields,
                 parameterChainId: parameters.chainId,
                 parameterEscrowContract: parameters.escrowContract,
-                parameterFeePayer: parameters.feePayer,
+                parameterFeePayer: configuredFeePayer,
                 request,
                 resolveChannelId: parameters.resolveChannelId,
                 store,
             });
-            // Only advertise the capability when this logical session can use a
-            // configured unified router on the canonical escrow.
-            const { machineTokenEnabled: requestedMachineTokenEnabled, ...requestWithoutMachineToken } = resolvedRequest;
-            const machineSessionSupported = MachineTokenSession.isSupported(resolvedRequest.chainId) &&
-                isAddressEqual(resolvedRequest.escrowContract, tip20ChannelEscrow);
             return {
-                ...requestWithoutMachineToken,
+                ...resolvedRequest,
                 feeToken: parameters.feeToken,
-                ...(requestedMachineTokenEnabled && machineSessionSupported
-                    ? { machineTokenEnabled: true }
-                    : {}),
                 sessionProtocol: Constants.SessionProtocols.v2,
             };
         },

package/dist/tempo/session/server/Settlement.d.ts

@@ -198,13 +198,6 @@ export declare function getClientAccount(client: {
 }): viem_Account | undefined;
 /** Validates that the transaction sender is the channel payee or nonzero operator. */
 export declare function assertSettlementSender(parameters: SettlementSenderParameters): void;
-/**
- * Assembles transaction options for settle/close transactions. Machine
- * channels pin PathUSD (or an explicit override); direct channels leave the
- * fee token unset so balance-aware selection can pick a funded candidate.
- * The rail comes from the caller so fee pinning always matches dispatch.
- */
-export declare function resolveChannelTransactionOptions(channel: Pick<ChannelStore.StoredPrecompileChannel, 'chainId' | 'token'>, options: SettlementTransactionOptions | undefined, account: viem_Account | undefined, machineRouter: Address | undefined): Chain.ChannelTransactionOptions | undefined;
 /** Applies automatic settlement when the server-owned schedule is due. */
 export declare function maybeSettleScheduled(parameters: MaybeSettleScheduledParameters): Promise<Hex | undefined>;
 /** Settles the highest accepted voucher for a precompile-backed session channel. */

package/dist/tempo/session/server/Settlement.js

@@ -1,6 +1,5 @@
 import { isAddress, isAddressEqual, parseUnits, zeroAddress, } from 'viem';
 import { BadRequestError, ChannelClosedError, ChannelNotFoundError, InsufficientBalanceError, VerificationFailedError, } from '../../../Errors.js';
-import * as MachineTokenSession from '../../internal/machine-token-session.js';
 import { isSessionContentRequest } from '../../server/internal/request-body.js';
 import * as Chain from '../precompile/Chain.js';
 import { readSettledReceiptFields } from '../precompile/Chain.js';
@@ -183,30 +182,6 @@ export function assertSettlementSender(parameters) {
             ' If using an access key, pass a Tempo access-key account whose address is the payee/operator wallet, not the raw delegated key address.',
     });
 }
-/**
- * Assembles transaction options for settle/close transactions. Machine
- * channels pin PathUSD (or an explicit override); direct channels leave the
- * fee token unset so balance-aware selection can pick a funded candidate.
- * The rail comes from the caller so fee pinning always matches dispatch.
- */
-export function resolveChannelTransactionOptions(channel, options, account, machineRouter) {
-    if (!account)
-        return undefined;
-    const feeToken = options?.feeToken ??
-        (machineRouter
-            ? MachineTokenSession.resolveFeeToken({
-                chainId: channel.chainId,
-                paymentToken: channel.token,
-            })
-            : undefined);
-    return {
-        account,
-        ...(options?.feePayer ? { feePayer: options.feePayer } : {}),
-        ...(options?.feePayerPolicy ? { feePayerPolicy: options.feePayerPolicy } : {}),
-        ...(feeToken ? { feeToken } : {}),
-        candidateFeeTokens: options?.candidateFeeTokens ?? [feeToken ?? channel.token],
-    };
-}
 /** Applies automatic settlement when the server-owned schedule is due. */
 export async function maybeSettleScheduled(parameters) {
     const { channel, schedule, store } = parameters;
@@ -237,32 +212,23 @@ export async function settle(store_, client, channelId_, options) {
         throw new VerificationFailedError({ reason: 'no voucher to settle' });
     const escrow = options?.escrowContract ?? channel.escrowContract;
     const account = options?.account ?? getClientAccount(client);
-    const machineRouter = MachineTokenSession.matchDeployment({
-        chainId: channel.chainId,
-        descriptor: channel.descriptor,
-    })?.swap;
-    if (!machineRouter || !account)
-        assertSettlementSender({
-            operation: 'settle',
-            channelId,
-            operator: channel.operator,
-            payee: channel.payee,
-            sender: account?.address,
-        });
+    assertSettlementSender({
+        operation: 'settle',
+        channelId,
+        operator: channel.operator,
+        payee: channel.payee,
+        sender: account?.address,
+    });
     const amount = uint96(channel.highestVoucher.cumulativeAmount);
-    const transactionOptions = resolveChannelTransactionOptions(channel, options, account, machineRouter);
-    let txHash;
-    if (machineRouter) {
-        const authorizationSignature = channel.highestVoucher.authorizationSignature;
-        if (!authorizationSignature)
-            throw new VerificationFailedError({
-                reason: 'machine-token voucher is missing its router authorization',
-            });
-        txHash = await Chain.settleMachineSessionOnChain(client, channel.descriptor, amount, channel.highestVoucher.signature, authorizationSignature, machineRouter, transactionOptions);
-    }
-    else {
-        txHash = await Chain.settleOnChain(client, channel.descriptor, amount, channel.highestVoucher.signature, escrow, transactionOptions);
-    }
+    const txHash = await Chain.settleOnChain(client, channel.descriptor, amount, channel.highestVoucher.signature, escrow, account
+        ? {
+            account,
+            ...(options?.feePayer ? { feePayer: options.feePayer } : {}),
+            ...(options?.feePayerPolicy ? { feePayerPolicy: options.feePayerPolicy } : {}),
+            ...(options?.feeToken ? { feeToken: options.feeToken } : {}),
+            candidateFeeTokens: options?.candidateFeeTokens ?? [channel.token],
+        }
+        : undefined);
     const receipt = await Chain.waitForSuccessfulReceipt(client, txHash);
     const settled = readSettledReceiptFields(Chain.getChannelEvent(receipt, 'Settled', channelId));
     const { newSettled } = settled;

package/dist/viem/Client.d.ts

@@ -1,10 +1,15 @@
 import { type Chain, type Client } from 'viem';
 import type { MaybePromise } from '../internal/types.js';
+import * as RemoteFeePayer from '../tempo/internal/remote-fee-payer.js';
+/** Creates an HTTP transport for a configured remote fee-payer service. */
+export declare function remoteFeePayerTransport(config: RemoteFeePayer.Config, options?: {
+    retryCount?: number | undefined;
+}): import("viem").HttpTransport<undefined, false>;
 export declare function getResolver(parameters: getResolver.Parameters & {
     /** Default chain to use if not provided. */
     chain?: Chain | undefined;
-    /** Fee payer relay URL. When set, the transport is wrapped with `withFeePayer`. */
-    feePayerUrl?: string | undefined;
+    /** Remote fee-payer configuration. When set, the transport is wrapped with `withFeePayer`. */
+    remoteFeePayer?: RemoteFeePayer.Config | undefined;
     /** RPC URLs keyed by chain ID. */
     rpcUrl?: ({
         [chainId: number]: string;

package/dist/viem/Client.js

@@ -1,28 +1,38 @@
 import { createClient, createTransport, custom, http } from 'viem';
 import { withFeePayer } from 'viem/tempo';
 import { tempo as tempoMainnetChain, tempoModerato } from 'viem/tempo/chains';
+import * as RemoteFeePayer from '../tempo/internal/remote-fee-payer.js';
 const knownTempoChains = {
     [tempoMainnetChain.id]: tempoMainnetChain,
     [tempoModerato.id]: tempoModerato,
 };
+/** Creates an HTTP transport for a configured remote fee-payer service. */
+export function remoteFeePayerTransport(config, options = {}) {
+    return http(config.url, {
+        fetchOptions: { headers: RemoteFeePayer.resolveHeaders(config) },
+        ...options,
+    });
+}
 export function getResolver(parameters) {
-    const { chain, feePayerUrl, getClient, rpcUrl } = parameters;
+    const { chain, getClient, remoteFeePayer, rpcUrl } = parameters;
     if (getClient) {
         // When a default chain with serializers is provided (e.g. Tempo chain config),
         // ensure user-provided clients inherit those serializers. Without this, clients
         // created without the Tempo chain config will use the default viem serializer,
         // causing errors like "maxFeePerGas is not a valid Legacy Transaction attribute".
-        if (!chain?.serializers && !feePayerUrl)
+        if (!chain?.serializers && !remoteFeePayer)
             return getClient;
         return async (params) => {
             const client = await getClient(params);
             let resolvedClient = client;
             // Wrap the client's transport with `withFeePayer` when a fee payer URL is provided.
-            if (feePayerUrl && client.transport.key !== 'feePayer') {
+            if (remoteFeePayer && client.transport.key !== 'feePayer') {
                 const request = client.request.bind(client);
                 // The supplied client already owns retries. Keep the relay middleware retry-free so
                 // failures are not retried once per nested transport layer.
-                const feePayerTransport = withFeePayer(custom({ request: (args) => request(args) }, { retryCount: 0 }), http(feePayerUrl, { retryCount: client.transport.retryCount }))({
+                const feePayerTransport = withFeePayer(custom({ request: (args) => request(args) }, { retryCount: 0 }), remoteFeePayerTransport(remoteFeePayer, {
+                    retryCount: client.transport.retryCount,
+                }))({
                     account: client.account,
                     chain: client.chain,
                     pollingInterval: client.pollingInterval,
@@ -56,7 +66,9 @@ export function getResolver(parameters) {
         const url = rpcUrl[resolvedChainId];
         if (!url)
             throw new Error(`No \`rpcUrl\` configured for \`chainId\` (${resolvedChainId}).`);
-        const transport = feePayerUrl ? withFeePayer(http(url), http(feePayerUrl)) : http(url);
+        const transport = remoteFeePayer
+            ? withFeePayer(http(url), remoteFeePayerTransport(remoteFeePayer))
+            : http(url);
         return createClient({
             chain: (knownTempoChains[resolvedChainId] ?? { ...chain, id: resolvedChainId }),
             transport,

package/dist/x402/Types.d.ts

@@ -26,6 +26,8 @@ export type EvmNetwork = `${typeof evmNetworkPrefix}${number}`;
 export declare const paymentRequiredHeader = "PAYMENT-REQUIRED";
 /** HTTP header carrying a base64-encoded x402 payment payload. */
 export declare const paymentSignatureHeader = "PAYMENT-SIGNATURE";
+/** Legacy HTTP header carrying an x402 v1 payment payload. */
+export declare const legacyPaymentSignatureHeader = "X-PAYMENT";
 /** HTTP header carrying a base64-encoded x402 settlement response. */
 export declare const paymentResponseHeader = "PAYMENT-RESPONSE";
 /** Describes the protected resource in x402 v2 payment-required responses. */

package/dist/x402/Types.js

@@ -14,6 +14,8 @@ export const syntheticChallengeIdPrefix = 'x402:';
 export const paymentRequiredHeader = 'PAYMENT-REQUIRED';
 /** HTTP header carrying a base64-encoded x402 payment payload. */
 export const paymentSignatureHeader = 'PAYMENT-SIGNATURE';
+/** Legacy HTTP header carrying an x402 v1 payment payload. */
+export const legacyPaymentSignatureHeader = 'X-PAYMENT';
 /** HTTP header carrying a base64-encoded x402 settlement response. */
 export const paymentResponseHeader = 'PAYMENT-RESPONSE';
 const nonEmptyString = z.string().check(z.minLength(1));

package/dist/x402/mcp.d.ts

@@ -0,0 +1,20 @@
+import type { x402ResourceServer } from '@x402/core/server';
+import { type MCPToolCallback, type PaymentWrappedHandler, type PaymentWrapperConfig } from '@x402/mcp';
+import * as Negotiator from '../integrations/x402/Negotiator.js';
+type ToolResource = NonNullable<PaymentWrapperConfig['resource']> & {
+    url: `mcp://tool/${string}`;
+};
+/** Configuration for {@link mpp}. A canonical MCP tool URL is required as its identity. */
+export type Config = Omit<PaymentWrapperConfig, 'resource'> & Pick<Negotiator.Config, 'realm' | 'secretKey'> & {
+    resource: ToolResource;
+};
+/**
+ * Creates an MCP tool wrapper that accepts both MPP and x402 payment metadata.
+ *
+ * Existing x402 credentials and lifecycle hooks continue through `@x402/mcp`.
+ * MPP credentials reuse the same x402 requirements, verifier, and facilitator;
+ * x402-only hooks in `PaymentWrapperConfig.hooks` therefore run only on x402 calls.
+ */
+export declare function mpp(resourceServer: x402ResourceServer, config: Config): <arguments_ extends Record<string, unknown>>(handler: PaymentWrappedHandler<arguments_>) => MCPToolCallback<arguments_>;
+export {};
+//# sourceMappingURL=mcp.d.ts.map