@blockrun/clawrouter 0.11.12 → 0.11.14

package/dist/index.js

@@ -1,3 +1,168 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/solana-balance.ts
+var solana_balance_exports = {};
+__export(solana_balance_exports, {
+  SolanaBalanceMonitor: () => SolanaBalanceMonitor
+});
+import { address as solAddress, createSolanaRpc } from "@solana/kit";
+var SOLANA_USDC_MINT, SOLANA_DEFAULT_RPC, BALANCE_TIMEOUT_MS, CACHE_TTL_MS2, SolanaBalanceMonitor;
+var init_solana_balance = __esm({
+  "src/solana-balance.ts"() {
+    "use strict";
+    SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+    SOLANA_DEFAULT_RPC = "https://api.mainnet-beta.solana.com";
+    BALANCE_TIMEOUT_MS = 1e4;
+    CACHE_TTL_MS2 = 3e4;
+    SolanaBalanceMonitor = class {
+      rpc;
+      walletAddress;
+      cachedBalance = null;
+      cachedAt = 0;
+      constructor(walletAddress, rpcUrl) {
+        this.walletAddress = walletAddress;
+        const url = rpcUrl || process["env"].CLAWROUTER_SOLANA_RPC_URL || SOLANA_DEFAULT_RPC;
+        this.rpc = createSolanaRpc(url);
+      }
+      async checkBalance() {
+        const now = Date.now();
+        if (this.cachedBalance !== null && now - this.cachedAt < CACHE_TTL_MS2) {
+          return this.buildInfo(this.cachedBalance);
+        }
+        const balance = await this.fetchBalance();
+        this.cachedBalance = balance;
+        this.cachedAt = now;
+        return this.buildInfo(balance);
+      }
+      deductEstimated(amountMicros) {
+        if (this.cachedBalance !== null && this.cachedBalance >= amountMicros) {
+          this.cachedBalance -= amountMicros;
+        }
+      }
+      invalidate() {
+        this.cachedBalance = null;
+        this.cachedAt = 0;
+      }
+      async refresh() {
+        this.invalidate();
+        return this.checkBalance();
+      }
+      /**
+       * Check if balance is sufficient for an estimated cost.
+       */
+      async checkSufficient(estimatedCostMicros) {
+        const info = await this.checkBalance();
+        if (info.balance >= estimatedCostMicros) {
+          return { sufficient: true, info };
+        }
+        const shortfall = estimatedCostMicros - info.balance;
+        return {
+          sufficient: false,
+          info,
+          shortfall: this.formatUSDC(shortfall)
+        };
+      }
+      /**
+       * Format USDC amount (in micros) as "$X.XX".
+       */
+      formatUSDC(amountMicros) {
+        const dollars = Number(amountMicros) / 1e6;
+        return `$${dollars.toFixed(2)}`;
+      }
+      getWalletAddress() {
+        return this.walletAddress;
+      }
+      async fetchBalance() {
+        const owner = solAddress(this.walletAddress);
+        const mint = solAddress(SOLANA_USDC_MINT);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), BALANCE_TIMEOUT_MS);
+        try {
+          const response = await this.rpc.getTokenAccountsByOwner(owner, { mint }, { encoding: "jsonParsed" }).send({ abortSignal: controller.signal });
+          if (response.value.length === 0) return 0n;
+          let total = 0n;
+          for (const account of response.value) {
+            const parsed = account.account.data;
+            total += BigInt(parsed.parsed.info.tokenAmount.amount);
+          }
+          return total;
+        } catch (err) {
+          throw new Error(`Failed to fetch Solana USDC balance: ${err instanceof Error ? err.message : String(err)}`);
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      buildInfo(balance) {
+        const dollars = Number(balance) / 1e6;
+        return {
+          balance,
+          balanceUSD: `$${dollars.toFixed(2)}`,
+          isLow: balance < 1000000n,
+          isEmpty: balance < 100n,
+          walletAddress: this.walletAddress
+        };
+      }
+    };
+  }
+});
+
+// src/wallet.ts
+var wallet_exports = {};
+__export(wallet_exports, {
+  deriveAllKeys: () => deriveAllKeys,
+  deriveEvmKey: () => deriveEvmKey,
+  deriveSolanaKeyBytes: () => deriveSolanaKeyBytes,
+  generateWalletMnemonic: () => generateWalletMnemonic,
+  isValidMnemonic: () => isValidMnemonic
+});
+import { HDKey } from "@scure/bip32";
+import { generateMnemonic, mnemonicToSeedSync, validateMnemonic } from "@scure/bip39";
+import { wordlist as english } from "@scure/bip39/wordlists/english";
+import { privateKeyToAccount } from "viem/accounts";
+function generateWalletMnemonic() {
+  return generateMnemonic(english, 256);
+}
+function isValidMnemonic(mnemonic) {
+  return validateMnemonic(mnemonic, english);
+}
+function deriveEvmKey(mnemonic) {
+  const seed = mnemonicToSeedSync(mnemonic);
+  const hdKey = HDKey.fromMasterSeed(seed);
+  const derived = hdKey.derive(ETH_DERIVATION_PATH);
+  if (!derived.privateKey) throw new Error("Failed to derive EVM private key");
+  const hex = `0x${Buffer.from(derived.privateKey).toString("hex")}`;
+  const account = privateKeyToAccount(hex);
+  return { privateKey: hex, address: account.address };
+}
+function deriveSolanaKeyBytes(mnemonic) {
+  const seed = mnemonicToSeedSync(mnemonic);
+  const hdKey = HDKey.fromMasterSeed(seed);
+  const derived = hdKey.derive(SOLANA_DERIVATION_PATH);
+  if (!derived.privateKey) throw new Error("Failed to derive Solana private key");
+  return new Uint8Array(derived.privateKey);
+}
+function deriveAllKeys(mnemonic) {
+  const { privateKey: evmPrivateKey, address: evmAddress } = deriveEvmKey(mnemonic);
+  const solanaPrivateKeyBytes = deriveSolanaKeyBytes(mnemonic);
+  return { mnemonic, evmPrivateKey, evmAddress, solanaPrivateKeyBytes };
+}
+var ETH_DERIVATION_PATH, SOLANA_DERIVATION_PATH;
+var init_wallet = __esm({
+  "src/wallet.ts"() {
+    "use strict";
+    ETH_DERIVATION_PATH = "m/44'/60'/0'/0/0";
+    SOLANA_DERIVATION_PATH = "m/44'/501'/0'/0'";
+  }
+});
+
 // src/models.ts
 var MODEL_ALIASES = {
   // Claude - use newest versions (4.6)
@@ -644,271 +809,72 @@ var blockrunProvider = {
 // src/proxy.ts
 import { createServer } from "http";
 import { finished } from "stream";
-import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+import { createPublicClient as createPublicClient2, http as http2 } from "viem";
+import { base as base2 } from "viem/chains";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+import { x402Client } from "@x402/fetch";
 
-// src/x402.ts
-import { signTypedData, privateKeyToAccount } from "viem/accounts";
-
-// src/payment-cache.ts
+// src/payment-preauth.ts
+import { x402HTTPClient } from "@x402/fetch";
 var DEFAULT_TTL_MS = 36e5;
-var PaymentCache = class {
-  cache = /* @__PURE__ */ new Map();
-  ttlMs;
-  constructor(ttlMs = DEFAULT_TTL_MS) {
-    this.ttlMs = ttlMs;
-  }
-  /** Get cached payment params for an endpoint path. */
-  get(endpointPath) {
-    const entry = this.cache.get(endpointPath);
-    if (!entry) return void 0;
-    if (Date.now() - entry.cachedAt > this.ttlMs) {
-      this.cache.delete(endpointPath);
-      return void 0;
-    }
-    return entry;
-  }
-  /** Cache payment params from a 402 response. */
-  set(endpointPath, params) {
-    this.cache.set(endpointPath, { ...params, cachedAt: Date.now() });
-  }
-  /** Invalidate cache for an endpoint (e.g., if payTo changed). */
-  invalidate(endpointPath) {
-    this.cache.delete(endpointPath);
-  }
-};
-
-// src/x402.ts
-var BASE_CHAIN_ID = 8453;
-var BASE_SEPOLIA_CHAIN_ID = 84532;
-var DEFAULT_TOKEN_NAME = "USD Coin";
-var DEFAULT_TOKEN_VERSION = "2";
-var DEFAULT_NETWORK = "eip155:8453";
-var DEFAULT_MAX_TIMEOUT_SECONDS = 300;
-var TRANSFER_TYPES = {
-  TransferWithAuthorization: [
-    { name: "from", type: "address" },
-    { name: "to", type: "address" },
-    { name: "value", type: "uint256" },
-    { name: "validAfter", type: "uint256" },
-    { name: "validBefore", type: "uint256" },
-    { name: "nonce", type: "bytes32" }
-  ]
-};
-function createNonce() {
-  const bytes = new Uint8Array(32);
-  crypto.getRandomValues(bytes);
-  return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
-}
-function decodeBase64Json(value) {
-  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
-  const padding = (4 - normalized.length % 4) % 4;
-  const padded = normalized + "=".repeat(padding);
-  const decoded = Buffer.from(padded, "base64").toString("utf8");
-  return JSON.parse(decoded);
-}
-function encodeBase64Json(value) {
-  return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
-}
-function parsePaymentRequired(headerValue) {
-  return decodeBase64Json(headerValue);
-}
-function normalizeNetwork(network) {
-  if (!network || network.trim().length === 0) {
-    return DEFAULT_NETWORK;
-  }
-  return network.trim().toLowerCase();
-}
-function resolveChainId(network) {
-  const eip155Match = network.match(/^eip155:(\d+)$/i);
-  if (eip155Match) {
-    const parsed = Number.parseInt(eip155Match[1], 10);
-    if (Number.isFinite(parsed) && parsed > 0) {
-      return parsed;
-    }
-  }
-  if (network === "base") return BASE_CHAIN_ID;
-  if (network === "base-sepolia") return BASE_SEPOLIA_CHAIN_ID;
-  return BASE_CHAIN_ID;
-}
-function parseHexAddress(value) {
-  if (!value) return void 0;
-  const direct = value.match(/^0x[a-fA-F0-9]{40}$/);
-  if (direct) {
-    return direct[0];
-  }
-  const caipSuffix = value.match(/0x[a-fA-F0-9]{40}$/);
-  if (caipSuffix) {
-    return caipSuffix[0];
-  }
-  return void 0;
-}
-function requireHexAddress(value, field) {
-  const parsed = parseHexAddress(value);
-  if (!parsed) {
-    throw new Error(`Invalid ${field} in payment requirements: ${String(value)}`);
-  }
-  return parsed;
-}
-function setPaymentHeaders(headers, payload) {
-  headers.set("payment-signature", payload);
-  headers.set("x-payment", payload);
-}
-async function createPaymentPayload(privateKey, fromAddress, option, amount, requestUrl, resource) {
-  const network = normalizeNetwork(option.network);
-  const chainId = resolveChainId(network);
-  const recipient = requireHexAddress(option.payTo, "payTo");
-  const verifyingContract = requireHexAddress(option.asset, "asset");
-  const maxTimeoutSeconds = typeof option.maxTimeoutSeconds === "number" && option.maxTimeoutSeconds > 0 ? Math.floor(option.maxTimeoutSeconds) : DEFAULT_MAX_TIMEOUT_SECONDS;
-  const now = Math.floor(Date.now() / 1e3);
-  const validAfter = now - 600;
-  const validBefore = now + maxTimeoutSeconds;
-  const nonce = createNonce();
-  const signature = await signTypedData({
-    privateKey,
-    domain: {
-      name: option.extra?.name || DEFAULT_TOKEN_NAME,
-      version: option.extra?.version || DEFAULT_TOKEN_VERSION,
-      chainId,
-      verifyingContract
-    },
-    types: TRANSFER_TYPES,
-    primaryType: "TransferWithAuthorization",
-    message: {
-      from: fromAddress,
-      to: recipient,
-      value: BigInt(amount),
-      validAfter: BigInt(validAfter),
-      validBefore: BigInt(validBefore),
-      nonce
-    }
-  });
-  const paymentData = {
-    x402Version: 2,
-    resource: {
-      url: resource?.url || requestUrl,
-      description: resource?.description || "BlockRun AI API call",
-      mimeType: "application/json"
-    },
-    accepted: {
-      scheme: option.scheme,
-      network,
-      amount,
-      asset: option.asset,
-      payTo: option.payTo,
-      maxTimeoutSeconds: option.maxTimeoutSeconds,
-      extra: option.extra
-    },
-    payload: {
-      signature,
-      authorization: {
-        from: fromAddress,
-        to: recipient,
-        value: amount,
-        validAfter: validAfter.toString(),
-        validBefore: validBefore.toString(),
-        nonce
-      }
-    },
-    extensions: {}
-  };
-  return encodeBase64Json(paymentData);
-}
-function createPaymentFetch(privateKey) {
-  const account = privateKeyToAccount(privateKey);
-  const walletAddress = account.address;
-  const paymentCache = new PaymentCache();
-  const payFetch = async (input, init, preAuth) => {
-    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    const endpointPath = new URL(url).pathname;
-    const cached = paymentCache.get(endpointPath);
-    if (cached && preAuth?.estimatedAmount) {
-      const paymentPayload = await createPaymentPayload(
-        privateKey,
-        walletAddress,
-        {
-          scheme: cached.scheme,
-          network: cached.network,
-          asset: cached.asset,
-          payTo: cached.payTo,
-          maxTimeoutSeconds: cached.maxTimeoutSeconds,
-          extra: cached.extra
-        },
-        preAuth.estimatedAmount,
-        url,
-        {
-          url: cached.resourceUrl,
-          description: cached.resourceDescription
+function createPayFetchWithPreAuth(baseFetch, client, ttlMs = DEFAULT_TTL_MS, options) {
+  const httpClient = new x402HTTPClient(client);
+  const cache = /* @__PURE__ */ new Map();
+  return async (input, init) => {
+    const request = new Request(input, init);
+    const urlPath = new URL(request.url).pathname;
+    const cached = !options?.skipPreAuth ? cache.get(urlPath) : void 0;
+    if (cached && Date.now() - cached.cachedAt < ttlMs) {
+      try {
+        const payload2 = await client.createPaymentPayload(cached.paymentRequired);
+        const headers = httpClient.encodePaymentSignatureHeader(payload2);
+        const preAuthRequest = request.clone();
+        for (const [key, value] of Object.entries(headers)) {
+          preAuthRequest.headers.set(key, value);
         }
-      );
-      const preAuthHeaders = new Headers(init?.headers);
-      setPaymentHeaders(preAuthHeaders, paymentPayload);
-      const response2 = await fetch(input, { ...init, headers: preAuthHeaders });
-      if (response2.status !== 402) {
-        return response2;
-      }
-      const paymentHeader2 = response2.headers.get("x-payment-required");
-      if (paymentHeader2) {
-        return handle402(input, init, url, endpointPath, paymentHeader2);
-      }
-      paymentCache.invalidate(endpointPath);
-      const cleanResponse = await fetch(input, init);
-      if (cleanResponse.status !== 402) {
-        return cleanResponse;
-      }
-      const cleanHeader = cleanResponse.headers.get("x-payment-required");
-      if (!cleanHeader) {
-        throw new Error("402 response missing x-payment-required header");
+        const response2 = await baseFetch(preAuthRequest);
+        if (response2.status !== 402) {
+          return response2;
+        }
+        cache.delete(urlPath);
+      } catch {
+        cache.delete(urlPath);
       }
-      return handle402(input, init, url, endpointPath, cleanHeader);
     }
-    const response = await fetch(input, init);
+    const clonedRequest = request.clone();
+    const response = await baseFetch(request);
     if (response.status !== 402) {
       return response;
     }
-    const paymentHeader = response.headers.get("x-payment-required");
-    if (!paymentHeader) {
-      throw new Error("402 response missing x-payment-required header");
+    let paymentRequired;
+    try {
+      const getHeader = (name) => response.headers.get(name);
+      let body;
+      try {
+        const responseText = await response.text();
+        if (responseText) body = JSON.parse(responseText);
+      } catch {
+      }
+      paymentRequired = httpClient.getPaymentRequiredResponse(getHeader, body);
+      cache.set(urlPath, { paymentRequired, cachedAt: Date.now() });
+    } catch (error) {
+      throw new Error(
+        `Failed to parse payment requirements: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    const payload = await client.createPaymentPayload(paymentRequired);
+    const paymentHeaders = httpClient.encodePaymentSignatureHeader(payload);
+    for (const [key, value] of Object.entries(paymentHeaders)) {
+      clonedRequest.headers.set(key, value);
     }
-    return handle402(input, init, url, endpointPath, paymentHeader);
+    return baseFetch(clonedRequest);
   };
-  async function handle402(input, init, url, endpointPath, paymentHeader) {
-    const paymentRequired = parsePaymentRequired(paymentHeader);
-    const option = paymentRequired.accepts?.[0];
-    if (!option) {
-      throw new Error("No payment options in 402 response");
-    }
-    const amount = option.amount || option.maxAmountRequired;
-    if (!amount) {
-      throw new Error("No amount in payment requirements");
-    }
-    paymentCache.set(endpointPath, {
-      payTo: option.payTo,
-      asset: option.asset,
-      scheme: option.scheme,
-      network: option.network,
-      extra: option.extra,
-      maxTimeoutSeconds: option.maxTimeoutSeconds,
-      resourceUrl: paymentRequired.resource?.url,
-      resourceDescription: paymentRequired.resource?.description
-    });
-    const paymentPayload = await createPaymentPayload(
-      privateKey,
-      walletAddress,
-      option,
-      amount,
-      url,
-      paymentRequired.resource
-    );
-    const retryHeaders = new Headers(init?.headers);
-    setPaymentHeaders(retryHeaders, paymentPayload);
-    return fetch(input, {
-      ...init,
-      headers: retryHeaders
-    });
-  }
-  return { fetch: payFetch, cache: paymentCache };
 }
 
+// src/proxy.ts
+import { registerExactEvmScheme } from "@x402/evm/exact/client";
+import { toClientEvmSigner } from "@x402/evm";
+
 // src/router/rules.ts
 function scoreTokenCount(estimatedTokens, thresholds) {
   if (estimatedTokens < thresholds.simple) {
@@ -2435,7 +2401,7 @@ function route(prompt, systemPrompt, maxOutputTokens, options) {
   const ruleResult = classifyByRules(prompt, systemPrompt, estimatedTokens, config.scoring);
   const { routingProfile } = options;
   let tierConfigs;
-  let profileSuffix = "";
+  let profileSuffix;
   if (routingProfile === "eco" && config.ecoTiers) {
     tierConfigs = config.ecoTiers;
     profileSuffix = " | eco";
@@ -3252,6 +3218,199 @@ var BalanceMonitor = class {
   }
 };
 
+// src/proxy.ts
+init_solana_balance();
+
+// src/auth.ts
+import { writeFile, mkdir as mkdir2 } from "fs/promises";
+init_wallet();
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+var WALLET_DIR = join4(homedir3(), ".openclaw", "blockrun");
+var WALLET_FILE = join4(WALLET_DIR, "wallet.key");
+var MNEMONIC_FILE = join4(WALLET_DIR, "mnemonic");
+var CHAIN_FILE = join4(WALLET_DIR, "payment-chain");
+async function loadSavedWallet() {
+  try {
+    const key = (await readTextFile(WALLET_FILE)).trim();
+    if (key.startsWith("0x") && key.length === 66) {
+      console.log(`[ClawRouter] \u2713 Loaded existing wallet from ${WALLET_FILE}`);
+      return key;
+    }
+    console.error(`[ClawRouter] \u2717 CRITICAL: Wallet file exists but has invalid format!`);
+    console.error(`[ClawRouter]   File: ${WALLET_FILE}`);
+    console.error(`[ClawRouter]   Expected: 0x followed by 64 hex characters (66 chars total)`);
+    console.error(
+      `[ClawRouter]   To fix: restore your backup key or set BLOCKRUN_WALLET_KEY env var`
+    );
+    throw new Error(
+      `Wallet file at ${WALLET_FILE} is corrupted or has wrong format. Refusing to auto-generate new wallet to protect existing funds. Restore your backup key or set BLOCKRUN_WALLET_KEY environment variable.`
+    );
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      if (err instanceof Error && err.message.includes("Refusing to auto-generate")) {
+        throw err;
+      }
+      console.error(
+        `[ClawRouter] \u2717 Failed to read wallet file: ${err instanceof Error ? err.message : String(err)}`
+      );
+      throw new Error(
+        `Cannot read wallet file at ${WALLET_FILE}: ${err instanceof Error ? err.message : String(err)}. Refusing to auto-generate new wallet to protect existing funds. Fix file permissions or set BLOCKRUN_WALLET_KEY environment variable.`,
+        { cause: err }
+      );
+    }
+  }
+  return void 0;
+}
+async function loadMnemonic() {
+  try {
+    const mnemonic = (await readTextFile(MNEMONIC_FILE)).trim();
+    if (mnemonic && isValidMnemonic(mnemonic)) {
+      return mnemonic;
+    }
+    console.warn(`[ClawRouter] \u26A0 Mnemonic file exists but has invalid format \u2014 ignoring`);
+    return void 0;
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      console.warn(`[ClawRouter] \u26A0 Cannot read mnemonic file \u2014 ignoring`);
+    }
+  }
+  return void 0;
+}
+async function saveMnemonic(mnemonic) {
+  await mkdir2(WALLET_DIR, { recursive: true });
+  await writeFile(MNEMONIC_FILE, mnemonic + "\n", { mode: 384 });
+}
+async function generateAndSaveWallet() {
+  const existingMnemonic = await loadMnemonic();
+  if (existingMnemonic) {
+    throw new Error(
+      `Mnemonic file exists at ${MNEMONIC_FILE} but wallet.key is missing. This means a Solana wallet was derived from this mnemonic. Refusing to generate a new wallet to protect Solana funds. Restore your EVM key with: export BLOCKRUN_WALLET_KEY=<your_key>`
+    );
+  }
+  const mnemonic = generateWalletMnemonic();
+  const derived = deriveAllKeys(mnemonic);
+  await mkdir2(WALLET_DIR, { recursive: true });
+  await writeFile(WALLET_FILE, derived.evmPrivateKey + "\n", { mode: 384 });
+  await writeFile(MNEMONIC_FILE, mnemonic + "\n", { mode: 384 });
+  try {
+    const verification = (await readTextFile(WALLET_FILE)).trim();
+    if (verification !== derived.evmPrivateKey) {
+      throw new Error("Wallet file verification failed - content mismatch");
+    }
+    console.log(`[ClawRouter] Wallet saved and verified at ${WALLET_FILE}`);
+  } catch (err) {
+    throw new Error(
+      `Failed to verify wallet file after creation: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  console.log(`[ClawRouter]`);
+  console.log(`[ClawRouter] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+  console.log(`[ClawRouter]   NEW WALLET GENERATED \u2014 BACK UP YOUR KEY NOW`);
+  console.log(`[ClawRouter] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+  console.log(`[ClawRouter]   EVM Address : ${derived.evmAddress}`);
+  console.log(`[ClawRouter]   Key file    : ${WALLET_FILE}`);
+  console.log(`[ClawRouter]   Mnemonic    : ${MNEMONIC_FILE}`);
+  console.log(`[ClawRouter]`);
+  console.log(`[ClawRouter]   Both EVM (Base) and Solana wallets are ready.`);
+  console.log(`[ClawRouter]   To back up, run in OpenClaw:`);
+  console.log(`[ClawRouter]     /wallet export`);
+  console.log(`[ClawRouter]`);
+  console.log(`[ClawRouter]   To restore on another machine:`);
+  console.log(`[ClawRouter]     export BLOCKRUN_WALLET_KEY=<your_key>`);
+  console.log(`[ClawRouter] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+  console.log(`[ClawRouter]`);
+  return {
+    key: derived.evmPrivateKey,
+    address: derived.evmAddress,
+    mnemonic,
+    solanaPrivateKeyBytes: derived.solanaPrivateKeyBytes
+  };
+}
+async function resolveOrGenerateWalletKey() {
+  const saved = await loadSavedWallet();
+  if (saved) {
+    const account = privateKeyToAccount2(saved);
+    const mnemonic = await loadMnemonic();
+    if (mnemonic) {
+      const solanaKeyBytes = deriveSolanaKeyBytes(mnemonic);
+      return {
+        key: saved,
+        address: account.address,
+        source: "saved",
+        mnemonic,
+        solanaPrivateKeyBytes: solanaKeyBytes
+      };
+    }
+    return { key: saved, address: account.address, source: "saved" };
+  }
+  const envKey = process["env"].BLOCKRUN_WALLET_KEY;
+  if (typeof envKey === "string" && envKey.startsWith("0x") && envKey.length === 66) {
+    const account = privateKeyToAccount2(envKey);
+    const mnemonic = await loadMnemonic();
+    if (mnemonic) {
+      const solanaKeyBytes = deriveSolanaKeyBytes(mnemonic);
+      return {
+        key: envKey,
+        address: account.address,
+        source: "env",
+        mnemonic,
+        solanaPrivateKeyBytes: solanaKeyBytes
+      };
+    }
+    return { key: envKey, address: account.address, source: "env" };
+  }
+  const result = await generateAndSaveWallet();
+  return {
+    key: result.key,
+    address: result.address,
+    source: "generated",
+    mnemonic: result.mnemonic,
+    solanaPrivateKeyBytes: result.solanaPrivateKeyBytes
+  };
+}
+async function setupSolana() {
+  const existing = await loadMnemonic();
+  if (existing) {
+    throw new Error(
+      "Solana wallet already set up. Mnemonic file exists at " + MNEMONIC_FILE
+    );
+  }
+  const savedKey = await loadSavedWallet();
+  if (!savedKey) {
+    throw new Error(
+      "No EVM wallet found. Run ClawRouter first to generate a wallet before setting up Solana."
+    );
+  }
+  const mnemonic = generateWalletMnemonic();
+  const solanaKeyBytes = deriveSolanaKeyBytes(mnemonic);
+  await saveMnemonic(mnemonic);
+  console.log(`[ClawRouter] Solana wallet set up successfully.`);
+  console.log(`[ClawRouter] Mnemonic saved to ${MNEMONIC_FILE}`);
+  console.log(`[ClawRouter] Existing EVM wallet unchanged.`);
+  return { mnemonic, solanaPrivateKeyBytes: solanaKeyBytes };
+}
+async function savePaymentChain(chain) {
+  await mkdir2(WALLET_DIR, { recursive: true });
+  await writeFile(CHAIN_FILE, chain + "\n", { mode: 384 });
+}
+async function loadPaymentChain() {
+  try {
+    const content = (await readTextFile(CHAIN_FILE)).trim();
+    if (content === "solana") return "solana";
+    return "base";
+  } catch {
+    return "base";
+  }
+}
+async function resolvePaymentChain() {
+  if (process["env"].CLAWROUTER_PAYMENT_CHAIN === "solana") return "solana";
+  if (process["env"].CLAWROUTER_PAYMENT_CHAIN === "base") return "base";
+  return loadPaymentChain();
+}
+
 // src/compression/types.ts
 var DEFAULT_COMPRESSION_CONFIG = {
   enabled: true,
@@ -3281,7 +3440,7 @@ var DEFAULT_COMPRESSION_CONFIG = {
 };
 
 // src/compression/layers/deduplication.ts
-import crypto2 from "crypto";
+import crypto from "crypto";
 function hashMessage(message) {
   let contentStr = "";
   if (typeof message.content === "string") {
@@ -3301,7 +3460,7 @@ function hashMessage(message) {
     );
   }
   const content = parts.join("|");
-  return crypto2.createHash("md5").update(content).digest("hex");
+  return crypto.createHash("md5").update(content).digest("hex");
 }
 function deduplicateMessages(messages) {
   const seen = /* @__PURE__ */ new Set();
@@ -3454,7 +3613,7 @@ function generateCodebookHeader(usedCodes, pathMap = {}) {
     parts.push(`[Dict: ${codeEntries}]`);
   }
   if (Object.keys(pathMap).length > 0) {
-    const pathEntries = Object.entries(pathMap).map(([code, path]) => `${code}=${path}`).join(", ");
+    const pathEntries = Object.entries(pathMap).map(([code, path2]) => `${code}=${path2}`).join(", ");
     parts.push(`[Paths: ${pathEntries}]`);
   }
   return parts.join("\n");
@@ -3528,8 +3687,8 @@ function extractPaths(messages) {
 }
 function findFrequentPrefixes(paths) {
   const prefixCounts = /* @__PURE__ */ new Map();
-  for (const path of paths) {
-    const parts = path.split("/").filter(Boolean);
+  for (const path2 of paths) {
+    const parts = path2.split("/").filter(Boolean);
     for (let i = 2; i < parts.length; i++) {
       const prefix = "/" + parts.slice(0, i).join("/") + "/";
       prefixCounts.set(prefix, (prefixCounts.get(prefix) || 0) + 1);
@@ -4398,6 +4557,7 @@ ${lines.join("\n")}`;
 
 // src/proxy.ts
 var BLOCKRUN_API = "https://blockrun.ai/api";
+var BLOCKRUN_SOLANA_API = "https://sol.blockrun.ai/api";
 var AUTO_MODEL = "blockrun/auto";
 var ROUTING_PROFILES = /* @__PURE__ */ new Set([
   "blockrun/free",
@@ -4526,7 +4686,7 @@ async function checkExistingProxy(port) {
     if (response.ok) {
       const data = await response.json();
       if (data.status === "ok" && data.wallet) {
-        return data.wallet;
+        return { wallet: data.wallet, paymentChain: data.paymentChain };
       }
     }
     return void 0;
@@ -4956,31 +5116,78 @@ async function uploadDataUriToHost(dataUri) {
   throw new Error(`catbox.moe upload failed: ${result}`);
 }
 async function startProxy(options) {
-  const apiBase = options.apiBase ?? BLOCKRUN_API;
+  const walletKey = typeof options.wallet === "string" ? options.wallet : options.wallet.key;
+  const solanaPrivateKeyBytes = typeof options.wallet === "string" ? void 0 : options.wallet.solanaPrivateKeyBytes;
+  const paymentChain = options.paymentChain ?? await resolvePaymentChain();
+  const apiBase = options.apiBase ?? (paymentChain === "solana" && solanaPrivateKeyBytes ? BLOCKRUN_SOLANA_API : BLOCKRUN_API);
+  if (paymentChain === "solana" && !solanaPrivateKeyBytes) {
+    console.warn(`[ClawRouter] Payment chain is Solana but no Solana keys provided. Using Base (EVM).`);
+  } else if (paymentChain === "solana") {
+    console.log(`[ClawRouter] Payment chain: Solana (${BLOCKRUN_SOLANA_API})`);
+  }
   const listenPort = options.port ?? getProxyPort();
-  const existingWallet = await checkExistingProxy(listenPort);
-  if (existingWallet) {
-    const account2 = privateKeyToAccount2(options.walletKey);
-    const balanceMonitor2 = new BalanceMonitor(account2.address);
+  const existingProxy = await checkExistingProxy(listenPort);
+  if (existingProxy) {
+    const account2 = privateKeyToAccount3(walletKey);
     const baseUrl2 = `http://127.0.0.1:${listenPort}`;
-    if (existingWallet !== account2.address) {
+    if (existingProxy.wallet !== account2.address) {
       console.warn(
-        `[ClawRouter] Existing proxy on port ${listenPort} uses wallet ${existingWallet}, but current config uses ${account2.address}. Reusing existing proxy.`
+        `[ClawRouter] Existing proxy on port ${listenPort} uses wallet ${existingProxy.wallet}, but current config uses ${account2.address}. Reusing existing proxy.`
+      );
+    }
+    if (existingProxy.paymentChain) {
+      if (existingProxy.paymentChain !== paymentChain) {
+        throw new Error(
+          `Existing proxy on port ${listenPort} is using ${existingProxy.paymentChain} but ${paymentChain} was requested. Stop the existing proxy first or use a different port.`
+        );
+      }
+    } else if (paymentChain !== "base") {
+      console.warn(`[ClawRouter] Existing proxy on port ${listenPort} does not report paymentChain (pre-v0.11 instance). Assuming Base.`);
+      throw new Error(
+        `Existing proxy on port ${listenPort} is a pre-v0.11 instance (assumed Base) but ${paymentChain} was requested. Stop the existing proxy first or use a different port.`
       );
     }
+    let reuseSolanaAddress;
+    if (solanaPrivateKeyBytes) {
+      const { createKeyPairSignerFromPrivateKeyBytes } = await import("@solana/kit");
+      const solanaSigner = await createKeyPairSignerFromPrivateKeyBytes(solanaPrivateKeyBytes);
+      reuseSolanaAddress = solanaSigner.address;
+    }
+    const balanceMonitor2 = paymentChain === "solana" && reuseSolanaAddress ? new SolanaBalanceMonitor(reuseSolanaAddress) : new BalanceMonitor(account2.address);
     options.onReady?.(listenPort);
     return {
       port: listenPort,
       baseUrl: baseUrl2,
-      walletAddress: existingWallet,
+      walletAddress: existingProxy.wallet,
+      solanaAddress: reuseSolanaAddress,
       balanceMonitor: balanceMonitor2,
       close: async () => {
       }
     };
   }
-  const account = privateKeyToAccount2(options.walletKey);
-  const { fetch: payFetch } = createPaymentFetch(options.walletKey);
-  const balanceMonitor = new BalanceMonitor(account.address);
+  const account = privateKeyToAccount3(walletKey);
+  const evmPublicClient = createPublicClient2({ chain: base2, transport: http2() });
+  const evmSigner = toClientEvmSigner(account, evmPublicClient);
+  const x402 = new x402Client();
+  registerExactEvmScheme(x402, { signer: evmSigner });
+  let solanaAddress;
+  if (solanaPrivateKeyBytes) {
+    const { registerExactSvmScheme } = await import("@x402/svm/exact/client");
+    const { createKeyPairSignerFromPrivateKeyBytes } = await import("@solana/kit");
+    const solanaSigner = await createKeyPairSignerFromPrivateKeyBytes(solanaPrivateKeyBytes);
+    solanaAddress = solanaSigner.address;
+    registerExactSvmScheme(x402, { signer: solanaSigner });
+    console.log(`[ClawRouter] Solana x402 scheme registered: ${solanaAddress}`);
+  }
+  x402.onAfterPaymentCreation(async (context) => {
+    const network = context.selectedRequirements.network;
+    const chain = network.startsWith("eip155") ? "Base (EVM)" : network.startsWith("solana") ? "Solana" : network;
+    console.log(`[ClawRouter] Payment signed on ${chain} (${network})`);
+  });
+  const payFetch = createPayFetchWithPreAuth(fetch, x402, void 0, {
+    skipPreAuth: paymentChain === "solana"
+  });
+  const balanceMonitor = paymentChain === "solana" && solanaAddress ? new SolanaBalanceMonitor(solanaAddress) : new BalanceMonitor(account.address);
   const routingConfig = mergeRoutingConfig(options.routingConfig);
   const modelPricing = buildModelPricing();
   const routerOpts = {
@@ -5014,8 +5221,12 @@ async function startProxy(options) {
       const full = url.searchParams.get("full") === "true";
       const response = {
         status: "ok",
-        wallet: account.address
+        wallet: account.address,
+        paymentChain
       };
+      if (solanaAddress) {
+        response.solana = solanaAddress;
+      }
       if (full) {
         try {
           const balanceInfo = await balanceMonitor.checkBalance();
@@ -5127,10 +5338,10 @@ async function startProxy(options) {
       const onError = async (err) => {
         server.removeListener("error", onError);
         if (err.code === "EADDRINUSE") {
-          const existingWallet2 = await checkExistingProxy(listenPort);
-          if (existingWallet2) {
+          const existingProxy2 = await checkExistingProxy(listenPort);
+          if (existingProxy2) {
             console.log(`[ClawRouter] Existing proxy detected on port ${listenPort}, reusing`);
-            rejectAttempt({ code: "REUSE_EXISTING", wallet: existingWallet2 });
+            rejectAttempt({ code: "REUSE_EXISTING", wallet: existingProxy2.wallet, existingChain: existingProxy2.paymentChain });
             return;
           }
           if (attempt < PORT_RETRY_ATTEMPTS) {
@@ -5163,6 +5374,11 @@ async function startProxy(options) {
     } catch (err) {
       const error = err;
       if (error.code === "REUSE_EXISTING" && error.wallet) {
+        if (error.existingChain && error.existingChain !== paymentChain) {
+          throw new Error(
+            `Existing proxy on port ${listenPort} is using ${error.existingChain} but ${paymentChain} was requested. Stop the existing proxy first or use a different port.`
+          );
+        }
         const baseUrl2 = `http://127.0.0.1:${listenPort}`;
         options.onReady?.(listenPort);
         return {
@@ -5220,6 +5436,7 @@ async function startProxy(options) {
     port,
     baseUrl,
     walletAddress: account.address,
+    solanaAddress,
     balanceMonitor,
     close: () => new Promise((res, rej) => {
       const timeout = setTimeout(() => {
@@ -5266,8 +5483,6 @@ async function tryModelRequest(upstreamUrl, method, headers, body, modelId, maxT
     requestBody = Buffer.from(JSON.stringify(parsed));
   } catch {
   }
-  const estimated = estimateAmount(modelId, requestBody.length, maxTokens);
-  const preAuth = estimated ? { estimatedAmount: estimated } : void 0;
   try {
     const response = await payFetch(
       upstreamUrl,
@@ -5276,8 +5491,7 @@ async function tryModelRequest(upstreamUrl, method, headers, body, modelId, maxT
         headers,
         body: requestBody.length > 0 ? new Uint8Array(requestBody) : void 0,
         signal
-      },
-      preAuth
+      }
     );
     if (response.status !== 200) {
       const errorBody = await response.text();
@@ -5913,6 +6127,7 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
   }
   deduplicator.markInflight(dedupKey);
   let estimatedCostMicros;
+  let balanceFallbackNotice;
   const isFreeModel = modelId === FREE_MODEL;
   if (modelId && !options.skipBalanceCheck && !isFreeModel) {
     const estimated = estimateAmount(modelId, body.length, maxTokens);
@@ -5923,12 +6138,17 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
       if (sufficiency.info.isEmpty || !sufficiency.sufficient) {
         const originalModel = modelId;
         console.log(
-          `[ClawRouter] Wallet ${sufficiency.info.isEmpty ? "empty" : "insufficient"} ($${sufficiency.info.balanceUSD}), falling back to free model: ${FREE_MODEL} (requested: ${originalModel})`
+          `[ClawRouter] Wallet ${sufficiency.info.isEmpty ? "empty" : "insufficient"} (${sufficiency.info.balanceUSD}), falling back to free model: ${FREE_MODEL} (requested: ${originalModel})`
         );
         modelId = FREE_MODEL;
         const parsed = JSON.parse(body.toString());
         parsed.model = FREE_MODEL;
         body = Buffer.from(JSON.stringify(parsed));
+        balanceFallbackNotice = sufficiency.info.isEmpty ? `> **\u26A0\uFE0F Wallet empty** \u2014 using free model. Fund your wallet to use ${originalModel}.
+
+` : `> **\u26A0\uFE0F Insufficient balance** (${sufficiency.info.balanceUSD}) \u2014 using free model instead of ${originalModel}.
+
+`;
         options.onLowBalance?.({
           balanceUSD: sufficiency.info.balanceUSD,
           walletAddress: sufficiency.info.walletAddress
@@ -6220,6 +6440,18 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
 `;
               safeWrite(res, roleData);
               responseChunks.push(Buffer.from(roleData));
+              if (balanceFallbackNotice) {
+                const noticeChunk = {
+                  ...baseChunk,
+                  choices: [{ index, delta: { content: balanceFallbackNotice }, logprobs: null, finish_reason: null }]
+                };
+                const noticeData = `data: ${JSON.stringify(noticeChunk)}
+
+`;
+                safeWrite(res, noticeData);
+                responseChunks.push(Buffer.from(noticeData));
+                balanceFallbackNotice = void 0;
+              }
               if (content) {
                 const contentChunk = {
                   ...baseChunk,
@@ -6304,23 +6536,36 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
           responseHeaders["x-clawrouter-agentic-score"] = routingDecision.agenticScore.toFixed(2);
         }
       }
-      res.writeHead(upstream.status, responseHeaders);
+      const bodyParts = [];
       if (upstream.body) {
         const reader = upstream.body.getReader();
         try {
           while (true) {
             const { done, value } = await reader.read();
             if (done) break;
-            const chunk = Buffer.from(value);
-            safeWrite(res, chunk);
-            responseChunks.push(chunk);
+            bodyParts.push(Buffer.from(value));
           }
         } finally {
           reader.releaseLock();
         }
       }
+      let responseBody = Buffer.concat(bodyParts);
+      if (balanceFallbackNotice && responseBody.length > 0) {
+        try {
+          const parsed = JSON.parse(responseBody.toString());
+          if (parsed.choices?.[0]?.message?.content !== void 0) {
+            parsed.choices[0].message.content = balanceFallbackNotice + parsed.choices[0].message.content;
+            responseBody = Buffer.from(JSON.stringify(parsed));
+          }
+        } catch {
+        }
+        balanceFallbackNotice = void 0;
+      }
+      responseHeaders["content-length"] = String(responseBody.length);
+      res.writeHead(upstream.status, responseHeaders);
+      safeWrite(res, responseBody);
+      responseChunks.push(responseBody);
       res.end();
-      const responseBody = Buffer.concat(responseChunks);
       deduplicator.complete(dedupKey, {
         status: upstream.status,
         headers: responseHeaders,
@@ -6372,7 +6617,7 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
     deduplicator.removeInflight(dedupKey);
     balanceMonitor.invalidate();
     if (err instanceof Error && err.name === "AbortError") {
-      throw new Error(`Request timed out after ${timeoutMs}ms`);
+      throw new Error(`Request timed out after ${timeoutMs}ms`, { cause: err });
     }
     throw err;
   }
@@ -6403,102 +6648,17 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
   }
 }
 
-// src/auth.ts
-import { writeFile, mkdir as mkdir2 } from "fs/promises";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
-import { generatePrivateKey, privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
-var WALLET_DIR = join4(homedir3(), ".openclaw", "blockrun");
-var WALLET_FILE = join4(WALLET_DIR, "wallet.key");
-async function loadSavedWallet() {
-  try {
-    const key = (await readTextFile(WALLET_FILE)).trim();
-    if (key.startsWith("0x") && key.length === 66) {
-      console.log(`[ClawRouter] \u2713 Loaded existing wallet from ${WALLET_FILE}`);
-      return key;
-    }
-    console.error(`[ClawRouter] \u2717 CRITICAL: Wallet file exists but has invalid format!`);
-    console.error(`[ClawRouter]   File: ${WALLET_FILE}`);
-    console.error(`[ClawRouter]   Expected: 0x followed by 64 hex characters (66 chars total)`);
-    console.error(
-      `[ClawRouter]   To fix: restore your backup key or set BLOCKRUN_WALLET_KEY env var`
-    );
-    throw new Error(
-      `Wallet file at ${WALLET_FILE} is corrupted or has wrong format. Refusing to auto-generate new wallet to protect existing funds. Restore your backup key or set BLOCKRUN_WALLET_KEY environment variable.`
-    );
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      if (err instanceof Error && err.message.includes("Refusing to auto-generate")) {
-        throw err;
-      }
-      console.error(
-        `[ClawRouter] \u2717 Failed to read wallet file: ${err instanceof Error ? err.message : String(err)}`
-      );
-      throw new Error(
-        `Cannot read wallet file at ${WALLET_FILE}: ${err instanceof Error ? err.message : String(err)}. Refusing to auto-generate new wallet to protect existing funds. Fix file permissions or set BLOCKRUN_WALLET_KEY environment variable.`
-      );
-    }
-  }
-  return void 0;
-}
-async function generateAndSaveWallet() {
-  const key = generatePrivateKey();
-  const account = privateKeyToAccount3(key);
-  await mkdir2(WALLET_DIR, { recursive: true });
-  await writeFile(WALLET_FILE, key + "\n", { mode: 384 });
-  try {
-    const verification = (await readTextFile(WALLET_FILE)).trim();
-    if (verification !== key) {
-      throw new Error("Wallet file verification failed - content mismatch");
-    }
-    console.log(`[ClawRouter] \u2713 Wallet saved and verified at ${WALLET_FILE}`);
-  } catch (err) {
-    throw new Error(
-      `Failed to verify wallet file after creation: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  console.log(`[ClawRouter]`);
-  console.log(`[ClawRouter] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
-  console.log(`[ClawRouter]   NEW WALLET GENERATED \u2014 BACK UP YOUR KEY NOW`);
-  console.log(`[ClawRouter] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
-  console.log(`[ClawRouter]   Address : ${account.address}`);
-  console.log(`[ClawRouter]   Key file: ${WALLET_FILE}`);
-  console.log(`[ClawRouter]`);
-  console.log(`[ClawRouter]   To back up, run in OpenClaw:`);
-  console.log(`[ClawRouter]     /wallet export`);
-  console.log(`[ClawRouter]`);
-  console.log(`[ClawRouter]   To restore on another machine:`);
-  console.log(`[ClawRouter]     export BLOCKRUN_WALLET_KEY=<your_key>`);
-  console.log(`[ClawRouter] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
-  console.log(`[ClawRouter]`);
-  return { key, address: account.address };
-}
-async function resolveOrGenerateWalletKey() {
-  const saved = await loadSavedWallet();
-  if (saved) {
-    const account = privateKeyToAccount3(saved);
-    return { key: saved, address: account.address, source: "saved" };
-  }
-  const envKey = process["env"].BLOCKRUN_WALLET_KEY;
-  if (typeof envKey === "string" && envKey.startsWith("0x") && envKey.length === 66) {
-    const account = privateKeyToAccount3(envKey);
-    return { key: envKey, address: account.address, source: "env" };
-  }
-  const { key, address } = await generateAndSaveWallet();
-  return { key, address, source: "generated" };
-}
-
 // src/index.ts
 import {
-  writeFileSync,
-  existsSync,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync2,
   readdirSync,
-  mkdirSync,
+  mkdirSync as mkdirSync2,
   copyFileSync,
   renameSync
 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
 import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
 
 // src/partners/registry.ts
@@ -6596,6 +6756,260 @@ function buildPartnerTools(proxyBaseUrl) {
   return PARTNER_SERVICES.map((service) => buildTool(service, proxyBaseUrl));
 }
 
+// src/index.ts
+init_solana_balance();
+
+// src/spend-control.ts
+import * as fs from "fs";
+import * as path from "path";
+import { homedir as homedir4 } from "os";
+var WALLET_DIR2 = path.join(homedir4(), ".openclaw", "blockrun");
+var HOUR_MS = 60 * 60 * 1e3;
+var DAY_MS = 24 * HOUR_MS;
+var FileSpendControlStorage = class {
+  spendingFile;
+  constructor() {
+    this.spendingFile = path.join(WALLET_DIR2, "spending.json");
+  }
+  load() {
+    try {
+      if (fs.existsSync(this.spendingFile)) {
+        const data = JSON.parse(readTextFileSync(this.spendingFile));
+        const rawLimits = data.limits ?? {};
+        const rawHistory = data.history ?? [];
+        const limits = {};
+        for (const key of ["perRequest", "hourly", "daily", "session"]) {
+          const val = rawLimits[key];
+          if (typeof val === "number" && val > 0 && Number.isFinite(val)) {
+            limits[key] = val;
+          }
+        }
+        const history = [];
+        if (Array.isArray(rawHistory)) {
+          for (const r of rawHistory) {
+            if (typeof r?.timestamp === "number" && typeof r?.amount === "number" && Number.isFinite(r.timestamp) && Number.isFinite(r.amount) && r.amount >= 0) {
+              history.push({
+                timestamp: r.timestamp,
+                amount: r.amount,
+                model: typeof r.model === "string" ? r.model : void 0,
+                action: typeof r.action === "string" ? r.action : void 0
+              });
+            }
+          }
+        }
+        return { limits, history };
+      }
+    } catch (err) {
+      console.error(`[ClawRouter] Failed to load spending data, starting fresh: ${err}`);
+    }
+    return null;
+  }
+  save(data) {
+    try {
+      if (!fs.existsSync(WALLET_DIR2)) {
+        fs.mkdirSync(WALLET_DIR2, { recursive: true, mode: 448 });
+      }
+      fs.writeFileSync(this.spendingFile, JSON.stringify(data, null, 2), {
+        mode: 384
+      });
+    } catch (err) {
+      console.error(`[ClawRouter] Failed to save spending data: ${err}`);
+    }
+  }
+};
+var InMemorySpendControlStorage = class {
+  data = null;
+  load() {
+    return this.data ? {
+      limits: { ...this.data.limits },
+      history: this.data.history.map((r) => ({ ...r }))
+    } : null;
+  }
+  save(data) {
+    this.data = {
+      limits: { ...data.limits },
+      history: data.history.map((r) => ({ ...r }))
+    };
+  }
+};
+var SpendControl = class {
+  limits = {};
+  history = [];
+  sessionSpent = 0;
+  sessionCalls = 0;
+  storage;
+  now;
+  constructor(options) {
+    this.storage = options?.storage ?? new FileSpendControlStorage();
+    this.now = options?.now ?? (() => Date.now());
+    this.load();
+  }
+  setLimit(window, amount) {
+    if (!Number.isFinite(amount) || amount <= 0) {
+      throw new Error("Limit must be a finite positive number");
+    }
+    this.limits[window] = amount;
+    this.save();
+  }
+  clearLimit(window) {
+    delete this.limits[window];
+    this.save();
+  }
+  getLimits() {
+    return { ...this.limits };
+  }
+  check(estimatedCost) {
+    const now = this.now();
+    if (this.limits.perRequest !== void 0) {
+      if (estimatedCost > this.limits.perRequest) {
+        return {
+          allowed: false,
+          blockedBy: "perRequest",
+          remaining: this.limits.perRequest,
+          reason: `Per-request limit exceeded: $${estimatedCost.toFixed(4)} > $${this.limits.perRequest.toFixed(2)} max`
+        };
+      }
+    }
+    if (this.limits.hourly !== void 0) {
+      const hourlySpent = this.getSpendingInWindow(now - HOUR_MS, now);
+      const remaining = this.limits.hourly - hourlySpent;
+      if (estimatedCost > remaining) {
+        const oldestInWindow = this.history.find((r) => r.timestamp >= now - HOUR_MS);
+        const resetIn = oldestInWindow ? Math.ceil((oldestInWindow.timestamp + HOUR_MS - now) / 1e3) : 0;
+        return {
+          allowed: false,
+          blockedBy: "hourly",
+          remaining,
+          reason: `Hourly limit exceeded: $${(hourlySpent + estimatedCost).toFixed(2)} > $${this.limits.hourly.toFixed(2)} max`,
+          resetIn
+        };
+      }
+    }
+    if (this.limits.daily !== void 0) {
+      const dailySpent = this.getSpendingInWindow(now - DAY_MS, now);
+      const remaining = this.limits.daily - dailySpent;
+      if (estimatedCost > remaining) {
+        const oldestInWindow = this.history.find((r) => r.timestamp >= now - DAY_MS);
+        const resetIn = oldestInWindow ? Math.ceil((oldestInWindow.timestamp + DAY_MS - now) / 1e3) : 0;
+        return {
+          allowed: false,
+          blockedBy: "daily",
+          remaining,
+          reason: `Daily limit exceeded: $${(dailySpent + estimatedCost).toFixed(2)} > $${this.limits.daily.toFixed(2)} max`,
+          resetIn
+        };
+      }
+    }
+    if (this.limits.session !== void 0) {
+      const remaining = this.limits.session - this.sessionSpent;
+      if (estimatedCost > remaining) {
+        return {
+          allowed: false,
+          blockedBy: "session",
+          remaining,
+          reason: `Session limit exceeded: $${(this.sessionSpent + estimatedCost).toFixed(2)} > $${this.limits.session.toFixed(2)} max`
+        };
+      }
+    }
+    return { allowed: true };
+  }
+  record(amount, metadata) {
+    if (!Number.isFinite(amount) || amount < 0) {
+      throw new Error("Record amount must be a non-negative finite number");
+    }
+    const record = {
+      timestamp: this.now(),
+      amount,
+      model: metadata?.model,
+      action: metadata?.action
+    };
+    this.history.push(record);
+    this.sessionSpent += amount;
+    this.sessionCalls += 1;
+    this.cleanup();
+    this.save();
+  }
+  getSpendingInWindow(from, to) {
+    return this.history.filter((r) => r.timestamp >= from && r.timestamp <= to).reduce((sum, r) => sum + r.amount, 0);
+  }
+  getSpending(window) {
+    const now = this.now();
+    switch (window) {
+      case "hourly":
+        return this.getSpendingInWindow(now - HOUR_MS, now);
+      case "daily":
+        return this.getSpendingInWindow(now - DAY_MS, now);
+      case "session":
+        return this.sessionSpent;
+    }
+  }
+  getRemaining(window) {
+    const limit = this.limits[window];
+    if (limit === void 0) return null;
+    return Math.max(0, limit - this.getSpending(window));
+  }
+  getStatus() {
+    const now = this.now();
+    const hourlySpent = this.getSpendingInWindow(now - HOUR_MS, now);
+    const dailySpent = this.getSpendingInWindow(now - DAY_MS, now);
+    return {
+      limits: { ...this.limits },
+      spending: {
+        hourly: hourlySpent,
+        daily: dailySpent,
+        session: this.sessionSpent
+      },
+      remaining: {
+        hourly: this.limits.hourly !== void 0 ? this.limits.hourly - hourlySpent : null,
+        daily: this.limits.daily !== void 0 ? this.limits.daily - dailySpent : null,
+        session: this.limits.session !== void 0 ? this.limits.session - this.sessionSpent : null
+      },
+      calls: this.sessionCalls
+    };
+  }
+  getHistory(limit) {
+    const records = [...this.history].reverse();
+    return limit ? records.slice(0, limit) : records;
+  }
+  resetSession() {
+    this.sessionSpent = 0;
+    this.sessionCalls = 0;
+  }
+  cleanup() {
+    const cutoff = this.now() - DAY_MS;
+    this.history = this.history.filter((r) => r.timestamp >= cutoff);
+  }
+  save() {
+    this.storage.save({
+      limits: { ...this.limits },
+      history: [...this.history]
+    });
+  }
+  load() {
+    const data = this.storage.load();
+    if (data) {
+      this.limits = data.limits;
+      this.history = data.history;
+      this.cleanup();
+    }
+  }
+};
+function formatDuration(seconds) {
+  if (seconds < 60) {
+    return `${seconds}s`;
+  } else if (seconds < 3600) {
+    const mins = Math.ceil(seconds / 60);
+    return `${mins} min`;
+  } else {
+    const hours = Math.floor(seconds / 3600);
+    const mins = Math.ceil(seconds % 3600 / 60);
+    return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+  }
+}
+
+// src/index.ts
+init_wallet();
+
 // src/retry.ts
 var DEFAULT_RETRY_CONFIG = {
   maxRetries: 2,
@@ -6674,13 +7088,13 @@ function isGatewayMode() {
   return args.includes("gateway");
 }
 function injectModelsConfig(logger) {
-  const configDir = join5(homedir4(), ".openclaw");
-  const configPath = join5(configDir, "openclaw.json");
+  const configDir = join6(homedir5(), ".openclaw");
+  const configPath = join6(configDir, "openclaw.json");
   let config = {};
   let needsWrite = false;
-  if (!existsSync(configDir)) {
+  if (!existsSync2(configDir)) {
     try {
-      mkdirSync(configDir, { recursive: true });
+      mkdirSync2(configDir, { recursive: true });
       logger.info("Created OpenClaw config directory");
     } catch (err) {
       logger.info(
@@ -6689,7 +7103,7 @@ function injectModelsConfig(logger) {
       return;
     }
   }
-  if (existsSync(configPath)) {
+  if (existsSync2(configPath)) {
     try {
       const content = readTextFileSync(configPath).trim();
       if (content) {
@@ -6834,7 +7248,7 @@ function injectModelsConfig(logger) {
   if (needsWrite) {
     try {
       const tmpPath = `${configPath}.tmp.${process.pid}`;
-      writeFileSync(tmpPath, JSON.stringify(config, null, 2));
+      writeFileSync2(tmpPath, JSON.stringify(config, null, 2));
       renameSync(tmpPath, configPath);
       logger.info("Smart routing enabled (blockrun/auto)");
     } catch (err) {
@@ -6843,10 +7257,10 @@ function injectModelsConfig(logger) {
   }
 }
 function injectAuthProfile(logger) {
-  const agentsDir = join5(homedir4(), ".openclaw", "agents");
-  if (!existsSync(agentsDir)) {
+  const agentsDir = join6(homedir5(), ".openclaw", "agents");
+  if (!existsSync2(agentsDir)) {
     try {
-      mkdirSync(agentsDir, { recursive: true });
+      mkdirSync2(agentsDir, { recursive: true });
     } catch (err) {
       logger.info(
         `Could not create agents dir: ${err instanceof Error ? err.message : String(err)}`
@@ -6860,11 +7274,11 @@ function injectAuthProfile(logger) {
       agents = ["main", ...agents];
     }
     for (const agentId of agents) {
-      const authDir = join5(agentsDir, agentId, "agent");
-      const authPath = join5(authDir, "auth-profiles.json");
-      if (!existsSync(authDir)) {
+      const authDir = join6(agentsDir, agentId, "agent");
+      const authPath = join6(authDir, "auth-profiles.json");
+      if (!existsSync2(authDir)) {
         try {
-          mkdirSync(authDir, { recursive: true });
+          mkdirSync2(authDir, { recursive: true });
         } catch {
           continue;
         }
@@ -6873,7 +7287,7 @@ function injectAuthProfile(logger) {
         version: 1,
         profiles: {}
       };
-      if (existsSync(authPath)) {
+      if (existsSync2(authPath)) {
         try {
           const existing = JSON.parse(readTextFileSync(authPath));
           if (existing.version && existing.profiles) {
@@ -6892,7 +7306,7 @@ function injectAuthProfile(logger) {
         key: "x402-proxy-handles-auth"
       };
       try {
-        writeFileSync(authPath, JSON.stringify(store, null, 2));
+        writeFileSync2(authPath, JSON.stringify(store, null, 2));
         logger.info(`Injected BlockRun auth profile for agent: ${agentId}`);
       } catch (err) {
         logger.info(
@@ -6906,22 +7320,22 @@ function injectAuthProfile(logger) {
 }
 var activeProxyHandle = null;
 async function startProxyInBackground(api) {
-  const { key: walletKey, address, source } = await resolveOrGenerateWalletKey();
-  if (source === "generated") {
+  const wallet = await resolveOrGenerateWalletKey();
+  if (wallet.source === "generated") {
     api.logger.warn(`\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
     api.logger.warn(`  NEW WALLET GENERATED \u2014 BACK UP YOUR KEY NOW!`);
-    api.logger.warn(`  Address : ${address}`);
+    api.logger.warn(`  Address : ${wallet.address}`);
     api.logger.warn(`  Run /wallet export to get your private key`);
     api.logger.warn(`  Losing this key = losing your USDC funds`);
     api.logger.warn(`\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
-  } else if (source === "saved") {
-    api.logger.info(`Using saved wallet: ${address}`);
+  } else if (wallet.source === "saved") {
+    api.logger.info(`Using saved wallet: ${wallet.address}`);
   } else {
-    api.logger.info(`Using wallet from BLOCKRUN_WALLET_KEY: ${address}`);
+    api.logger.info(`Using wallet from BLOCKRUN_WALLET_KEY: ${wallet.address}`);
   }
   const routingConfig = api.pluginConfig?.routing;
   const proxy = await startProxy({
-    walletKey,
+    wallet,
     routingConfig,
     onReady: (port) => {
       api.logger.info(`BlockRun x402 proxy listening on port ${port}`);
@@ -6949,18 +7363,18 @@ async function startProxyInBackground(api) {
   activeProxyHandle = proxy;
   api.logger.info(`ClawRouter ready \u2014 smart routing enabled`);
   api.logger.info(`Pricing: Simple ~$0.001 | Code ~$0.01 | Complex ~$0.05 | Free: $0`);
-  const startupMonitor = new BalanceMonitor(address);
-  startupMonitor.checkBalance().then((balance) => {
+  const displayAddress = proxy.solanaAddress ?? wallet.address;
+  proxy.balanceMonitor.checkBalance().then((balance) => {
     if (balance.isEmpty) {
-      api.logger.info(`Wallet: ${address} | Balance: $0.00`);
+      api.logger.info(`Wallet: ${displayAddress} | Balance: $0.00`);
       api.logger.info(`Using FREE model. Fund wallet for premium models.`);
     } else if (balance.isLow) {
-      api.logger.info(`Wallet: ${address} | Balance: ${balance.balanceUSD} (low)`);
+      api.logger.info(`Wallet: ${displayAddress} | Balance: ${balance.balanceUSD} (low)`);
     } else {
-      api.logger.info(`Wallet: ${address} | Balance: ${balance.balanceUSD}`);
+      api.logger.info(`Wallet: ${displayAddress} | Balance: ${balance.balanceUSD}`);
     }
   }).catch(() => {
-    api.logger.info(`Wallet: ${address} | Balance: (checking...)`);
+    api.logger.info(`Wallet: ${displayAddress} | Balance: (checking...)`);
   });
 }
 async function createStatsCommand() {
@@ -6998,7 +7412,7 @@ async function createWalletCommand() {
       let walletKey;
       let address;
       try {
-        if (existsSync(WALLET_FILE)) {
+        if (existsSync2(WALLET_FILE)) {
           walletKey = readTextFileSync(WALLET_FILE).trim();
           if (walletKey.startsWith("0x") && walletKey.length === 66) {
             const account = privateKeyToAccount4(walletKey);
@@ -7016,48 +7430,176 @@ Run \`openclaw plugins install @blockrun/clawrouter\` to generate a wallet.`,
         };
       }
       if (subcommand === "export") {
-        return {
-          text: [
-            "\u{1F510} **ClawRouter Wallet Export**",
-            "",
-            "\u26A0\uFE0F **SECURITY WARNING**: Your private key controls your wallet funds.",
-            "Never share this key. Anyone with this key can spend your USDC.",
-            "",
-            `**Address:** \`${address}\``,
-            "",
-            `**Private Key:**`,
-            `\`${walletKey}\``,
-            "",
-            "**To restore on a new machine:**",
-            "1. Set the environment variable before running OpenClaw:",
-            `   \`export BLOCKRUN_WALLET_KEY=${walletKey}\``,
-            "2. Or save to file:",
-            `   \`mkdir -p ~/.openclaw/blockrun && echo "${walletKey}" > ~/.openclaw/blockrun/wallet.key && chmod 600 ~/.openclaw/blockrun/wallet.key\``
-          ].join("\n")
-        };
+        const lines = [
+          "**ClawRouter Wallet Export**",
+          "",
+          "**SECURITY WARNING**: Your private key and mnemonic control your wallet funds.",
+          "Never share these. Anyone with them can spend your USDC.",
+          "",
+          "**EVM (Base):**",
+          `  Address: \`${address}\``,
+          `  Private Key: \`${walletKey}\``
+        ];
+        let hasMnemonic = false;
+        try {
+          if (existsSync2(MNEMONIC_FILE)) {
+            const mnemonic = readTextFileSync(MNEMONIC_FILE).trim();
+            if (mnemonic) {
+              hasMnemonic = true;
+              const { deriveSolanaKeyBytes: deriveSolanaKeyBytes2 } = await Promise.resolve().then(() => (init_wallet(), wallet_exports));
+              const solKeyBytes = deriveSolanaKeyBytes2(mnemonic);
+              const { createKeyPairSignerFromPrivateKeyBytes } = await import("@solana/kit");
+              const signer = await createKeyPairSignerFromPrivateKeyBytes(solKeyBytes);
+              lines.push(
+                "",
+                "**Solana:**",
+                `  Address: \`${signer.address}\``,
+                `  (Derived from mnemonic below)`,
+                "",
+                "**Mnemonic (24 words):**",
+                `\`${mnemonic}\``,
+                "",
+                "CRITICAL: Back up this mnemonic. It is the ONLY way to recover your Solana wallet."
+              );
+            }
+          }
+        } catch {
+        }
+        lines.push(
+          "",
+          "**To restore on a new machine:**",
+          "1. Set the environment variable before running OpenClaw:",
+          `   \`export BLOCKRUN_WALLET_KEY=${walletKey}\``,
+          "2. Or save to file:",
+          `   \`mkdir -p ~/.openclaw/blockrun && echo "${walletKey}" > ~/.openclaw/blockrun/wallet.key && chmod 600 ~/.openclaw/blockrun/wallet.key\``
+        );
+        if (hasMnemonic) {
+          lines.push(
+            "3. Restore the mnemonic for Solana:",
+            `   \`echo "<your mnemonic>" > ~/.openclaw/blockrun/mnemonic && chmod 600 ~/.openclaw/blockrun/mnemonic\``
+          );
+        }
+        return { text: lines.join("\n") };
+      }
+      if (subcommand === "solana") {
+        try {
+          let solanaAddr;
+          if (existsSync2(MNEMONIC_FILE)) {
+            const existingMnemonic = readTextFileSync(MNEMONIC_FILE).trim();
+            if (existingMnemonic) {
+              await savePaymentChain("solana");
+              const { deriveSolanaKeyBytes: deriveSolanaKeyBytes2 } = await Promise.resolve().then(() => (init_wallet(), wallet_exports));
+              const solKeyBytes = deriveSolanaKeyBytes2(existingMnemonic);
+              const { createKeyPairSignerFromPrivateKeyBytes: createKeyPairSignerFromPrivateKeyBytes2 } = await import("@solana/kit");
+              const signer2 = await createKeyPairSignerFromPrivateKeyBytes2(solKeyBytes);
+              solanaAddr = signer2.address;
+              return {
+                text: [
+                  "Payment chain set to Solana. Restart the gateway to apply.",
+                  "",
+                  `**Solana Address:** \`${solanaAddr}\``,
+                  `**Fund with USDC on Solana:** https://solscan.io/account/${solanaAddr}`
+                ].join("\n")
+              };
+            }
+          }
+          const { solanaPrivateKeyBytes } = await setupSolana();
+          await savePaymentChain("solana");
+          const { createKeyPairSignerFromPrivateKeyBytes } = await import("@solana/kit");
+          const signer = await createKeyPairSignerFromPrivateKeyBytes(solanaPrivateKeyBytes);
+          return {
+            text: [
+              "**Solana Wallet Set Up**",
+              "",
+              `**Solana Address:** \`${signer.address}\``,
+              `**Mnemonic File:** \`${MNEMONIC_FILE}\``,
+              "",
+              "Your existing EVM wallet is unchanged.",
+              "Payment chain set to Solana. Restart the gateway to apply.",
+              "",
+              `**Fund with USDC on Solana:** https://solscan.io/account/${signer.address}`
+            ].join("\n")
+          };
+        } catch (err) {
+          return {
+            text: `Failed to set up Solana: ${err instanceof Error ? err.message : String(err)}`,
+            isError: true
+          };
+        }
       }
-      let balanceText = "Balance: (checking...)";
+      if (subcommand === "base") {
+        try {
+          await savePaymentChain("base");
+          return {
+            text: "Payment chain set to Base (EVM). Restart the gateway to apply."
+          };
+        } catch (err) {
+          return {
+            text: `Failed to set payment chain: ${err instanceof Error ? err.message : String(err)}`,
+            isError: true
+          };
+        }
+      }
+      let evmBalanceText = "Balance: (checking...)";
       try {
         const monitor = new BalanceMonitor(address);
         const balance = await monitor.checkBalance();
-        balanceText = `Balance: ${balance.balanceUSD}`;
+        evmBalanceText = `Balance: ${balance.balanceUSD}`;
+      } catch {
+        evmBalanceText = "Balance: (could not check)";
+      }
+      let solanaSection = "";
+      try {
+        if (existsSync2(MNEMONIC_FILE)) {
+          const { deriveSolanaKeyBytes: deriveSolanaKeyBytes2 } = await Promise.resolve().then(() => (init_wallet(), wallet_exports));
+          const mnemonic = readTextFileSync(MNEMONIC_FILE).trim();
+          if (mnemonic) {
+            const solKeyBytes = deriveSolanaKeyBytes2(mnemonic);
+            const { createKeyPairSignerFromPrivateKeyBytes } = await import("@solana/kit");
+            const signer = await createKeyPairSignerFromPrivateKeyBytes(solKeyBytes);
+            const solAddr = signer.address;
+            let solBalanceText = "Balance: (checking...)";
+            try {
+              const { SolanaBalanceMonitor: SolanaBalanceMonitor2 } = await Promise.resolve().then(() => (init_solana_balance(), solana_balance_exports));
+              const solMonitor = new SolanaBalanceMonitor2(solAddr);
+              const solBalance = await solMonitor.checkBalance();
+              solBalanceText = `Balance: ${solBalance.balanceUSD}`;
+            } catch {
+              solBalanceText = "Balance: (could not check)";
+            }
+            solanaSection = [
+              "",
+              "**Solana:**",
+              `  Address: \`${solAddr}\``,
+              `  ${solBalanceText}`,
+              `  Fund: https://solscan.io/account/${solAddr}`
+            ].join("\n");
+          }
+        }
       } catch {
-        balanceText = "Balance: (could not check)";
       }
+      const currentChain = await resolvePaymentChain();
       return {
         text: [
-          "\u{1F99E} **ClawRouter Wallet**",
+          "**ClawRouter Wallet**",
+          "",
+          `**Payment Chain:** ${currentChain === "solana" ? "Solana" : "Base (EVM)"}`,
+          "",
+          "**Base (EVM):**",
+          `  Address: \`${address}\``,
+          `  ${evmBalanceText}`,
+          `  Fund: https://basescan.org/address/${address}`,
+          solanaSection,
           "",
-          `**Address:** \`${address}\``,
-          `**${balanceText}**`,
           `**Key File:** \`${WALLET_FILE}\``,
           "",
           "**Commands:**",
           "\u2022 `/wallet` - Show this status",
           "\u2022 `/wallet export` - Export private key for backup",
-          "",
-          `**Fund with USDC on Base:** https://basescan.org/address/${address}`
-        ].join("\n")
+          !solanaSection ? "\u2022 `/wallet solana` - Enable Solana payments" : "",
+          solanaSection ? "\u2022 `/wallet base` - Switch to Base (EVM)" : "",
+          solanaSection ? "\u2022 `/wallet solana` - Switch to Solana" : ""
+        ].filter(Boolean).join("\n")
       };
     }
   };
@@ -7212,23 +7754,30 @@ export {
   DEFAULT_ROUTING_CONFIG,
   DEFAULT_SESSION_CONFIG,
   EmptyWalletError,
+  FileSpendControlStorage,
+  InMemorySpendControlStorage,
   InsufficientFundsError,
   MODEL_ALIASES,
   OPENCLAW_MODELS,
   PARTNER_SERVICES,
-  PaymentCache,
   RequestDeduplicator,
   ResponseCache,
   RpcError,
   SessionStore,
+  SolanaBalanceMonitor,
+  SpendControl,
   blockrunProvider,
   buildPartnerTools,
   buildProviderModels,
   calculateModelCost,
-  createPaymentFetch,
   index_default as default,
+  deriveAllKeys,
+  deriveEvmKey,
+  deriveSolanaKeyBytes,
   fetchWithRetry,
+  formatDuration,
   formatStatsAscii,
+  generateWalletMnemonic,
   getAgenticModels,
   getFallbackChain,
   getFallbackChainFiltered,
@@ -7244,9 +7793,14 @@ export {
   isInsufficientFundsError,
   isRetryable,
   isRpcError,
+  isValidMnemonic,
+  loadPaymentChain,
   logUsage,
   resolveModelAlias,
+  resolvePaymentChain,
   route,
+  savePaymentChain,
+  setupSolana,
   startProxy
 };
 //# sourceMappingURL=index.js.map