x402-proxy 0.5.2 → 0.7.0

package/dist/{derive-CISr_ond.js → derive-ibF2UinV.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
+import os from "node:os";
 import { parse, stringify } from "yaml";
 import { ed25519 } from "@noble/curves/ed25519.js";
 import { base58 } from "@scure/base";
@@ -158,4 +158,4 @@ function checksumAddress(addr) {
 }
 
 //#endregion
-export { getConfigDirShort as a, isConfigured as c, saveConfig as d, saveWalletFile as f, ensureConfigDir as i, loadConfig as l, deriveSolanaKeypair as n, getHistoryPath as o, generateMnemonic$1 as r, getWalletPath as s, deriveEvmKeypair as t, loadWalletFile as u };
+export { getHistoryPath as a, loadConfig as c, saveWalletFile as d, getConfigDirShort as i, loadWalletFile as l, deriveSolanaKeypair as n, getWalletPath as o, generateMnemonic$1 as r, isConfigured as s, deriveEvmKeypair as t, saveConfig as u };

package/dist/index.d.ts

@@ -5,11 +5,27 @@ import { KeyPairSigner } from "@solana/kit";
 
 //#region src/handler.d.ts
 type PaymentInfo = {
+  protocol: "x402";
   network: string | undefined;
   payTo: string | undefined; /** Raw amount in base units as returned by x402 (e.g. "50000" for 0.05 USDC) */
   amount: string | undefined;
   asset: string | undefined;
 };
+type MppPaymentInfo = {
+  protocol: "mpp";
+  network: string;
+  amount?: string;
+  intent?: string;
+  channelId?: string;
+  receipt?: {
+    method: string;
+    reference: string;
+    status: string;
+    timestamp: string;
+    acceptedCumulative?: string;
+    txHash?: string;
+  };
+};
 type X402ProxyOptions = {
   client: x402Client$1;
 };
@@ -17,20 +33,39 @@ type X402ProxyHandler = {
   /** Wrapped fetch with x402 payment handling */x402Fetch: (input: string | URL | Request, init?: RequestInit) => Promise<Response>; /** Shift the latest payment info from the queue (call after x402Fetch) */
   shiftPayment: () => PaymentInfo | undefined;
 };
+type MppProxyHandler = {
+  /** Payment-aware fetch that handles 402 + WWW-Authenticate automatically */fetch: (input: string | URL, init?: RequestInit) => Promise<Response>; /** SSE streaming with mid-stream voucher cycling */
+  sse: (input: string | URL, init?: RequestInit) => Promise<AsyncIterable<string>>; /** Shift the latest payment info from the queue */
+  shiftPayment: () => MppPaymentInfo | undefined; /** Settle any active session channel */
+  close: () => Promise<void>;
+};
+type DetectedProtocols = {
+  x402: boolean;
+  mpp: boolean;
+};
+/**
+ * Detect which payment protocols a 402 response advertises.
+ * - x402: PAYMENT-REQUIRED or X-PAYMENT-REQUIRED header
+ * - MPP: WWW-Authenticate header with Payment scheme
+ */
+declare function detectProtocols(response: Response): DetectedProtocols;
 /**
  * Extract the on-chain transaction signature from an x402 payment response header.
  */
 declare function extractTxSignature(response: Response): string | undefined;
 /**
  * Create an x402 proxy handler that wraps fetch with automatic payment.
- *
- * Chain-agnostic: accepts a pre-configured x402Client with any registered
- * schemes (SVM, EVM, etc). The handler captures payment info via the
- * onAfterPaymentCreation hook. Callers use `x402Fetch` for requests that
- * may require x402 payment, and `shiftPayment` to retrieve captured
- * payment info after each call.
  */
 declare function createX402ProxyHandler(opts: X402ProxyOptions): X402ProxyHandler;
+declare const TEMPO_NETWORK = "eip155:4217";
+/**
+ * Create an MPP proxy handler using mppx client.
+ * Dynamically imports mppx/client to keep startup fast.
+ */
+declare function createMppProxyHandler(opts: {
+  evmKey: string;
+  maxDeposit?: string;
+}): Promise<MppProxyHandler>;
 //#endregion
 //#region src/history.d.ts
 declare const HISTORY_MAX_LINES = 1000;
@@ -38,7 +73,7 @@ declare const HISTORY_KEEP_LINES = 500;
 type TxRecord = {
   t: number;
   ok: boolean;
-  kind: "x402_inference" | "x402_payment" | "transfer" | "buy" | "sell" | "mint" | "swap";
+  kind: "x402_inference" | "x402_payment" | "mpp_payment" | "transfer" | "buy" | "sell" | "mint" | "swap";
   net: string;
   from: string;
   to?: string;
@@ -82,4 +117,4 @@ declare function loadSvmWallet(keypairPath: string): Promise<KeyPairSigner>;
  */
 declare function loadEvmWallet(keyPath: string): ClientEvmSigner$1;
 //#endregion
-export { type ClientEvmSigner, ExactEvmScheme, ExactSvmScheme, HISTORY_KEEP_LINES, HISTORY_MAX_LINES, type PaymentInfo, type TxRecord, type X402ProxyHandler, type X402ProxyOptions, appendHistory, calcSpend, createX402ProxyHandler, explorerUrl, extractTxSignature, formatTxLine, loadEvmWallet, loadSvmWallet, readHistory, toClientEvmSigner, x402Client };
+export { type ClientEvmSigner, type DetectedProtocols, ExactEvmScheme, ExactSvmScheme, HISTORY_KEEP_LINES, HISTORY_MAX_LINES, type MppPaymentInfo, type MppProxyHandler, type PaymentInfo, TEMPO_NETWORK, type TxRecord, type X402ProxyHandler, type X402ProxyOptions, appendHistory, calcSpend, createMppProxyHandler, createX402ProxyHandler, detectProtocols, explorerUrl, extractTxSignature, formatTxLine, loadEvmWallet, loadSvmWallet, readHistory, toClientEvmSigner, x402Client };

package/dist/index.js

@@ -1,31 +1,42 @@
 import { ExactEvmScheme, toClientEvmSigner, toClientEvmSigner as toClientEvmSigner$1 } from "@x402/evm";
 import { decodePaymentResponseHeader, wrapFetchWithPayment, x402Client } from "@x402/fetch";
 import { ExactSvmScheme } from "@x402/svm/exact/client";
-import { appendFileSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { createKeyPairSignerFromBytes } from "@solana/kit";
 import { privateKeyToAccount } from "viem/accounts";
 
 //#region src/handler.ts
 /**
+* Detect which payment protocols a 402 response advertises.
+* - x402: PAYMENT-REQUIRED or X-PAYMENT-REQUIRED header
+* - MPP: WWW-Authenticate header with Payment scheme
+*/
+function detectProtocols(response) {
+	const pr = response.headers.get("PAYMENT-REQUIRED") ?? response.headers.get("X-PAYMENT-REQUIRED");
+	const wwwAuth = response.headers.get("WWW-Authenticate");
+	return {
+		x402: !!pr,
+		mpp: !!(wwwAuth && /^Payment\b/i.test(wwwAuth.trim()))
+	};
+}
+/**
 * Extract the on-chain transaction signature from an x402 payment response header.
 */
 function extractTxSignature(response) {
-	const header = response.headers.get("PAYMENT-RESPONSE") ?? response.headers.get("X-PAYMENT-RESPONSE");
-	if (!header) return void 0;
-	try {
-		return decodePaymentResponseHeader(header).transaction ?? void 0;
+	const x402Header = response.headers.get("PAYMENT-RESPONSE") ?? response.headers.get("X-PAYMENT-RESPONSE");
+	if (x402Header) try {
+		return decodePaymentResponseHeader(x402Header).transaction ?? void 0;
+	} catch {}
+	const mppHeader = response.headers.get("Payment-Receipt");
+	if (mppHeader) try {
+		return JSON.parse(Buffer.from(mppHeader, "base64url").toString()).reference ?? void 0;
 	} catch {
 		return;
 	}
 }
 /**
 * Create an x402 proxy handler that wraps fetch with automatic payment.
-*
-* Chain-agnostic: accepts a pre-configured x402Client with any registered
-* schemes (SVM, EVM, etc). The handler captures payment info via the
-* onAfterPaymentCreation hook. Callers use `x402Fetch` for requests that
-* may require x402 payment, and `shiftPayment` to retrieve captured
-* payment info after each call.
 */
 function createX402ProxyHandler(opts) {
 	const { client } = opts;
@@ -33,6 +44,7 @@ function createX402ProxyHandler(opts) {
 	client.onAfterPaymentCreation(async (hookCtx) => {
 		const raw = hookCtx.selectedRequirements.amount;
 		paymentQueue.push({
+			protocol: "x402",
 			network: hookCtx.selectedRequirements.network,
 			payTo: hookCtx.selectedRequirements.payTo,
 			amount: raw,
@@ -44,6 +56,84 @@ function createX402ProxyHandler(opts) {
 		shiftPayment: () => paymentQueue.shift()
 	};
 }
+const TEMPO_NETWORK = "eip155:4217";
+/**
+* Create an MPP proxy handler using mppx client.
+* Dynamically imports mppx/client to keep startup fast.
+*/
+async function createMppProxyHandler(opts) {
+	const { Mppx, tempo } = await import("mppx/client");
+	const { privateKeyToAccount } = await import("viem/accounts");
+	const account = privateKeyToAccount(opts.evmKey);
+	const maxDeposit = opts.maxDeposit ?? "1";
+	const paymentQueue = [];
+	const mppx = Mppx.create({
+		methods: [tempo({
+			account,
+			maxDeposit
+		})],
+		polyfill: false
+	});
+	let session;
+	return {
+		async fetch(input, init) {
+			const response = await mppx.fetch(typeof input === "string" ? input : input.toString(), init);
+			const receiptHeader = response.headers.get("Payment-Receipt");
+			if (receiptHeader) try {
+				const receipt = JSON.parse(Buffer.from(receiptHeader, "base64url").toString());
+				paymentQueue.push({
+					protocol: "mpp",
+					network: TEMPO_NETWORK,
+					receipt
+				});
+			} catch {
+				paymentQueue.push({
+					protocol: "mpp",
+					network: TEMPO_NETWORK
+				});
+			}
+			return response;
+		},
+		async sse(input, init) {
+			session ??= tempo.session({
+				account,
+				maxDeposit
+			});
+			const url = typeof input === "string" ? input : input.toString();
+			const iterable = await session.sse(url, init);
+			paymentQueue.push({
+				protocol: "mpp",
+				network: TEMPO_NETWORK,
+				intent: "session"
+			});
+			return iterable;
+		},
+		shiftPayment: () => paymentQueue.shift(),
+		async close() {
+			if (session?.opened) {
+				const receipt = await session.close();
+				if (receipt) {
+					const spentUsdc = receipt.spent ? (Number(receipt.spent) / 1e6).toString() : void 0;
+					paymentQueue.push({
+						protocol: "mpp",
+						network: TEMPO_NETWORK,
+						intent: "session",
+						amount: spentUsdc,
+						channelId: session.channelId ?? void 0,
+						receipt: {
+							method: receipt.method,
+							reference: receipt.reference,
+							status: receipt.status,
+							timestamp: receipt.timestamp,
+							acceptedCumulative: receipt.acceptedCumulative,
+							txHash: receipt.txHash
+						}
+					});
+				}
+			}
+		}
+	};
+}
 
 //#endregion
 //#region src/history.ts
@@ -51,6 +141,7 @@ const HISTORY_MAX_LINES = 1e3;
 const HISTORY_KEEP_LINES = 500;
 function appendHistory(historyPath, record) {
 	try {
+		mkdirSync(dirname(historyPath), { recursive: true });
 		appendFileSync(historyPath, `${JSON.stringify(record)}\n`);
 		if (existsSync(historyPath)) {
 			if (statSync(historyPath).size > HISTORY_MAX_LINES * 200) {
@@ -111,6 +202,7 @@ function formatAmount(amount, token) {
 const KIND_LABELS = {
 	x402_inference: "inference",
 	x402_payment: "payment",
+	mpp_payment: "mpp payment",
 	transfer: "transfer",
 	buy: "buy",
 	sell: "sell",
@@ -119,7 +211,9 @@ const KIND_LABELS = {
 };
 function explorerUrl(net, tx) {
 	if (net.startsWith("eip155:")) {
-		if (net.split(":")[1] === "8453") return `https://basescan.org/tx/${tx}`;
+		const chainId = net.split(":")[1];
+		if (chainId === "4217") return `https://explore.mainnet.tempo.xyz/tx/${tx}`;
+		if (chainId === "8453") return `https://basescan.org/tx/${tx}`;
 		return `https://basescan.org/tx/${tx}`;
 	}
 	return `https://solscan.io/tx/${tx}`;
@@ -133,6 +227,7 @@ function shortModel(model) {
 }
 function shortNetwork(net) {
 	if (net === "eip155:8453") return "base";
+	if (net === "eip155:4217") return "tempo";
 	if (net.startsWith("eip155:")) return `evm:${net.split(":")[1]}`;
 	if (net.startsWith("solana:")) return "sol";
 	return net;
@@ -178,4 +273,4 @@ function loadEvmWallet(keyPath) {
 }
 
 //#endregion
-export { ExactEvmScheme, ExactSvmScheme, HISTORY_KEEP_LINES, HISTORY_MAX_LINES, appendHistory, calcSpend, createX402ProxyHandler, explorerUrl, extractTxSignature, formatTxLine, loadEvmWallet, loadSvmWallet, readHistory, toClientEvmSigner, x402Client };
+export { ExactEvmScheme, ExactSvmScheme, HISTORY_KEEP_LINES, HISTORY_MAX_LINES, TEMPO_NETWORK, appendHistory, calcSpend, createMppProxyHandler, createX402ProxyHandler, detectProtocols, explorerUrl, extractTxSignature, formatTxLine, loadEvmWallet, loadSvmWallet, readHistory, toClientEvmSigner, x402Client };

package/dist/openclaw/plugin.d.ts

@@ -0,0 +1,55 @@
+import { x402Client } from "@x402/fetch";
+//#region src/openclaw/tools.d.ts
+type ModelEntry = {
+  provider: string;
+  id: string;
+  name: string;
+  maxTokens: number;
+  reasoning: boolean;
+  input: string[];
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+  contextWindow: number;
+};
+//#endregion
+//#region src/openclaw/plugin.d.ts
+type OpenClawPluginApi = {
+  pluginConfig?: Record<string, unknown>;
+  logger: {
+    info: (msg: string) => void;
+    error: (msg: string) => void;
+  };
+  registerProvider: (provider: {
+    id: string;
+    label: string;
+    auth: unknown[];
+    models: {
+      baseUrl: string;
+      api: string;
+      authHeader: boolean;
+      models: Array<Omit<ModelEntry, "provider"> & {
+        input: Array<"text" | "image">;
+      }>;
+    };
+  }) => void;
+  registerTool: (tool: unknown) => void;
+  registerCommand: (command: unknown) => void;
+  registerService: (service: {
+    id: string;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+  }) => void;
+  registerHttpRoute: (params: {
+    path: string;
+    match: string;
+    auth: string;
+    handler: (req: unknown, res: unknown) => Promise<void>;
+  }) => void;
+};
+declare function register(api: OpenClawPluginApi): void;
+//#endregion
+export { register };