x402-proxy-openclaw 0.10.9

package/dist/handler.js

@@ -0,0 +1,319 @@
+import { getMppVoucherHeadroomUsdc, isDebugEnabled } from "./lib/env.js";
+import { decodePaymentResponseHeader, wrapFetchWithPayment } from "@x402/fetch";
+import { parseUnits } from "viem";
+//#region packages/x402-proxy/src/handler.ts
+/**
+* Extract the on-chain transaction signature from an x402 payment response header.
+*/
+function extractTxSignature(response) {
+	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.
+*/
+function createX402ProxyHandler(opts) {
+	const { client } = opts;
+	const paymentQueue = [];
+	client.onAfterPaymentCreation(async (hookCtx) => {
+		const raw = hookCtx.selectedRequirements.amount;
+		paymentQueue.push({
+			protocol: "x402",
+			network: hookCtx.selectedRequirements.network,
+			payTo: hookCtx.selectedRequirements.payTo,
+			amount: raw,
+			asset: hookCtx.selectedRequirements.asset
+		});
+	});
+	return {
+		x402Fetch: wrapFetchWithPayment(globalThis.fetch, client),
+		shiftPayment: () => paymentQueue.shift()
+	};
+}
+const TEMPO_NETWORK = "eip155:4217";
+const MPP_VOUCHER_HEADROOM_USDC_DEFAULT = "0.005";
+function computeMppVoucherTarget(params) {
+	const { requiredCumulative, deposit, headroom } = params;
+	if (deposit <= requiredCumulative) return requiredCumulative;
+	if (headroom <= 0n) return requiredCumulative;
+	const target = requiredCumulative + headroom;
+	return target > deposit ? deposit : target;
+}
+function parseVoucherHeadroom(value) {
+	const configured = value?.trim() || MPP_VOUCHER_HEADROOM_USDC_DEFAULT;
+	try {
+		const parsed = parseUnits(configured, 6);
+		return parsed > 0n ? parsed : 0n;
+	} catch {
+		return parseUnits(MPP_VOUCHER_HEADROOM_USDC_DEFAULT, 6);
+	}
+}
+/**
+* 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 { Session } = await import("mppx/tempo");
+	const { privateKeyToAccount } = await import("viem/accounts");
+	const { saveSession, clearSession } = await import("./lib/config.js");
+	const account = privateKeyToAccount(opts.evmKey);
+	const maxDeposit = opts.maxDeposit ?? "1";
+	const voucherHeadroomRaw = parseVoucherHeadroom(getMppVoucherHeadroomUsdc());
+	const paymentQueue = [];
+	let lastChallengeAmount;
+	const debug = isDebugEnabled();
+	const mppx = Mppx.create({
+		methods: [tempo({
+			account,
+			maxDeposit
+		})],
+		polyfill: false,
+		onChallenge: async (challenge) => {
+			const req = challenge.request;
+			if (req.amount) lastChallengeAmount = (Number(req.amount) / 10 ** (req.decimals ?? 6)).toString();
+		}
+	});
+	const payerAddress = account.address;
+	function injectPayerHeader(init) {
+		const existing = init?.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init?.headers ?? {};
+		return {
+			...init,
+			headers: {
+				...existing,
+				"X-Payer-Address": payerAddress
+			}
+		};
+	}
+	const activeSessions = /* @__PURE__ */ new Set();
+	let persistedChannelId;
+	function rememberSession(session) {
+		activeSessions.add(session);
+		if (session.channelId && session.channelId !== persistedChannelId) {
+			persistedChannelId = session.channelId;
+			if (debug) process.stderr.write(`[x402-proxy] channelId: ${persistedChannelId}\n`);
+			try {
+				saveSession({
+					channelId: session.channelId,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
+			} catch {}
+		}
+	}
+	function pushCloseReceipt(session, receipt) {
+		if (!receipt) return;
+		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
+			}
+		});
+	}
+	return {
+		async fetch(input, init) {
+			const response = await mppx.fetch(typeof input === "string" ? input : input.toString(), injectPayerHeader(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,
+						amount: lastChallengeAmount,
+						receipt
+					});
+				} catch {
+					paymentQueue.push({
+						protocol: "mpp",
+						network: TEMPO_NETWORK,
+						amount: lastChallengeAmount
+					});
+				}
+				lastChallengeAmount = void 0;
+			}
+			return response;
+		},
+		async sse(input, init) {
+			const url = typeof input === "string" ? input : input.toString();
+			let createCredential;
+			let spent = 0n;
+			const session = {
+				channelId: void 0,
+				cumulative: 0n,
+				opened: false,
+				async close() {
+					if (!session.opened || !session.channelId || !createCredential) return void 0;
+					const credential = await createCredential({
+						action: "close",
+						channelId: session.channelId,
+						cumulativeAmountRaw: spent.toString()
+					});
+					const receiptHeader = (await mppx.rawFetch(url, {
+						method: "POST",
+						headers: {
+							Authorization: credential,
+							"X-Payer-Address": payerAddress
+						}
+					})).headers.get("Payment-Receipt");
+					if (!receiptHeader) return void 0;
+					try {
+						const receipt = Session.Receipt.deserializeSessionReceipt(receiptHeader);
+						spent = spent > BigInt(receipt.spent) ? spent : BigInt(receipt.spent);
+						return receipt;
+					} catch {
+						return;
+					}
+				}
+			};
+			const sessionMppx = Mppx.create({
+				methods: [tempo({
+					account,
+					maxDeposit,
+					onChannelUpdate(entry) {
+						session.channelId = entry.channelId;
+						session.cumulative = entry.cumulativeAmount;
+						session.opened = entry.opened;
+						if (entry.channelId && entry.channelId !== persistedChannelId) {
+							persistedChannelId = entry.channelId;
+							if (debug) process.stderr.write(`[x402-proxy] channelId: ${persistedChannelId}\n`);
+							try {
+								saveSession({
+									channelId: entry.channelId,
+									createdAt: (/* @__PURE__ */ new Date()).toISOString()
+								});
+							} catch {}
+						}
+					}
+				})],
+				polyfill: false,
+				onChallenge: async (challenge, helpers) => {
+					const req = challenge.request;
+					if (req.amount) lastChallengeAmount = (Number(req.amount) / 10 ** (req.decimals ?? 6)).toString();
+					createCredential = helpers.createCredential;
+				}
+			});
+			const response = await sessionMppx.fetch(url, injectPayerHeader({
+				...init,
+				headers: {
+					...init?.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init?.headers ?? {},
+					Accept: "text/event-stream"
+				}
+			}));
+			if (!response.body) throw new Error("MPP SSE response has no body");
+			rememberSession(session);
+			paymentQueue.push({
+				protocol: "mpp",
+				network: TEMPO_NETWORK,
+				intent: "session"
+			});
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			async function* iterate() {
+				let buffer = "";
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += decoder.decode(value, { stream: true });
+						const parts = buffer.split("\n\n");
+						buffer = parts.pop() ?? "";
+						for (const part of parts) {
+							if (!part.trim()) continue;
+							const event = Session.Sse.parseEvent(part);
+							if (!event) continue;
+							switch (event.type) {
+								case "message":
+									yield event.data;
+									break;
+								case "payment-receipt":
+									spent = spent > BigInt(event.data.spent) ? spent : BigInt(event.data.spent);
+									break;
+								case "payment-need-voucher": {
+									if (!createCredential) throw new Error("MPP voucher requested before challenge helper was captured");
+									const target = computeMppVoucherTarget({
+										requiredCumulative: BigInt(event.data.requiredCumulative),
+										deposit: BigInt(event.data.deposit),
+										headroom: voucherHeadroomRaw
+									});
+									const credential = await createCredential({
+										action: "voucher",
+										channelId: event.data.channelId,
+										cumulativeAmountRaw: target.toString()
+									});
+									const voucherResponse = await sessionMppx.rawFetch(url, {
+										method: "POST",
+										headers: {
+											Authorization: credential,
+											"X-Payer-Address": payerAddress
+										},
+										signal: init?.signal
+									});
+									if (!voucherResponse.ok) {
+										const body = await voucherResponse.text().catch(() => "");
+										throw new Error(`Voucher POST failed with status ${voucherResponse.status}${body ? `: ${body.slice(0, 200)}` : ""}`);
+									}
+									const receiptHeader = voucherResponse.headers.get("Payment-Receipt");
+									if (receiptHeader) try {
+										const receipt = Session.Receipt.deserializeSessionReceipt(receiptHeader);
+										spent = spent > BigInt(receipt.spent) ? spent : BigInt(receipt.spent);
+									} catch {}
+									break;
+								}
+							}
+						}
+					}
+				} finally {
+					reader.releaseLock();
+				}
+			}
+			return iterate();
+		},
+		shiftPayment: () => paymentQueue.shift(),
+		async close() {
+			const sessions = Array.from(activeSessions);
+			if (sessions.length === 0) return;
+			const byChannelId = /* @__PURE__ */ new Map();
+			const sessionsWithoutChannel = [];
+			for (const session of sessions) {
+				if (!session.opened) continue;
+				if (!session.channelId) {
+					sessionsWithoutChannel.push(session);
+					continue;
+				}
+				const existing = byChannelId.get(session.channelId);
+				if (!existing || session.cumulative > existing.cumulative) byChannelId.set(session.channelId, session);
+			}
+			for (const session of sessions) activeSessions.delete(session);
+			const sessionsToClose = [...byChannelId.values(), ...sessionsWithoutChannel];
+			let shouldClearPersistedSession = false;
+			for (const session of sessionsToClose) {
+				const receipt = await session.close();
+				if (session.channelId && session.channelId === persistedChannelId) shouldClearPersistedSession = true;
+				pushCloseReceipt(session, receipt);
+			}
+			if (shouldClearPersistedSession) try {
+				clearSession();
+			} catch {}
+		}
+	};
+}
+//#endregion
+export { TEMPO_NETWORK, createMppProxyHandler, createX402ProxyHandler, extractTxSignature };

package/dist/history.js

@@ -0,0 +1,124 @@
+import { dirname } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+function isMeaningfulInferenceRecord(record) {
+	if (record.kind !== "x402_inference") return true;
+	if (!record.ok) return true;
+	return record.amount != null || record.model != null || record.inputTokens != null || record.outputTokens != null || record.tx != null;
+}
+function appendHistory(historyPath, record) {
+	try {
+		mkdirSync(dirname(historyPath), { recursive: true });
+		appendFileSync(historyPath, `${JSON.stringify(record)}\n`);
+		if (existsSync(historyPath)) {
+			if (statSync(historyPath).size > 1e3 * 200) {
+				const lines = readFileSync(historyPath, "utf-8").trimEnd().split("\n");
+				if (lines.length > 1e3) writeFileSync(historyPath, `${lines.slice(-500).join("\n")}\n`);
+			}
+		}
+	} catch {}
+}
+function readHistory(historyPath) {
+	try {
+		if (!existsSync(historyPath)) return [];
+		const content = readFileSync(historyPath, "utf-8").trimEnd();
+		if (!content) return [];
+		return content.split("\n").flatMap((line) => {
+			try {
+				const parsed = JSON.parse(line);
+				if (typeof parsed.t !== "number" || typeof parsed.kind !== "string") return [];
+				const record = parsed;
+				return isMeaningfulInferenceRecord(record) ? [record] : [];
+			} catch {
+				return [];
+			}
+		});
+	} catch {
+		return [];
+	}
+}
+function calcSpend(records) {
+	const todayStart = /* @__PURE__ */ new Date();
+	todayStart.setUTCHours(0, 0, 0, 0);
+	const todayMs = todayStart.getTime();
+	let today = 0;
+	let total = 0;
+	let count = 0;
+	for (const r of records) {
+		if (!r.ok || r.amount == null) continue;
+		if (r.token !== "USDC") continue;
+		total += r.amount;
+		count++;
+		if (r.t >= todayMs) today += r.amount;
+	}
+	return {
+		today,
+		total,
+		count
+	};
+}
+function formatUsdcValue(amount) {
+	return new Intl.NumberFormat("en-US", {
+		useGrouping: false,
+		minimumFractionDigits: 0,
+		maximumFractionDigits: 12
+	}).format(amount);
+}
+function formatAmount(amount, token) {
+	if (token === "USDC") return `${formatUsdcValue(amount)} USDC`;
+	if (token === "SOL") return `${amount} SOL`;
+	return `${amount} ${token}`;
+}
+const KIND_LABELS = {
+	x402_inference: "inference",
+	x402_payment: "payment",
+	mpp_payment: "mpp payment",
+	transfer: "transfer",
+	buy: "buy",
+	sell: "sell",
+	mint: "mint",
+	swap: "swap"
+};
+function explorerUrl(net, tx) {
+	if (net.startsWith("eip155:")) {
+		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}`;
+}
+/** Strip provider prefix and OpenRouter date suffixes from model IDs.
+*  e.g. "minimax/minimax-m2.5-20260211" -> "minimax-m2.5"
+*       "moonshotai/kimi-k2.5-0127" -> "kimi-k2.5" */
+function shortModel(model) {
+	const parts = model.split("/");
+	return parts[parts.length - 1].replace(/-\d{6,8}$/, "").replace(/-\d{4}$/, "");
+}
+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;
+}
+function formatTxLine(r, opts) {
+	const time = new Date(r.t).toLocaleTimeString("en-US", {
+		hour: "2-digit",
+		minute: "2-digit",
+		hour12: false,
+		timeZone: "UTC"
+	});
+	const timeStr = r.tx ? `[${time}](${explorerUrl(r.net, r.tx)})` : time;
+	const parts = [r.kind === "x402_inference" && r.model ? shortModel(r.model) : KIND_LABELS[r.kind] ?? r.kind];
+	if (r.label) parts.push(r.label);
+	if (r.ok && r.amount != null && r.token) parts.push(formatAmount(r.amount, r.token));
+	else if (r.ok && r.kind === "sell" && r.meta?.pct != null) parts.push(`${r.meta.pct}%`);
+	parts.push(shortNetwork(r.net));
+	if (opts?.verbose && r.tx) {
+		const short = r.tx.length > 20 ? `${r.tx.slice(0, 10)}...${r.tx.slice(-6)}` : r.tx;
+		parts.push(short);
+	}
+	return `  ${timeStr} ${r.ok ? "" : "✗ "}${parts.join(" · ")}`;
+}
+//#endregion
+export { appendHistory, calcSpend, formatAmount, formatTxLine, formatUsdcValue, readHistory };

package/dist/lib/config.js

@@ -0,0 +1,47 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import "yaml";
+//#region packages/x402-proxy/src/lib/config.ts
+const APP_NAME = "x402-proxy";
+function getConfigDir() {
+	const xdg = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+	return path.join(xdg, APP_NAME);
+}
+function getWalletPath() {
+	return path.join(getConfigDir(), "wallet.json");
+}
+function getHistoryPath() {
+	return path.join(getConfigDir(), "history.jsonl");
+}
+function getDebugLogPath() {
+	return path.join(getConfigDir(), "debug.log");
+}
+function ensureConfigDir() {
+	fs.mkdirSync(getConfigDir(), { recursive: true });
+}
+function loadWalletFile() {
+	const p = getWalletPath();
+	if (!fs.existsSync(p)) return null;
+	try {
+		const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+		if (data.version === 1 && typeof data.mnemonic === "string") return data;
+		return null;
+	} catch {
+		return null;
+	}
+}
+function getSessionPath() {
+	return path.join(getConfigDir(), "session.json");
+}
+function saveSession(session) {
+	ensureConfigDir();
+	fs.writeFileSync(getSessionPath(), JSON.stringify(session, null, 2), "utf-8");
+}
+function clearSession() {
+	try {
+		fs.unlinkSync(getSessionPath());
+	} catch {}
+}
+//#endregion
+export { clearSession, ensureConfigDir, getDebugLogPath, getHistoryPath, loadWalletFile, saveSession };

package/dist/lib/debug-log.js

@@ -0,0 +1,29 @@
+import { ensureConfigDir, getDebugLogPath } from "./config.js";
+import { appendFileSync, existsSync, renameSync, rmSync, statSync } from "node:fs";
+//#region packages/x402-proxy/src/lib/debug-log.ts
+const MAX_DEBUG_LOG_BYTES = 10 * 1024 * 1024;
+const ROTATED_DEBUG_LOG_SUFFIX = ".1";
+function rotateIfNeeded(path) {
+	if (!existsSync(path)) return;
+	const { size } = statSync(path);
+	if (size <= MAX_DEBUG_LOG_BYTES) return;
+	const rotated = `${path}${ROTATED_DEBUG_LOG_SUFFIX}`;
+	try {
+		rmSync(rotated, { force: true });
+	} catch {}
+	renameSync(path, rotated);
+}
+function writeDebugLog(event, fields = {}) {
+	try {
+		ensureConfigDir();
+		const path = getDebugLogPath();
+		rotateIfNeeded(path);
+		appendFileSync(path, `${JSON.stringify({
+			ts: (/* @__PURE__ */ new Date()).toISOString(),
+			event,
+			...fields
+		})}\n`, "utf-8");
+	} catch {}
+}
+//#endregion
+export { writeDebugLog };

package/dist/lib/derive.js

@@ -0,0 +1,77 @@
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { base58 } from "@scure/base";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha512 } from "@noble/hashes/sha2.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { HDKey } from "@scure/bip32";
+import { mnemonicToSeedSync } from "@scure/bip39";
+import "@scure/bip39/wordlists/english.js";
+//#region packages/x402-proxy/src/lib/derive.ts
+/**
+* Wallet derivation from BIP-39 mnemonic.
+*
+* A single 24-word mnemonic is the root secret. Both Solana and EVM keypairs
+* are deterministically derived from it.
+*
+* Solana: SLIP-10 Ed25519 at m/44'/501'/0'/0'
+* EVM:    BIP-32 secp256k1  at m/44'/60'/0'/0/0
+*
+* Ported from agentbox/packages/openclaw-x402/src/wallet.ts
+*/
+/**
+* SLIP-10 Ed25519 derivation at m/44'/501'/0'/0' (Phantom/Backpack compatible).
+*/
+const enc = new TextEncoder();
+function deriveSolanaKeypair(mnemonic) {
+	const seed = mnemonicToSeedSync(mnemonic);
+	let I = hmac(sha512, enc.encode("ed25519 seed"), seed);
+	let key = I.slice(0, 32);
+	let chainCode = I.slice(32);
+	for (const index of [
+		2147483692,
+		2147484149,
+		2147483648,
+		2147483648
+	]) {
+		const data = new Uint8Array(37);
+		data[0] = 0;
+		data.set(key, 1);
+		data[33] = index >>> 24 & 255;
+		data[34] = index >>> 16 & 255;
+		data[35] = index >>> 8 & 255;
+		data[36] = index & 255;
+		I = hmac(sha512, chainCode, data);
+		key = I.slice(0, 32);
+		chainCode = I.slice(32);
+	}
+	const secretKey = new Uint8Array(key);
+	const publicKey = ed25519.getPublicKey(secretKey);
+	return {
+		secretKey,
+		publicKey,
+		address: base58.encode(publicKey)
+	};
+}
+/**
+* BIP-32 secp256k1 derivation at m/44'/60'/0'/0/0.
+*/
+function deriveEvmKeypair(mnemonic) {
+	const seed = mnemonicToSeedSync(mnemonic);
+	const derived = HDKey.fromMasterSeed(seed).derive("m/44'/60'/0'/0/0");
+	if (!derived.privateKey) throw new Error("Failed to derive EVM private key");
+	const privateKey = `0x${Buffer.from(derived.privateKey).toString("hex")}`;
+	const hash = keccak_256(secp256k1.getPublicKey(derived.privateKey, false).slice(1));
+	return {
+		privateKey,
+		address: checksumAddress(Buffer.from(hash.slice(-20)).toString("hex"))
+	};
+}
+function checksumAddress(addr) {
+	const hash = Buffer.from(keccak_256(enc.encode(addr))).toString("hex");
+	let out = "0x";
+	for (let i = 0; i < 40; i++) out += Number.parseInt(hash[i], 16) >= 8 ? addr[i].toUpperCase() : addr[i];
+	return out;
+}
+//#endregion
+export { deriveEvmKeypair, deriveSolanaKeypair };

package/dist/lib/env.js

@@ -0,0 +1,9 @@
+//#region packages/x402-proxy/src/lib/env.ts
+function isDebugEnabled() {
+	return process.env.X402_PROXY_DEBUG === "1";
+}
+function getMppVoucherHeadroomUsdc() {
+	return process.env.X402_PROXY_MPP_VOUCHER_HEADROOM_USDC;
+}
+//#endregion
+export { getMppVoucherHeadroomUsdc, isDebugEnabled };

package/dist/lib/optimized-svm-scheme.js

@@ -0,0 +1,86 @@
+import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, appendTransactionMessageInstructions, createDefaultRpcTransport, createSolanaRpcFromTransport, createTransactionMessage, getBase64EncodedWireTransaction, isSolanaError, mainnet, partiallySignTransactionMessageWithSigners, pipe, setTransactionMessageComputeUnitLimit, setTransactionMessageComputeUnitPrice, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash } from "@solana/kit";
+import { TOKEN_PROGRAM_ADDRESS, findAssociatedTokenPda, getTransferCheckedInstruction } from "@solana-program/token";
+//#region packages/x402-proxy/src/lib/optimized-svm-scheme.ts
+const MEMO_PROGRAM_ADDRESS = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+const COMPUTE_UNIT_LIMIT = 2e4;
+const COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1n;
+const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+const USDC_DECIMALS = 6;
+const MAINNET_RPC_URLS = ["https://api.mainnet.solana.com", "https://public.rpc.solanavibestation.com"];
+/**
+* Create a failover transport that tries each RPC in order.
+* On 429 from one endpoint, immediately tries the next instead of waiting.
+* Each transport gets its own coalescing via createDefaultRpcTransport.
+*/
+function createFailoverTransport(urls) {
+	const transports = urls.map((url) => createDefaultRpcTransport({ url }));
+	const failover = (async (config) => {
+		let lastError;
+		for (const transport of transports) try {
+			return await transport(config);
+		} catch (e) {
+			lastError = e;
+			if (isSolanaError(e, SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR) && e.context.statusCode === 429) continue;
+			throw e;
+		}
+		throw lastError;
+	});
+	return failover;
+}
+function createRpcClient(customRpcUrl) {
+	return createSolanaRpcFromTransport(createFailoverTransport((customRpcUrl ? [customRpcUrl, ...MAINNET_RPC_URLS] : MAINNET_RPC_URLS).map((u) => mainnet(u))));
+}
+/**
+* Optimized ExactSvmScheme that replaces upstream @x402/svm to prevent
+* RPC rate-limit failures on parallel payments.
+*
+* Two optimizations over upstream:
+* 1. Shared RPC client - @solana/kit's built-in request coalescing
+*    merges identical getLatestBlockhash calls in the same tick into 1.
+* 2. Hardcoded USDC - skips fetchMint RPC call for USDC (immutable data).
+*/
+var OptimizedSvmScheme = class {
+	scheme = "exact";
+	rpc;
+	constructor(signer, config) {
+		this.signer = signer;
+		this.rpc = createRpcClient(config?.rpcUrl);
+	}
+	async createPaymentPayload(x402Version, paymentRequirements) {
+		const rpc = this.rpc;
+		const asset = paymentRequirements.asset;
+		if (asset !== USDC_MINT) throw new Error(`Unsupported asset: ${asset}. Only USDC is supported.`);
+		const [[sourceATA], [destinationATA]] = await Promise.all([findAssociatedTokenPda({
+			mint: asset,
+			owner: this.signer.address,
+			tokenProgram: TOKEN_PROGRAM_ADDRESS
+		}), findAssociatedTokenPda({
+			mint: asset,
+			owner: paymentRequirements.payTo,
+			tokenProgram: TOKEN_PROGRAM_ADDRESS
+		})]);
+		const transferIx = getTransferCheckedInstruction({
+			source: sourceATA,
+			mint: asset,
+			destination: destinationATA,
+			authority: this.signer,
+			amount: BigInt(paymentRequirements.amount),
+			decimals: USDC_DECIMALS
+		});
+		const feePayer = paymentRequirements.extra?.feePayer;
+		if (!feePayer) throw new Error("feePayer is required in paymentRequirements.extra for SVM transactions");
+		const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+		const nonce = crypto.getRandomValues(new Uint8Array(16));
+		const memoIx = {
+			programAddress: MEMO_PROGRAM_ADDRESS,
+			accounts: [],
+			data: new TextEncoder().encode(Array.from(nonce).map((b) => b.toString(16).padStart(2, "0")).join(""))
+		};
+		return {
+			x402Version,
+			payload: { transaction: getBase64EncodedWireTransaction(await partiallySignTransactionMessageWithSigners(pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageComputeUnitPrice(COMPUTE_UNIT_PRICE_MICROLAMPORTS, tx), (tx) => setTransactionMessageComputeUnitLimit(COMPUTE_UNIT_LIMIT, tx), (tx) => setTransactionMessageFeePayer(feePayer, tx), (tx) => appendTransactionMessageInstructions([transferIx, memoIx], tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx)))) }
+		};
+	}
+};
+//#endregion
+export { OptimizedSvmScheme };