x402-proxy-openclaw 0.10.9

package/dist/solana.js

@@ -0,0 +1,93 @@
+import { address, appendTransactionMessageInstructions, createSolanaRpc, createTransactionMessage, getAddressEncoder, getBase64EncodedWireTransaction, getProgramDerivedAddress, partiallySignTransactionMessageWithSigners, pipe, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash } from "@solana/kit";
+//#region packages/x402-proxy/src/openclaw/solana.ts
+const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const ASSOCIATED_TOKEN_PROGRAM = address("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+async function findAta(mint, owner) {
+	const encoder = getAddressEncoder();
+	const [pda] = await getProgramDerivedAddress({
+		programAddress: ASSOCIATED_TOKEN_PROGRAM,
+		seeds: [
+			encoder.encode(owner),
+			encoder.encode(TOKEN_PROGRAM),
+			encoder.encode(mint)
+		]
+	});
+	return pda;
+}
+function transferCheckedIx(source, mint, destination, authority, amount, decimals) {
+	const data = new Uint8Array(10);
+	data[0] = 12;
+	new DataView(data.buffer).setBigUint64(1, amount, true);
+	data[9] = decimals;
+	return {
+		programAddress: TOKEN_PROGRAM,
+		accounts: [
+			{
+				address: source,
+				role: 2
+			},
+			{
+				address: mint,
+				role: 0
+			},
+			{
+				address: destination,
+				role: 2
+			},
+			{
+				address: authority.address,
+				role: 1
+			}
+		],
+		data
+	};
+}
+async function getTokenAccounts(rpcUrl, owner) {
+	const { value } = await createSolanaRpc(rpcUrl).getTokenAccountsByOwner(address(owner), { programId: TOKEN_PROGRAM }, { encoding: "jsonParsed" }).send();
+	return value.map((v) => {
+		const info = v.account.data.parsed.info;
+		return {
+			mint: info.mint,
+			amount: info.tokenAmount.uiAmountString,
+			decimals: info.tokenAmount.decimals
+		};
+	}).filter((t) => t.mint !== USDC_MINT && t.amount !== "0");
+}
+async function getUsdcBalance(rpcUrl, owner) {
+	const { value } = await createSolanaRpc(rpcUrl).getTokenAccountsByOwner(address(owner), { mint: address(USDC_MINT) }, { encoding: "jsonParsed" }).send();
+	if (value.length > 0) {
+		const ta = value[0].account.data.parsed.info.tokenAmount;
+		return {
+			raw: BigInt(ta.amount),
+			ui: ta.uiAmount !== null ? ta.uiAmount.toFixed(2) : "0.00"
+		};
+	}
+	return {
+		raw: 0n,
+		ui: "0.00"
+	};
+}
+async function getSolBalanceLamports(rpcUrl, owner) {
+	const { value } = await createSolanaRpc(rpcUrl).getBalance(address(owner)).send();
+	return value;
+}
+async function getSolBalance(rpcUrl, owner) {
+	const lamports = await getSolBalanceLamports(rpcUrl, owner);
+	return (Number(lamports) / 1e9).toFixed(4);
+}
+async function checkAtaExists(rpcUrl, owner) {
+	const ata = await findAta(address(USDC_MINT), address(owner));
+	const { value } = await createSolanaRpc(rpcUrl).getAccountInfo(ata, { encoding: "base64" }).send();
+	return value !== null;
+}
+async function transferUsdc(signer, rpcUrl, dest, amountRaw) {
+	const rpc = createSolanaRpc(rpcUrl);
+	const usdcMint = address(USDC_MINT);
+	const transferIx = transferCheckedIx(await findAta(usdcMint, signer.address), usdcMint, await findAta(usdcMint, address(dest)), signer, amountRaw, 6);
+	const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+	const encoded = getBase64EncodedWireTransaction(await partiallySignTransactionMessageWithSigners(pipe(createTransactionMessage({ version: 0 }), (m) => setTransactionMessageFeePayer(signer.address, m), (m) => appendTransactionMessageInstructions([transferIx], m), (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m))));
+	return await rpc.sendTransaction(encoded, { encoding: "base64" }).send();
+}
+//#endregion
+export { checkAtaExists, getSolBalance, getTokenAccounts, getUsdcBalance, transferUsdc };

package/dist/tools.js

@@ -0,0 +1,269 @@
+import { TEMPO_NETWORK, createMppProxyHandler, extractTxSignature } from "./handler.js";
+import { appendHistory, calcSpend, formatAmount, readHistory } from "./history.js";
+import { getSolBalance, getTokenAccounts, getUsdcBalance } from "./solana.js";
+import { fetchAllBalances } from "./commands/wallet.js";
+import { Type } from "@sinclair/typebox";
+//#region packages/x402-proxy/src/openclaw/tools.ts
+const SOL_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+const USDC_DECIMALS = 6;
+const INFERENCE_RESERVE = .3;
+const MAX_RESPONSE_CHARS = 5e4;
+function paymentAmount(payment) {
+	if (!payment?.amount) return void 0;
+	const parsed = Number.parseFloat(payment.amount);
+	return Number.isNaN(parsed) ? void 0 : parsed / 10 ** USDC_DECIMALS;
+}
+function parseMppAmount(value) {
+	if (!value) return void 0;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function toolResult(text) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {}
+	};
+}
+function addressForNetwork(evmAddress, solanaAddress, network) {
+	if (network?.startsWith("eip155:")) return evmAddress ?? solanaAddress;
+	if (network?.startsWith("solana:")) return solanaAddress ?? evmAddress;
+	return solanaAddress ?? evmAddress;
+}
+function walletAddressForNetwork(ctx, network) {
+	return addressForNetwork(ctx.getEvmWalletAddress(), ctx.getSolanaWalletAddress(), network) ?? "unknown";
+}
+async function getWalletSnapshot(rpcUrl, solanaWallet, evmWallet, historyPath) {
+	const [{ ui, raw }, sol, tokens, balances] = await Promise.all([
+		solanaWallet ? getUsdcBalance(rpcUrl, solanaWallet) : Promise.resolve({
+			ui: "0",
+			raw: 0n
+		}),
+		solanaWallet ? getSolBalance(rpcUrl, solanaWallet) : Promise.resolve("0"),
+		solanaWallet ? getTokenAccounts(rpcUrl, solanaWallet).catch(() => []) : Promise.resolve([]),
+		fetchAllBalances(evmWallet ?? void 0, solanaWallet ?? void 0)
+	]);
+	const records = readHistory(historyPath);
+	return {
+		ui,
+		raw,
+		sol,
+		tokens,
+		balances,
+		records,
+		spend: calcSpend(records)
+	};
+}
+function createWalletTool(ctx) {
+	return {
+		name: "x_wallet",
+		label: "Wallet Status",
+		description: "Check wallet readiness, balances, and spend history for x402 and MPP payments before making paid requests.",
+		parameters: Type.Object({}),
+		async execute() {
+			await ctx.ensureReady();
+			const solanaWallet = ctx.getSolanaWalletAddress();
+			const evmWallet = ctx.getEvmWalletAddress();
+			if (!solanaWallet && !evmWallet) return toolResult("Wallet not configured yet. Run `x402-proxy setup` or set X402_PROXY_WALLET_MNEMONIC.");
+			try {
+				const snap = await getWalletSnapshot(ctx.rpcUrl, solanaWallet, evmWallet, ctx.historyPath);
+				const total = Number.parseFloat(snap.ui);
+				const available = Math.max(0, total - INFERENCE_RESERVE);
+				const tokenLines = snap.tokens.slice(0, 5).map((t) => {
+					const short = `${t.mint.slice(0, 4)}...${t.mint.slice(-4)}`;
+					return `${Number.parseFloat(t.amount).toLocaleString("en-US", { maximumFractionDigits: 0 })} (${short})`;
+				});
+				const lines = [
+					`Default protocol: ${ctx.getDefaultRequestProtocol()}`,
+					`MPP budget: ${ctx.getDefaultMppSessionBudget()} USDC`,
+					`MPP ready: ${evmWallet ? "yes" : "no"}`,
+					`x402 ready: ${solanaWallet ? "yes" : "no"}`
+				];
+				if (evmWallet) {
+					lines.push(`Base wallet: ${evmWallet}`);
+					lines.push(`Base balance: ${snap.balances.evm?.usdc ?? "?"} USDC`);
+					lines.push(`Tempo balance: ${snap.balances.tempo?.usdc ?? "?"} USDC`);
+				}
+				if (solanaWallet) {
+					lines.push(`Solana wallet: ${solanaWallet}`);
+					lines.push(`Solana: ${snap.sol} SOL`);
+					lines.push(`Solana USDC: ${snap.ui} USDC`);
+					lines.push(`Available for x402 tools: ${available.toFixed(2)} USDC`);
+					lines.push(`Reserved for inference: ${INFERENCE_RESERVE.toFixed(2)} USDC`);
+				}
+				lines.push(`Spent today: ${formatAmount(snap.spend.today, "USDC")}`);
+				lines.push(`Total spent: ${formatAmount(snap.spend.total, "USDC")} (${snap.spend.count} txs)`);
+				if (tokenLines.length > 0) lines.push(`Tokens held: ${tokenLines.join(", ")}`);
+				if (!evmWallet) lines.push("MPP setup hint: set X402_PROXY_WALLET_MNEMONIC or X402_PROXY_WALLET_EVM_KEY, or run x402-proxy setup.");
+				if (!solanaWallet) lines.push("x402 setup hint: add a Solana wallet or mnemonic if you want to pay Solana x402 endpoints.");
+				return toolResult(lines.join("\n"));
+			} catch (err) {
+				return toolResult(`Failed to check wallet status: ${String(err)}`);
+			}
+		}
+	};
+}
+function createRequestTool(ctx) {
+	return {
+		name: "x_request",
+		label: "Paid Request",
+		description: "Call a paid HTTP endpoint with automatic x402 or MPP settlement. Defaults to the plugin protocol and supports explicit protocol override.",
+		parameters: Type.Object({
+			url: Type.String({ description: "The paid endpoint URL" }),
+			method: Type.Optional(Type.String({ description: "HTTP method (default: GET)" })),
+			params: Type.Optional(Type.String({ description: "For GET: query params as JSON object. For POST/PUT/PATCH: JSON request body." })),
+			headers: Type.Optional(Type.String({ description: "Custom HTTP headers as JSON object" })),
+			protocol: Type.Optional(Type.Union([
+				Type.Literal("x402"),
+				Type.Literal("mpp"),
+				Type.Literal("auto")
+			], { description: "Override the default payment protocol for this request." }))
+		}),
+		async execute(_id, params) {
+			await ctx.ensureReady();
+			const solanaWallet = ctx.getSolanaWalletAddress();
+			const evmWallet = ctx.getEvmWalletAddress();
+			const method = (params.method || "GET").toUpperCase();
+			let url = params.url;
+			const reqInit = { method };
+			if (params.headers) try {
+				reqInit.headers = JSON.parse(params.headers);
+			} catch {
+				return toolResult("Invalid headers JSON.");
+			}
+			if (params.params) if (method === "GET" || method === "HEAD") try {
+				const qp = JSON.parse(params.params);
+				const qs = new URLSearchParams(qp).toString();
+				url = qs ? `${url}${url.includes("?") ? "&" : "?"}${qs}` : url;
+			} catch {
+				return toolResult("Invalid params JSON for GET request.");
+			}
+			else {
+				reqInit.body = params.params;
+				reqInit.headers = {
+					"Content-Type": "application/json",
+					...reqInit.headers
+				};
+			}
+			const protocol = params.protocol && [
+				"x402",
+				"mpp",
+				"auto"
+			].includes(params.protocol) ? params.protocol : ctx.getDefaultRequestProtocol();
+			const toolStartMs = Date.now();
+			if ((protocol === "mpp" || protocol === "auto") && !ctx.getEvmKey()) return toolResult("MPP request failed: no EVM wallet configured. Run x402-proxy setup or set X402_PROXY_WALLET_EVM_KEY.");
+			if (protocol === "x402") {
+				if (!solanaWallet) return toolResult("x402 request failed: no Solana wallet configured. Add a mnemonic or Solana key first.");
+				try {
+					const { ui } = await getUsdcBalance(ctx.rpcUrl, solanaWallet);
+					if (Number.parseFloat(ui) <= INFERENCE_RESERVE) return toolResult(`Insufficient funds. Balance: ${ui} USDC, reserved for inference: ${INFERENCE_RESERVE.toFixed(2)} USDC. Top up wallet: ${solanaWallet}`);
+				} catch {}
+				const proxy = ctx.getX402Proxy();
+				if (!proxy) return toolResult("x402 wallet is not ready yet. Try again in a moment.");
+				try {
+					const response = await proxy.x402Fetch(url, reqInit);
+					const body = await response.text();
+					if (response.status === 402) {
+						const payment = proxy.shiftPayment();
+						appendHistory(ctx.historyPath, {
+							t: Date.now(),
+							ok: false,
+							kind: "x402_payment",
+							net: payment?.network ?? "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+							from: walletAddressForNetwork(ctx, payment?.network),
+							label: url,
+							ms: Date.now() - toolStartMs,
+							error: "payment_required"
+						});
+						return toolResult(`Payment failed (402): ${body.substring(0, 500)}. Wallet: ${walletAddressForNetwork(ctx, payment?.network)}`);
+					}
+					const payment = proxy.shiftPayment();
+					const amount = paymentAmount(payment);
+					appendHistory(ctx.historyPath, {
+						t: Date.now(),
+						ok: true,
+						kind: "x402_payment",
+						net: payment?.network ?? "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+						from: walletAddressForNetwork(ctx, payment?.network),
+						to: payment?.payTo,
+						tx: extractTxSignature(response),
+						amount,
+						token: "USDC",
+						label: url,
+						ms: Date.now() - toolStartMs
+					});
+					const truncated = body.length > MAX_RESPONSE_CHARS ? `${body.substring(0, MAX_RESPONSE_CHARS)}\n\n[Truncated - response was ${body.length} chars]` : body;
+					return toolResult(`HTTP ${response.status}\n\n${truncated}`);
+				} catch (err) {
+					ctx.getX402Proxy()?.shiftPayment();
+					appendHistory(ctx.historyPath, {
+						t: Date.now(),
+						ok: false,
+						kind: "x402_payment",
+						net: SOL_MAINNET,
+						from: solanaWallet,
+						label: params.url,
+						error: String(err).substring(0, 200)
+					});
+					const msg = String(err);
+					return toolResult(msg.includes("Simulation failed") || msg.includes("insufficient") ? `Payment failed - insufficient funds. Wallet: ${solanaWallet}. Error: ${msg}` : `Request failed: ${msg}`);
+				}
+			}
+			const evmKey = ctx.getEvmKey();
+			if (!evmKey) return toolResult("MPP request failed: no EVM wallet configured. Run x402-proxy setup or set X402_PROXY_WALLET_EVM_KEY.");
+			const mpp = await createMppProxyHandler({
+				evmKey,
+				maxDeposit: ctx.getDefaultMppSessionBudget()
+			});
+			try {
+				const response = await mpp.fetch(url, reqInit);
+				const body = await response.text();
+				const payment = mpp.shiftPayment();
+				if (response.status === 402) {
+					appendHistory(ctx.historyPath, {
+						t: Date.now(),
+						ok: false,
+						kind: "mpp_payment",
+						net: payment?.network ?? "eip155:4217",
+						from: evmWallet ?? "unknown",
+						label: url,
+						ms: Date.now() - toolStartMs,
+						error: "payment_required"
+					});
+					return toolResult(`MPP payment failed (402): ${body.substring(0, 500)}`);
+				}
+				appendHistory(ctx.historyPath, {
+					t: Date.now(),
+					ok: true,
+					kind: "mpp_payment",
+					net: payment?.network ?? "eip155:4217",
+					from: evmWallet ?? "unknown",
+					tx: extractTxSignature(response) ?? payment?.receipt?.reference,
+					amount: parseMppAmount(payment?.amount),
+					token: "USDC",
+					label: url,
+					ms: Date.now() - toolStartMs
+				});
+				const truncated = body.length > MAX_RESPONSE_CHARS ? `${body.substring(0, MAX_RESPONSE_CHARS)}\n\n[Truncated - response was ${body.length} chars]` : body;
+				return toolResult(`HTTP ${response.status}\n\n${truncated}`);
+			} catch (err) {
+				appendHistory(ctx.historyPath, {
+					t: Date.now(),
+					ok: false,
+					kind: "mpp_payment",
+					net: TEMPO_NETWORK,
+					from: evmWallet ?? "unknown",
+					label: params.url,
+					error: String(err).substring(0, 200)
+				});
+				return toolResult(`MPP request failed: ${String(err)}`);
+			} finally {
+				await mpp.close().catch(() => {});
+			}
+		}
+	};
+}
+//#endregion
+export { SOL_MAINNET, addressForNetwork, createRequestTool, createWalletTool, getWalletSnapshot, parseMppAmount, paymentAmount };

package/dist/wallet.js

@@ -0,0 +1,15 @@
+import { createKeyPairSignerFromBytes } from "@solana/kit";
+import { readFileSync } from "node:fs";
+import "viem/accounts";
+import "@x402/evm";
+//#region packages/x402-proxy/src/wallet.ts
+/**
+* Load a Solana keypair from a solana-keygen JSON file.
+* Format: JSON array of 64 numbers [32 secret bytes + 32 public bytes].
+*/
+async function loadSvmWallet(keypairPath) {
+	const data = JSON.parse(readFileSync(keypairPath, "utf-8"));
+	return createKeyPairSignerFromBytes(new Uint8Array(data));
+}
+//#endregion
+export { loadSvmWallet };

package/openclaw.plugin.json

@@ -0,0 +1,112 @@
+{
+  "id": "x402-proxy",
+  "name": "mpp/x402 Payments Proxy",
+  "description": "x402 and MPP payments, wallet tools, and paid inference proxying",
+  "version": "0.10.9",
+  "providers": [
+    "surf"
+  ],
+  "autoEnableWhenConfiguredProviders": [
+    "surf"
+  ],
+  "skills": [
+    "skills"
+  ],
+  "contracts": {
+    "tools": [
+      "x_wallet",
+      "x_balance",
+      "x_request",
+      "x_payment"
+    ]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "providers": {
+        "type": "object",
+        "description": "Provider catalog keyed by name. Defaults to the built-in surf provider when omitted.",
+        "additionalProperties": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "baseUrl": {
+              "type": "string",
+              "description": "Gateway base path for this provider, typically under /x402-proxy"
+            },
+            "upstreamUrl": {
+              "type": "string",
+              "description": "Upstream inference origin to proxy to"
+            },
+            "protocol": {
+              "type": "string",
+              "enum": [
+                "x402",
+                "mpp",
+                "auto"
+              ],
+              "description": "Payment protocol for this provider. Defaults to mpp."
+            },
+            "mppSessionBudget": {
+              "type": "string",
+              "description": "Maximum USDC budget to lock for MPP sessions for this provider (default: 0.5)"
+            },
+            "models": {
+              "type": "array",
+              "description": "Static OpenClaw model catalog entries for this provider"
+            }
+          }
+        }
+      },
+      "protocol": {
+        "type": "string",
+        "enum": [
+          "x402",
+          "mpp",
+          "auto"
+        ],
+        "description": "Default payment protocol fallback for providers that do not override it."
+      },
+      "mppSessionBudget": {
+        "type": "string",
+        "description": "Default maximum USDC budget to lock for MPP sessions (default: 0.5)"
+      },
+      "keypairPath": {
+        "type": "string",
+        "description": "Optional path to Solana keypair JSON file (overrides x402-proxy wallet resolution for Solana/x402 surfaces)"
+      },
+      "rpcUrl": {
+        "type": "string",
+        "description": "Solana RPC URL"
+      },
+      "dashboardUrl": {
+        "type": "string",
+        "description": "URL to link from /x_wallet dashboard"
+      }
+    },
+    "required": []
+  },
+  "uiHints": {
+    "protocol": {
+      "label": "Default protocol",
+      "help": "Used only when a provider entry does not set its own protocol."
+    },
+    "mppSessionBudget": {
+      "label": "Default MPP budget",
+      "placeholder": "0.5"
+    },
+    "keypairPath": {
+      "label": "Solana keypair path",
+      "advanced": true
+    },
+    "rpcUrl": {
+      "label": "Solana RPC URL",
+      "advanced": true
+    },
+    "dashboardUrl": {
+      "label": "Dashboard URL",
+      "advanced": true
+    }
+  }
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "x402-proxy-openclaw",
+  "description": "OpenClaw plugin for x402 and MPP payments, wallet tools, and paid inference proxying.",
+  "version": "0.10.9",
+  "type": "module",
+  "sideEffects": false,
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cascade-protocol/x402-proxy.git",
+    "directory": "packages/x402-proxy"
+  },
+  "homepage": "https://github.com/cascade-protocol/x402-proxy#readme",
+  "bugs": {
+    "url": "https://github.com/cascade-protocol/x402-proxy/issues"
+  },
+  "main": "./dist/openclaw/plugin.js",
+  "types": "./dist/openclaw/plugin.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/openclaw/plugin.d.ts",
+      "default": "./dist/openclaw/plugin.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/openclaw/plugin.js"
+    ],
+    "providers": [
+      "surf"
+    ],
+    "compat": {
+      "pluginApi": ">=2026.3.24",
+      "minGatewayVersion": "2026.3.24"
+    },
+    "build": {
+      "openclawVersion": "2026.3.24",
+      "pluginSdkVersion": "2026.3.24"
+    }
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.3.8"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "@getmcp/generators": "^0.10.1",
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "@noble/curves": "^2.0.1",
+    "@noble/hashes": "^2.0.1",
+    "@scure/base": "^2.0.0",
+    "@scure/bip32": "^2.0.1",
+    "@scure/bip39": "^2.0.1",
+    "@sinclair/typebox": "^0.34.48",
+    "@solana-program/token": "^0.12.0",
+    "@solana/kit": "^6.5.0",
+    "@stricli/core": "^1.2.6",
+    "@x402/core": "^2.8.0",
+    "@x402/evm": "^2.8.0",
+    "@x402/fetch": "^2.8.0",
+    "@x402/mcp": "^2.8.0",
+    "@x402/svm": "^2.8.0",
+    "ethers": "^6.16.0",
+    "mppx": "^0.5.1",
+    "picocolors": "^1.1.1",
+    "viem": "^2.47.6",
+    "yaml": "^2.8.3"
+  },
+  "keywords": [
+    "x402",
+    "mpp",
+    "http-402",
+    "mcp",
+    "mcp-proxy",
+    "ai-agent",
+    "agentic-commerce",
+    "base",
+    "solana",
+    "tempo",
+    "usdc",
+    "coinbase",
+    "openclaw",
+    "openclaw-plugin"
+  ]
+}