mppx 0.8.19 → 0.9.1

package/dist/x402/mcp.js

@@ -0,0 +1,154 @@
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
+import { decodePaymentRequiredHeader } from '@x402/core/http';
+import { createPaymentWrapper, MCP_PAYMENT_META_KEY, } from '@x402/mcp';
+import * as Challenge from '../Challenge.js';
+import * as Errors from '../Errors.js';
+import * as Negotiator from '../integrations/x402/Negotiator.js';
+import * as Mcp from '../Mcp.js';
+import * as McpCredential from '../mcp/internal/Credential.js';
+import * as Receipt from '../Receipt.js';
+import { paymentRequiredHeader } from './Types.js';
+/**
+ * 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 function mpp(resourceServer, config) {
+    const toolName = parseToolName(config.resource.url);
+    const x402 = createPaymentWrapper(resourceServer, config);
+    const resourceUrl = config.resource.url;
+    const route = {
+        accepts: config.accepts.map(toPaymentOption),
+        ...(config.extensions ? { extensions: config.extensions } : {}),
+        ...(config.resource.description ? { description: config.resource.description } : {}),
+        ...(config.resource.mimeType ? { mimeType: config.resource.mimeType } : {}),
+        resource: resourceUrl,
+    };
+    const negotiator = Negotiator.create({
+        routes: route,
+        server: resourceServer,
+        secretKey: config.secretKey,
+        ...(config.realm ? { realm: config.realm } : {}),
+    });
+    return (handler) => {
+        const x402Handler = x402(handler);
+        return async (arguments_, rawExtra) => {
+            const extra = (rawExtra ?? {});
+            if (extra._meta?.[MCP_PAYMENT_META_KEY])
+                return x402Handler(arguments_, rawExtra);
+            const credential = McpCredential.parse(extra._meta?.[Mcp.credentialMetaKey]);
+            const headers = new Headers({
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            });
+            if (credential)
+                headers.set('Authorization', credential.header);
+            const request = new Request('https://mppx.invalid/tool', {
+                body: JSON.stringify(arguments_),
+                headers,
+                method: 'POST',
+            });
+            const result = await negotiator.negotiate(request, Negotiator.createContext(request, arguments_));
+            if (result.status === 'unprotected')
+                return x402Handler(arguments_, rawExtra);
+            if (result.status === 'x402')
+                return x402Handler(arguments_, rawExtra);
+            if (result.status === 'handled') {
+                if (result.response.status === 402)
+                    throw createCombinedChallenge(result.response, credential ? new Errors.VerificationFailedError() : undefined);
+                return attachReceipt(await responseToToolResult(result.response.clone()), result.response, credential);
+            }
+            const toolResult = await handler(arguments_, {
+                arguments: arguments_,
+                ...(extra._meta ? { meta: extra._meta } : {}),
+                toolName,
+            });
+            if (!credential)
+                return toolResult;
+            const response = result.withReceipt(Response.json(toolResult));
+            return attachReceipt(toolResult, response, credential);
+        };
+    };
+}
+function attachReceipt(result, response, credential) {
+    if (!credential || !response.headers.has('Payment-Receipt'))
+        return result;
+    const receipt = Receipt.fromResponse(response);
+    return {
+        ...result,
+        _meta: {
+            ...result._meta,
+            [Mcp.receiptMetaKey]: {
+                ...receipt,
+                challengeId: credential.value.challenge.id,
+            },
+        },
+    };
+}
+/** Converts an HTTP-side bridge response into a valid MCP tool result. */
+async function responseToToolResult(response) {
+    const text = await response.text();
+    const value = parseResponseBody(text, response.headers.get('Content-Type'));
+    if (isWrappedToolResult(value))
+        return value;
+    const message = getErrorMessage(value) ?? (text || `HTTP ${response.status}`);
+    return {
+        content: [{ text: message, type: 'text' }],
+        ...(response.status >= 400 ? { isError: true } : {}),
+        ...(isRecord(value) && response.status < 400 ? { structuredContent: value } : {}),
+    };
+}
+function parseResponseBody(text, contentType) {
+    if (!text || !contentType?.includes('application/json'))
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isWrappedToolResult(value) {
+    return isRecord(value) && Array.isArray(value.content);
+}
+function getErrorMessage(value) {
+    return isRecord(value) && typeof value.error === 'string' ? value.error : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function createCombinedChallenge(response, error) {
+    const challenges = Challenge.fromResponseList(response);
+    const encoded = response.headers.get(paymentRequiredHeader);
+    const x402 = encoded ? decodePaymentRequiredHeader(encoded) : undefined;
+    return new McpError(Mcp.errorCode(error), error?.title ?? 'Payment Required', {
+        challenges,
+        httpStatus: 402,
+        ...(x402 ? { x402 } : {}),
+    });
+}
+function toPaymentOption(requirement) {
+    return {
+        network: requirement.network,
+        payTo: requirement.payTo,
+        price: {
+            amount: requirement.amount,
+            asset: requirement.asset,
+            ...(requirement.extra ? { extra: requirement.extra } : {}),
+        },
+        scheme: requirement.scheme,
+        ...(requirement.extra ? { extra: requirement.extra } : {}),
+        ...(requirement.maxTimeoutSeconds ? { maxTimeoutSeconds: requirement.maxTimeoutSeconds } : {}),
+    };
+}
+function parseToolName(resource) {
+    if (!resource.startsWith('mcp://tool/'))
+        throw new Error('MPP x402 MCP resources must use mcp://tool/{toolName}.');
+    const toolName = resource.slice('mcp://tool/'.length);
+    if (!toolName || toolName.includes('/') || toolName.includes('?') || toolName.includes('#'))
+        throw new Error('MPP x402 MCP resources must use mcp://tool/{toolName}.');
+    return toolName;
+}
+//# sourceMappingURL=mcp.js.map

package/dist/x402/middlewares/express.d.ts

@@ -0,0 +1,23 @@
+import type { RoutesConfig, x402ResourceServer } from '@x402/core/server';
+import type { RequestHandler } from 'express';
+import * as Negotiator from '../../integrations/x402/Negotiator.js';
+/** Express-specific configuration for {@link mpp}. */
+export type Config = Omit<Negotiator.Config, 'routes' | 'server'>;
+/**
+ * Adds MPP negotiation to the official x402 Express middleware.
+ *
+ * x402 retains ownership of response buffering, handler cancellation, hooks, and
+ * post-handler settlement. This wrapper only handles MPP credentials and appends
+ * an MPP challenge to unpaid x402 responses.
+ *
+ * @example
+ * ```ts
+ * import { mpp } from 'mppx/x402/express'
+ *
+ * app.use(mpp(routes, resourceServer, {
+ *   secretKey: process.env.MPP_SECRET_KEY!,
+ * }))
+ * ```
+ */
+export declare function mpp(routes: RoutesConfig, server: x402ResourceServer, config: Config): RequestHandler;
+//# sourceMappingURL=express.d.ts.map

package/dist/x402/middlewares/express.js

@@ -0,0 +1,49 @@
+import { ExpressAdapter, paymentMiddlewareFromHTTPServer } from '@x402/express';
+import * as Negotiator from '../../integrations/x402/Negotiator.js';
+import * as ExpressAdapter_ from '../../middlewares/internal/express.js';
+/**
+ * Adds MPP negotiation to the official x402 Express middleware.
+ *
+ * x402 retains ownership of response buffering, handler cancellation, hooks, and
+ * post-handler settlement. This wrapper only handles MPP credentials and appends
+ * an MPP challenge to unpaid x402 responses.
+ *
+ * @example
+ * ```ts
+ * import { mpp } from 'mppx/x402/express'
+ *
+ * app.use(mpp(routes, resourceServer, {
+ *   secretKey: process.env.MPP_SECRET_KEY!,
+ * }))
+ * ```
+ */
+export function mpp(routes, server, config) {
+    const mpp = Negotiator.create({ ...config, routes, server });
+    const x402 = paymentMiddlewareFromHTTPServer(mpp.httpServer, config.paywallConfig, undefined, false);
+    return async (req, res, next) => {
+        const request = ExpressAdapter_.toRequest(req);
+        const paymentHeader = Negotiator.getX402Credential(request);
+        const context = {
+            adapter: new ExpressAdapter(req),
+            method: req.method,
+            path: req.path,
+            ...(paymentHeader ? { paymentHeader } : {}),
+        };
+        try {
+            const result = await mpp.negotiate(request, context);
+            if (result.status === 'unprotected')
+                return next();
+            if (result.status === 'handled')
+                return ExpressAdapter_.sendResponse(res, result.response);
+            if (result.status === 'paid') {
+                ExpressAdapter_.copyHeaders(res, result.withReceipt(new Response()).headers);
+                return next();
+            }
+            return x402(req, res, next);
+        }
+        catch (error) {
+            return next(error);
+        }
+    };
+}
+//# sourceMappingURL=express.js.map

package/dist/x402/middlewares/hono.d.ts

@@ -0,0 +1,13 @@
+import type { RoutesConfig, x402ResourceServer } from '@x402/core/server';
+import type { MiddlewareHandler } from 'hono';
+import * as Negotiator from '../../integrations/x402/Negotiator.js';
+/** Hono-specific configuration for {@link mpp}. */
+export type Config = Omit<Negotiator.Config, 'routes' | 'server'>;
+/**
+ * Adds MPP negotiation to the official x402 Hono middleware.
+ *
+ * The official adapter retains ownership of Hono response handling, cancellation,
+ * extensions, and post-handler x402 settlement.
+ */
+export declare function mpp(routes: RoutesConfig, server: x402ResourceServer, config: Config): MiddlewareHandler;
+//# sourceMappingURL=hono.d.ts.map

package/dist/x402/middlewares/hono.js

@@ -0,0 +1,36 @@
+import { HonoAdapter, paymentMiddlewareFromHTTPServer } from '@x402/hono';
+import * as Negotiator from '../../integrations/x402/Negotiator.js';
+/**
+ * Adds MPP negotiation to the official x402 Hono middleware.
+ *
+ * The official adapter retains ownership of Hono response handling, cancellation,
+ * extensions, and post-handler x402 settlement.
+ */
+export function mpp(routes, server, config) {
+    const mpp = Negotiator.create({ ...config, routes, server });
+    const x402 = paymentMiddlewareFromHTTPServer(mpp.httpServer, config.paywallConfig, undefined, false);
+    return async (context, next) => {
+        const request = context.req.raw;
+        const paymentHeader = Negotiator.getX402Credential(request);
+        const requestContext = {
+            adapter: new HonoAdapter(context),
+            method: request.method,
+            path: new URL(request.url).pathname,
+            ...(paymentHeader ? { paymentHeader } : {}),
+        };
+        const result = await mpp.negotiate(request, requestContext);
+        if (result.status === 'unprotected')
+            return next();
+        if (result.status === 'handled') {
+            context.res = result.response;
+            return;
+        }
+        if (result.status === 'paid') {
+            await next();
+            context.res = result.withReceipt(context.res);
+            return;
+        }
+        return x402(context, next);
+    };
+}
+//# sourceMappingURL=hono.js.map

package/dist/x402/middlewares/next.d.ts

@@ -0,0 +1,17 @@
+import type { RouteConfig, RoutesConfig, x402ResourceServer } from '@x402/core/server';
+import { type NextRequest } from 'next/server.js';
+import * as Negotiator from '../../integrations/x402/Negotiator.js';
+type RouteHandler<arguments_ extends unknown[] = []> = (request: NextRequest, ...arguments_: arguments_) => Promise<Response> | Response;
+/** Next.js-specific configuration for MPP compatibility wrappers. */
+export type Config = Omit<Negotiator.Config, 'routes' | 'server'>;
+/**
+ * Adds MPP negotiation to the official x402 Next.js route wrapper.
+ *
+ * The official adapter retains ownership of route execution, cancellation,
+ * extensions, and post-handler x402 settlement.
+ */
+export declare function mpp<arguments_ extends unknown[]>(handler: RouteHandler<arguments_>, route: RouteConfig, server: x402ResourceServer, config: Config): RouteHandler<arguments_>;
+/** Creates a dual-protocol Next.js proxy handler backed by the official x402 proxy. */
+export declare function mppProxy(routes: RoutesConfig, server: x402ResourceServer, config: Config): RouteHandler;
+export {};
+//# sourceMappingURL=next.d.ts.map

package/dist/x402/middlewares/next.js

@@ -0,0 +1,58 @@
+import { NextAdapter, paymentProxyFromHTTPServer, withX402FromHTTPServer } from '@x402/next';
+import { NextResponse } from 'next/server.js';
+import * as Negotiator from '../../integrations/x402/Negotiator.js';
+/**
+ * Adds MPP negotiation to the official x402 Next.js route wrapper.
+ *
+ * The official adapter retains ownership of route execution, cancellation,
+ * extensions, and post-handler x402 settlement.
+ */
+export function mpp(handler, route, server, config) {
+    return createHandler(handler, { '*': route }, server, config);
+}
+/** Creates a dual-protocol Next.js proxy handler backed by the official x402 proxy. */
+export function mppProxy(routes, server, config) {
+    const mpp = Negotiator.create({ ...config, routes, server });
+    const x402 = paymentProxyFromHTTPServer(mpp.httpServer, config.paywallConfig, undefined, false);
+    return async (request) => {
+        const result = await mpp.negotiate(request, createContext(request));
+        if (result.status === 'unprotected')
+            return NextResponse.next();
+        if (result.status === 'handled')
+            return result.response;
+        if (result.status === 'paid')
+            return result.withReceipt(NextResponse.next());
+        return x402(request);
+    };
+}
+function createHandler(handler, routes, server, config) {
+    const mpp = Negotiator.create({ ...config, routes, server });
+    const argumentsByRequest = new WeakMap();
+    const x402 = withX402FromHTTPServer(((request) => handler(request, ...argumentsByRequest.get(request))), mpp.httpServer, config.paywallConfig, undefined, false);
+    return async (request, ...arguments_) => {
+        const result = await mpp.negotiate(request, createContext(request));
+        if (result.status === 'unprotected')
+            return handler(request, ...arguments_);
+        if (result.status === 'handled')
+            return result.response;
+        if (result.status === 'paid')
+            return result.withReceipt(await handler(request, ...arguments_));
+        argumentsByRequest.set(request, arguments_);
+        try {
+            return await x402(request);
+        }
+        finally {
+            argumentsByRequest.delete(request);
+        }
+    };
+}
+function createContext(request) {
+    const paymentHeader = Negotiator.getX402Credential(request);
+    return {
+        adapter: new NextAdapter(request),
+        method: request.method,
+        path: request.nextUrl.pathname,
+        ...(paymentHeader ? { paymentHeader } : {}),
+    };
+}
+//# sourceMappingURL=next.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mppx",
   "type": "module",
-  "version": "0.8.19",
+  "version": "0.9.1",
   "main": "./dist/index.js",
   "license": "MIT",
   "homepage": "https://github.com/wevm/mppx#readme",
@@ -103,6 +103,22 @@
       "types": "./dist/x402/index.d.ts",
       "default": "./dist/x402/index.js"
     },
+    "./x402/express": {
+      "types": "./dist/x402/middlewares/express.d.ts",
+      "default": "./dist/x402/middlewares/express.js"
+    },
+    "./x402/hono": {
+      "types": "./dist/x402/middlewares/hono.d.ts",
+      "default": "./dist/x402/middlewares/hono.js"
+    },
+    "./x402/next": {
+      "types": "./dist/x402/middlewares/next.d.ts",
+      "default": "./dist/x402/middlewares/next.js"
+    },
+    "./x402/mcp": {
+      "types": "./dist/x402/mcp.d.ts",
+      "default": "./dist/x402/mcp.js"
+    },
     "./tempo": {
       "types": "./dist/tempo/index.d.ts",
       "default": "./dist/tempo/index.js"
@@ -142,15 +158,36 @@
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": ">=1.25.0",
+    "@x402/core": ">=2.22.0",
+    "@x402/express": ">=2.22.0",
+    "@x402/hono": ">=2.22.0",
+    "@x402/mcp": ">=2.22.0",
+    "@x402/next": ">=2.22.0",
     "elysia": ">=1",
     "express": ">=5",
     "hono": ">=4.12.25",
+    "next": ">=16.2.6",
     "viem": ">=2.54.0"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
       "optional": true
     },
+    "@x402/core": {
+      "optional": true
+    },
+    "@x402/express": {
+      "optional": true
+    },
+    "@x402/hono": {
+      "optional": true
+    },
+    "@x402/mcp": {
+      "optional": true
+    },
+    "@x402/next": {
+      "optional": true
+    },
     "elysia": {
       "optional": true
     },
@@ -159,6 +196,9 @@
     },
     "hono": {
       "optional": true
+    },
+    "next": {
+      "optional": true
     }
   },
   "dependencies": {

package/dist/tempo/internal/machine-token-charge.d.ts

@@ -1,51 +0,0 @@
-import type * as Hex from 'ox/Hex';
-import { type Address, type Client } from 'viem';
-type Call = {
-    data?: Hex.Hex | undefined;
-    to?: Address | undefined;
-    value?: bigint | undefined;
-};
-type RouteCall = {
-    data: Hex.Hex;
-    to: Address;
-};
-type Route = {
-    calls: readonly [RouteCall, RouteCall];
-    settlementSender: Address;
-    transfers: readonly [{
-        amount: bigint;
-        memo: Hex.Hex;
-        recipient: Address;
-    }];
-};
-type Transfer = {
-    amount: bigint | string;
-    memo?: string | undefined;
-    recipient: Address;
-};
-/** Returns whether a first-party machine-token charge route is deployed on a chain. */
-export declare function isSupported(chainId: number | undefined): boolean;
-/** Resolves the canonical first-party settlement route for a compatible charge. */
-export declare function getRoute(parameters: {
-    chainId: number | undefined;
-    currency: Address;
-    transfers: readonly Transfer[];
-}): Route | undefined;
-/** Builds and simulates the first-party settlement route. */
-export declare function findRoute(client: Client, parameters: {
-    account: Address;
-    chainId: number;
-    currency: Address;
-    transfers: readonly Transfer[];
-}): Promise<Route | undefined>;
-/** Matches an exact first-party settlement route. */
-export declare function matchRoute(parameters: {
-    calls: readonly Call[];
-    chainId: number | undefined;
-    currency: Address;
-    transfers: readonly Transfer[];
-}): Route | undefined;
-/** Returns the trusted sender that settles the configured charge route on a chain. */
-export declare function getSettlementSender(chainId: number | undefined): Address | undefined;
-export {};
-//# sourceMappingURL=machine-token-charge.d.ts.map

package/dist/tempo/internal/machine-token-charge.js

@@ -1,113 +0,0 @@
-import { decodeFunctionData, encodeFunctionData, isAddressEqual, } from 'viem';
-import { call, readContract } from 'viem/actions';
-import { Abis, Actions } from 'viem/tempo';
-import * as defaults from './defaults.js';
-const swapAbi = [
-    {
-        inputs: [
-            { name: 'inputToken', type: 'address' },
-            { name: 'amount', type: 'uint256' },
-            { name: 'targetToken', type: 'address' },
-            { name: 'recipient', type: 'address' },
-            { name: 'memo', type: 'bytes32' },
-        ],
-        name: 'swapTo',
-        outputs: [],
-        stateMutability: 'nonpayable',
-        type: 'function',
-    },
-];
-function getDeployment(chainId) {
-    if (chainId === undefined)
-        return undefined;
-    return defaults.machineToken[chainId];
-}
-/** Returns whether a first-party machine-token charge route is deployed on a chain. */
-export function isSupported(chainId) {
-    return !!getDeployment(chainId);
-}
-/** Resolves the canonical first-party settlement route for a compatible charge. */
-export function getRoute(parameters) {
-    const deployment = getDeployment(parameters.chainId);
-    const transfer = parameters.transfers.length === 1 ? parameters.transfers[0] : undefined;
-    if (!deployment || !transfer?.memo)
-        return undefined;
-    const amount = BigInt(transfer.amount);
-    const memo = transfer.memo;
-    return {
-        calls: [
-            {
-                data: encodeFunctionData({
-                    abi: Abis.tip20,
-                    functionName: 'approve',
-                    args: [deployment.swap, amount],
-                }),
-                to: deployment.token,
-            },
-            {
-                data: encodeFunctionData({
-                    abi: swapAbi,
-                    functionName: 'swapTo',
-                    args: [deployment.token, amount, parameters.currency, transfer.recipient, memo],
-                }),
-                to: deployment.swap,
-            },
-        ],
-        settlementSender: deployment.swap,
-        transfers: [{ amount, memo, recipient: transfer.recipient }],
-    };
-}
-/** Builds and simulates the first-party settlement route. */
-export async function findRoute(client, parameters) {
-    const route = getRoute(parameters);
-    if (!route)
-        return undefined;
-    try {
-        const balance = await readContract(client, Actions.token.getBalance.call(client, {
-            account: parameters.account,
-            token: route.calls[0].to,
-        }));
-        if (balance < route.transfers[0].amount)
-            return undefined;
-        await call(client, { account: parameters.account, calls: route.calls });
-        return route;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Matches an exact first-party settlement route. */
-export function matchRoute(parameters) {
-    const transfer = parameters.transfers.length === 1 ? parameters.transfers[0] : undefined;
-    const swap = parameters.calls[1];
-    if (!transfer || parameters.calls.length !== 2 || !swap?.data)
-        return undefined;
-    try {
-        const decoded = decodeFunctionData({ abi: swapAbi, data: swap.data });
-        const route = getRoute({
-            ...parameters,
-            transfers: [{ ...transfer, memo: transfer.memo ?? decoded.args[4] }],
-        });
-        if (!route)
-            return undefined;
-        if (parameters.calls.some((call, index) => {
-            const expected = route.calls[index];
-            return (!call.data ||
-                !call.to ||
-                !expected ||
-                (call.value ?? 0n) !== 0n ||
-                !isAddressEqual(call.to, expected.to) ||
-                call.data.toLowerCase() !== expected.data.toLowerCase());
-        }))
-            return undefined;
-        return route;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Returns the trusted sender that settles the configured charge route on a chain. */
-export function getSettlementSender(chainId) {
-    return getDeployment(chainId)?.swap;
-}
-//# sourceMappingURL=machine-token-charge.js.map