x402-proxy-openclaw 0.10.9

package/dist/lib/output.js

@@ -0,0 +1,13 @@
+import pc from "picocolors";
+//#region packages/x402-proxy/src/lib/output.ts
+function isTTY() {
+	return !!process.stderr.isTTY;
+}
+function info(msg) {
+	process.stderr.write(`${isTTY() ? pc.cyan(msg) : msg}\n`);
+}
+function dim(msg) {
+	process.stderr.write(`${isTTY() ? pc.dim(msg) : msg}\n`);
+}
+//#endregion
+export { dim, info };

package/dist/lib/wallet-resolution.js

@@ -0,0 +1,76 @@
+import { loadWalletFile } from "./config.js";
+import { deriveEvmKeypair, deriveSolanaKeypair } from "./derive.js";
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { base58 } from "@scure/base";
+import { privateKeyToAccount } from "viem/accounts";
+//#region packages/x402-proxy/src/lib/wallet-resolution.ts
+/**
+* Resolve wallet keys following the priority cascade:
+* 1. Flags (--evm-key / --solana-key as raw key strings)
+* 2. X402_PROXY_WALLET_EVM_KEY / X402_PROXY_WALLET_SOLANA_KEY env vars
+* 3. X402_PROXY_WALLET_MNEMONIC env var (derives both)
+* 4. ~/.config/x402-proxy/wallet.json (mnemonic file)
+*/
+function resolveWallet(opts) {
+	if (opts?.evmKey || opts?.solanaKey) {
+		const result = { source: "flag" };
+		if (opts.evmKey) {
+			const hex = opts.evmKey.startsWith("0x") ? opts.evmKey : `0x${opts.evmKey}`;
+			result.evmKey = hex;
+			result.evmAddress = privateKeyToAccount(hex).address;
+		}
+		if (opts.solanaKey) {
+			result.solanaKey = parseSolanaKey(opts.solanaKey);
+			result.solanaAddress = solanaAddressFromKey(result.solanaKey);
+		}
+		return result;
+	}
+	const envEvm = process.env.X402_PROXY_WALLET_EVM_KEY;
+	const envSol = process.env.X402_PROXY_WALLET_SOLANA_KEY;
+	if (envEvm || envSol) {
+		const result = { source: "env" };
+		if (envEvm) {
+			const hex = envEvm.startsWith("0x") ? envEvm : `0x${envEvm}`;
+			result.evmKey = hex;
+			result.evmAddress = privateKeyToAccount(hex).address;
+		}
+		if (envSol) {
+			result.solanaKey = parseSolanaKey(envSol);
+			result.solanaAddress = solanaAddressFromKey(result.solanaKey);
+		}
+		return result;
+	}
+	const envMnemonic = process.env.X402_PROXY_WALLET_MNEMONIC;
+	if (envMnemonic) return resolveFromMnemonic(envMnemonic, "mnemonic-env");
+	const walletFile = loadWalletFile();
+	if (walletFile) return resolveFromMnemonic(walletFile.mnemonic, "wallet-file");
+	return { source: "none" };
+}
+function resolveFromMnemonic(mnemonic, source) {
+	const evm = deriveEvmKeypair(mnemonic);
+	const sol = deriveSolanaKeypair(mnemonic);
+	const solanaKey = new Uint8Array(64);
+	solanaKey.set(sol.secretKey, 0);
+	solanaKey.set(sol.publicKey, 32);
+	return {
+		evmKey: evm.privateKey,
+		evmAddress: evm.address,
+		solanaKey,
+		solanaAddress: sol.address,
+		source
+	};
+}
+function parseSolanaKey(input) {
+	const trimmed = input.trim();
+	if (trimmed.startsWith("[")) {
+		const arr = JSON.parse(trimmed);
+		return new Uint8Array(arr);
+	}
+	return base58.decode(trimmed);
+}
+function solanaAddressFromKey(keyBytes) {
+	if (keyBytes.length >= 64) return base58.encode(keyBytes.slice(32));
+	return base58.encode(ed25519.getPublicKey(keyBytes));
+}
+//#endregion
+export { resolveWallet };

package/dist/openclaw/plugin.d.ts

@@ -0,0 +1,15 @@
+import { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
+import * as openclaw_plugin_sdk0 from "openclaw/plugin-sdk";
+import * as openclaw_plugin_sdk_core0 from "openclaw/plugin-sdk/core";
+
+//#region packages/x402-proxy/src/openclaw/plugin.d.ts
+declare function register(api: OpenClawPluginApi): void;
+declare const _default: {
+  id: string;
+  name: string;
+  description: string;
+  configSchema: openclaw_plugin_sdk0.OpenClawPluginConfigSchema;
+  register: NonNullable<openclaw_plugin_sdk_core0.OpenClawPluginDefinition["register"]>;
+} & Pick<openclaw_plugin_sdk_core0.OpenClawPluginDefinition, "kind">;
+//#endregion
+export { _default as default, register };

package/dist/openclaw/plugin.js

@@ -0,0 +1,156 @@
+import { createMppProxyHandler, createX402ProxyHandler } from "../handler.js";
+import { getHistoryPath } from "../lib/config.js";
+import { OptimizedSvmScheme } from "../lib/optimized-svm-scheme.js";
+import { resolveWallet } from "../lib/wallet-resolution.js";
+import { loadSvmWallet } from "../wallet.js";
+import { SOL_MAINNET, addressForNetwork, createRequestTool, createWalletTool } from "../tools.js";
+import { createSendCommand, createWalletCommand } from "../commands.js";
+import { resolveProviders, routePrefixForBaseUrl } from "../defaults.js";
+import { createInferenceProxyRouteHandler } from "../route.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createKeyPairSignerFromBytes } from "@solana/kit";
+import { x402Client } from "@x402/fetch";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+//#region packages/x402-proxy/src/openclaw/plugin.ts
+function register(api) {
+	const config = api.pluginConfig ?? {};
+	const explicitKeypairPath = config.keypairPath;
+	const rpcUrl = config.rpcUrl || "https://api.mainnet-beta.solana.com";
+	const dashboardUrl = config.dashboardUrl || "";
+	const { providers, models: allModels } = resolveProviders(config);
+	const defaultProvider = providers[0];
+	for (const provider of providers) api.registerProvider({
+		id: provider.id,
+		label: provider.id,
+		auth: [],
+		catalog: {
+			order: "simple",
+			run: async () => ({ provider: {
+				baseUrl: provider.baseUrl,
+				api: "openai-completions",
+				authHeader: false,
+				models: provider.models
+			} })
+		}
+	});
+	api.logger.info(`x402-proxy: ${providers.map((provider) => `${provider.id}:${provider.protocol}`).join(", ")} - ${allModels.length} models`);
+	let solanaWalletAddress = null;
+	let evmWalletAddress = null;
+	let signerRef = null;
+	let proxyRef = null;
+	let mppHandlerRef = null;
+	let evmKeyRef = null;
+	let walletLoadPromise = null;
+	const historyPath = getHistoryPath();
+	const routePrefixes = [...new Set(providers.map((provider) => routePrefixForBaseUrl(provider.baseUrl)))];
+	const handler = createInferenceProxyRouteHandler({
+		providers,
+		getX402Proxy: () => proxyRef,
+		getMppHandler: () => mppHandlerRef,
+		getWalletAddress: () => solanaWalletAddress ?? evmWalletAddress,
+		getWalletAddressForNetwork: (network) => addressForNetwork(evmWalletAddress, solanaWalletAddress, network),
+		historyPath,
+		allModels,
+		logger: api.logger
+	});
+	for (const path of routePrefixes) api.registerHttpRoute({
+		path,
+		match: "prefix",
+		auth: "plugin",
+		handler
+	});
+	api.logger.info(`proxy: HTTP routes ${routePrefixes.join(", ")} registered for ${providers.map((provider) => provider.upstreamUrl).join(", ")}`);
+	async function ensureWalletLoaded() {
+		if (walletLoadPromise) {
+			await walletLoadPromise;
+			return;
+		}
+		walletLoadPromise = (async () => {
+			try {
+				const resolution = resolveWallet();
+				evmKeyRef = resolution.evmKey ?? null;
+				evmWalletAddress = resolution.evmAddress ?? null;
+				if (explicitKeypairPath) {
+					signerRef = await loadSvmWallet(explicitKeypairPath.startsWith("~/") ? join(homedir(), explicitKeypairPath.slice(2)) : explicitKeypairPath);
+					solanaWalletAddress = signerRef.address;
+				} else if (resolution.solanaKey && resolution.solanaAddress) {
+					signerRef = await createKeyPairSignerFromBytes(resolution.solanaKey);
+					solanaWalletAddress = resolution.solanaAddress;
+				} else {
+					signerRef = null;
+					solanaWalletAddress = null;
+				}
+				if (!solanaWalletAddress && !evmWalletAddress) {
+					api.logger.error("x402-proxy: no wallet found. Run `x402-proxy setup` to create one, or set X402_PROXY_WALLET_MNEMONIC / X402_PROXY_WALLET_EVM_KEY.");
+					return;
+				}
+				if (signerRef) {
+					const client = new x402Client();
+					client.register(SOL_MAINNET, new OptimizedSvmScheme(signerRef, { rpcUrl }));
+					proxyRef = createX402ProxyHandler({ client });
+				} else proxyRef = null;
+				if (evmKeyRef) {
+					const maxBudget = Math.max(...providers.map((p) => Number(p.mppSessionBudget) || .5)).toString();
+					mppHandlerRef = await createMppProxyHandler({
+						evmKey: evmKeyRef,
+						maxDeposit: maxBudget
+					});
+				} else mppHandlerRef = null;
+				api.logger.info(`wallets: solana=${solanaWalletAddress ?? "missing"} evm=${evmWalletAddress ?? "missing"}`);
+			} catch (err) {
+				api.logger.error(`wallet load failed: ${err}`);
+			}
+		})();
+		await walletLoadPromise;
+	}
+	ensureWalletLoaded();
+	api.registerService({
+		id: "x402-wallet",
+		async start() {
+			await ensureWalletLoaded();
+		},
+		async stop() {
+			if (mppHandlerRef) try {
+				await mppHandlerRef.close();
+			} catch {}
+		}
+	});
+	const toolCtx = {
+		ensureReady: ensureWalletLoaded,
+		getSolanaWalletAddress: () => solanaWalletAddress,
+		getEvmWalletAddress: () => evmWalletAddress,
+		getSigner: () => signerRef,
+		getX402Proxy: () => proxyRef,
+		getEvmKey: () => evmKeyRef,
+		getDefaultRequestProtocol: () => defaultProvider?.protocol ?? "mpp",
+		getDefaultMppSessionBudget: () => defaultProvider?.mppSessionBudget ?? "0.5",
+		rpcUrl,
+		historyPath,
+		allModels
+	};
+	api.registerTool(createWalletTool(toolCtx), { names: ["x_balance"] });
+	api.registerTool(createRequestTool(toolCtx), { names: ["x_payment"] });
+	const cmdCtx = {
+		ensureReady: ensureWalletLoaded,
+		getSolanaWalletAddress: () => solanaWalletAddress,
+		getEvmWalletAddress: () => evmWalletAddress,
+		getSigner: () => signerRef,
+		getDefaultRequestProtocol: () => defaultProvider?.protocol ?? "mpp",
+		getDefaultMppSessionBudget: () => defaultProvider?.mppSessionBudget ?? "0.5",
+		rpcUrl,
+		dashboardUrl,
+		historyPath,
+		allModels
+	};
+	api.registerCommand(createWalletCommand(cmdCtx));
+	api.registerCommand(createSendCommand(cmdCtx));
+}
+var plugin_default = definePluginEntry({
+	id: "x402-proxy",
+	name: "mpp/x402 Payments Proxy",
+	description: "x402 and MPP payments, wallet tools, and paid inference proxying",
+	register
+});
+//#endregion
+export { plugin_default as default, register };

package/dist/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
+    }
+  }
+}