@blockrun/clawrouter 0.11.12 → 0.11.14

package/dist/cli.js

@@ -3,271 +3,72 @@
 // src/proxy.ts
 import { createServer } from "http";
 import { finished } from "stream";
-import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
-
-// src/x402.ts
-import { signTypedData, privateKeyToAccount } 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/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) {
@@ -1794,7 +1595,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";
@@ -3102,6 +2903,299 @@ var BalanceMonitor = class {
   }
 };
 
+// src/solana-balance.ts
+import { address as solAddress, createSolanaRpc } from "@solana/kit";
+var SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var SOLANA_DEFAULT_RPC = "https://api.mainnet-beta.solana.com";
+var BALANCE_TIMEOUT_MS = 1e4;
+var CACHE_TTL_MS2 = 3e4;
+var 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/auth.ts
+import { writeFile, mkdir as mkdir2 } from "fs/promises";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+
+// src/wallet.ts
+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";
+var ETH_DERIVATION_PATH = "m/44'/60'/0'/0/0";
+var SOLANA_DERIVATION_PATH = "m/44'/501'/0'/0'";
+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 };
+}
+
+// src/auth.ts
+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 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 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,
@@ -3131,7 +3225,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") {
@@ -3151,7 +3245,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();
@@ -4248,6 +4342,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",
@@ -4376,7 +4471,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;
@@ -4806,31 +4901,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 = {
@@ -4864,8 +5006,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();
@@ -4977,10 +5123,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) {
@@ -5013,6 +5159,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 {
@@ -5070,6 +5221,7 @@ async function startProxy(options) {
     port,
     baseUrl,
     walletAddress: account.address,
+    solanaAddress,
     balanceMonitor,
     close: () => new Promise((res, rej) => {
       const timeout = setTimeout(() => {
@@ -5116,8 +5268,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,
@@ -5126,8 +5276,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();
@@ -5763,6 +5912,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);
@@ -5773,12 +5923,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
@@ -6070,6 +6225,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,
@@ -6154,23 +6321,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,
@@ -6222,7 +6402,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;
   }
@@ -6253,91 +6433,6 @@ 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/report.ts
 async function generateReport(period, json = false) {
   const days = period === "daily" ? 1 : period === "weekly" ? 7 : 30;
@@ -6379,6 +6474,12 @@ function capitalize(str) {
 
 // src/doctor.ts
 import { platform, arch, freemem, totalmem } from "os";
+import { createPublicClient as createPublicClient3, http as http3 } from "viem";
+import { base as base3 } from "viem/chains";
+import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+import { wrapFetchWithPayment, x402Client as x402Client2 } from "@x402/fetch";
+import { registerExactEvmScheme as registerExactEvmScheme2 } from "@x402/evm/exact/client";
+import { toClientEvmSigner as toClientEvmSigner2 } from "@x402/evm";
 function formatBytes(bytes) {
   const gb = bytes / (1024 * 1024 * 1024);
   return `${gb.toFixed(1)}GB`;
@@ -6463,7 +6564,6 @@ async function collectNetworkInfo() {
     blockrunLatency = Date.now() - start;
     blockrunReachable = response.ok || response.status === 402;
   } catch {
-    blockrunReachable = false;
   }
   let proxyRunning = false;
   try {
@@ -6473,7 +6573,6 @@ async function collectNetworkInfo() {
     });
     proxyRunning = response.ok;
   } catch {
-    proxyRunning = false;
   }
   return {
     blockrunApi: { reachable: blockrunReachable, latencyMs: blockrunLatency },
@@ -6592,7 +6691,12 @@ async function analyzeWithAI(diagnostics, userQuestion, model = "sonnet") {
 `);
   try {
     const { key } = await resolveOrGenerateWalletKey();
-    const { fetch: paymentFetch } = createPaymentFetch(key);
+    const account = privateKeyToAccount4(key);
+    const publicClient = createPublicClient3({ chain: base3, transport: http3() });
+    const evmSigner = toClientEvmSigner2(account, publicClient);
+    const x402 = new x402Client2();
+    registerExactEvmScheme2(x402, { signer: evmSigner });
+    const paymentFetch = wrapFetchWithPayment(fetch, x402);
     const response = await paymentFetch(
       "https://blockrun.ai/api/v1/chat/completions",
       {
@@ -6627,8 +6731,7 @@ Please analyze and help me fix any issues.`
           ],
           max_tokens: 1e3
         })
-      },
-      void 0
+      }
     );
     if (!response.ok) {
       const text = await response.text();
@@ -6864,16 +6967,16 @@ ClawRouter Partner APIs (v${VERSION})
     console.log(report);
     process.exit(0);
   }
-  const { key: walletKey, address, source } = await resolveOrGenerateWalletKey();
-  if (source === "generated") {
-    console.log(`[ClawRouter] Generated new wallet: ${address}`);
-  } else if (source === "saved") {
-    console.log(`[ClawRouter] Using saved wallet: ${address}`);
+  const wallet = await resolveOrGenerateWalletKey();
+  if (wallet.source === "generated") {
+    console.log(`[ClawRouter] Generated new wallet: ${wallet.address}`);
+  } else if (wallet.source === "saved") {
+    console.log(`[ClawRouter] Using saved wallet: ${wallet.address}`);
   } else {
-    console.log(`[ClawRouter] Using wallet from BLOCKRUN_WALLET_KEY: ${address}`);
+    console.log(`[ClawRouter] Using wallet from BLOCKRUN_WALLET_KEY: ${wallet.address}`);
   }
   const proxy = await startProxy({
-    walletKey,
+    wallet,
     port: args.port,
     onReady: (port) => {
       console.log(`[ClawRouter] Proxy listening on http://127.0.0.1:${port}`);
@@ -6897,19 +7000,19 @@ ClawRouter Partner APIs (v${VERSION})
       console.error(`[ClawRouter] Need help? Run: npx @blockrun/clawrouter doctor`);
     }
   });
-  const monitor = new BalanceMonitor(address);
+  const monitor = new BalanceMonitor(wallet.address);
   try {
     const balance = await monitor.checkBalance();
     if (balance.isEmpty) {
       console.log(`[ClawRouter] Wallet balance: $0.00 (using FREE model)`);
-      console.log(`[ClawRouter] Fund wallet for premium models: ${address}`);
+      console.log(`[ClawRouter] Fund wallet for premium models: ${wallet.address}`);
     } else if (balance.isLow) {
       console.log(`[ClawRouter] Wallet balance: ${balance.balanceUSD} (low)`);
     } else {
       console.log(`[ClawRouter] Wallet balance: ${balance.balanceUSD}`);
     }
   } catch {
-    console.log(`[ClawRouter] Wallet: ${address} (balance check pending)`);
+    console.log(`[ClawRouter] Wallet: ${wallet.address} (balance check pending)`);
   }
   console.log(`[ClawRouter] Ready - Ctrl+C to stop`);
   const shutdown = async (signal) => {