openzoo 0.9.1 → 0.9.3

package/lib/pay.js

@@ -3,7 +3,7 @@ import { getAssociatedTokenAddressSync } from '@solana/spl-token';
 import { config, fundingLine } from './config.js';
 import { loadOrCreateWallet } from './wallet.js';
 import {
-  parse402, pickAccept, railOf, buildPaymentOnline, tokenBalance,
+  parse402, orderAccepts, railOf, buildPaymentOnline, tokenBalance,
   receiptLine, decodeSettleHeader,
 } from './x402.js';
 import { buildEvmPayment, evmTokenBalance } from './evm.js';
@@ -180,15 +180,41 @@ export class PayClient {
 
     const quote = parse402(await first.json());
     // config.rail (OPENZOO_RAIL) steers every front — proxy, demo, MCP — since
-    // they all pay through this one call site.
-    const accept = pickAccept(quote, config.token, { allowRH: this.allowRH, forceRail: config.rail });
-    const billedUsd = Number(accept?.extra?.billedUsd ?? NaN);
-    if (Number.isFinite(billedUsd) && billedUsd > config.maxUsdPerCall) {
-      throw new QuoteTooHighError(billedUsd, quote);
-    }
-
+    // they all pay through this one call site. The wallet pays with whatever
+    // it HOLDS: every offered row is tried best-first, and only when NONE is
+    // affordable does the call fail — never because the first-choice asset
+    // alone ran dry while another funded one sat in the wallet.
+    const candidates = orderAccepts(quote, config.token, { allowRH: this.allowRH, forceRail: config.rail });
     onStage?.('quoted');
-    const payment = await this.buildPaymentFor(accept, onStage);
+    let accept = null;
+    let payment = null;
+    const fundErrs = [];
+    let tooHigh = null;
+    for (const cand of candidates) {
+      const billedUsd = Number(cand?.extra?.billedUsd ?? NaN);
+      if (Number.isFinite(billedUsd) && billedUsd > config.maxUsdPerCall) {
+        tooHigh = tooHigh || new QuoteTooHighError(billedUsd, quote);
+        continue;
+      }
+      try {
+        payment = await this.buildPaymentFor(cand, onStage);
+        accept = cand;
+        break;
+      } catch (e) {
+        const funding = e instanceof UnderfundedError
+          || e?.name === 'UnderlyingShortError' || e?.name === 'NeedsGasError';
+        if (!funding) throw e;
+        fundErrs.push({ sym: cand?.extra?.symbol || cand?.asset, err: e });
+      }
+    }
+    if (!payment) {
+      if (!fundErrs.length && tooHigh) throw tooHigh;
+      if (fundErrs.length === 1) throw fundErrs[0].err;
+      throw new UnderfundedError(candidates[0], null, this.address, {
+        line: `No offered payment row is affordable from this wallet (tried ${fundErrs.length}):\n`
+          + fundErrs.map(({ sym, err }) => `  · ${sym}: ${err.message.replace(/^openzoo wallet underfunded: /, '')}`).join('\n'),
+      });
+    }
     onStage?.('paying');
     const response = await fetch(url, {
       ...init,

package/lib/proxy.js

@@ -2,10 +2,11 @@ import http from 'node:http';
 import crypto from 'node:crypto';
 import { Readable } from 'node:stream';
 import {
-  config, FUNDING_ASSETS, fundingLine, liveRails, railFundingHint, railFundingAddresses, unfundableRails, RAIL_FUNDING,
+  config, FUNDING_ASSETS, EVM_FUNDING_ASSETS, evmRpcFor, fundingLine, liveRails, railFundingHint, railFundingAddresses, unfundableRails, RAIL_FUNDING,
 } from './config.js';
 import { PayClient, QuoteTooHighError, UnderfundedError } from './pay.js';
 import { tokenBalance } from './x402.js';
+import { evmTokenBalance } from './evm.js';
 import { bindCorpus, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import { maybeRewriteModel, rewritablePath, augmentModelList, ALIAS_IDS } from './models.js';
 import { forgetContext } from './contexts.js';
@@ -56,6 +57,42 @@ function jsonErr(res, status, message, extraFields = {}) {
 
 const mb = (n) => (n / 1048576).toFixed(1);
 
+/**
+ * Every fundable balance across all three chains, for the startup line and
+ * the live refresh. Each read is independent and advisory — one lagging RPC
+ * drops its entry rather than blanking the whole line.
+ */
+async function snapshotBalances(client) {
+  const out = [];
+  try {
+    const bals = await Promise.all(
+      FUNDING_ASSETS.map((a) => tokenBalance(client.connection, client.keypair.publicKey, a.mint)),
+    );
+    FUNDING_ASSETS.forEach((a, i) => out.push({ symbol: a.symbol, ui: Number(bals[i].ui ?? 0), chain: 'solana' }));
+  } catch { /* Solana RPC hiccup — EVM entries still report */ }
+  const owner = client.evmAddress;
+  if (owner) {
+    await Promise.all(Object.entries(EVM_FUNDING_ASSETS).flatMap(([rail, assets]) => assets.map(async (a) => {
+      try {
+        const raw = await evmTokenBalance({ rpcUrl: evmRpcFor(rail), token: a.address, owner });
+        out.push({ symbol: a.symbol, ui: Number(raw) / 10 ** a.decimals, chain: rail });
+      } catch { /* advisory */ }
+    })));
+  }
+  // Parallel reads land in racy order; sort so the printed line is stable
+  // and diffs against the previous snapshot read cleanly.
+  const rank = { solana: 0, base: 1, robinhood: 2 };
+  return out.sort((a, b) => (rank[a.chain] ?? 9) - (rank[b.chain] ?? 9) || a.symbol.localeCompare(b.symbol));
+}
+
+/** Solana entries always show; EVM entries only once they hold something. */
+function balanceLine(snap) {
+  return snap
+    .filter((b) => b.chain === 'solana' || b.ui > 0)
+    .map((b) => `${b.ui} ${b.symbol}${b.chain !== 'solana' ? ` (${b.chain})` : ''}`)
+    .join('  ·  ');
+}
+
 /**
  * The zoo answers chat completions as ONE JSON object (it settles payment
  * before serving — there is nothing to stream until generation is done).
@@ -175,6 +212,17 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   const log = silent ? () => {} : (...a) => console.log(...a);
   let sessionSpent = 0;
   let tunnelSpent = 0;
+  // Live balance refresh state — the real implementation is assigned in the
+  // banner section below; the handler only ever calls scheduleRefresh().
+  let lastSnap = null;
+  let refreshBalances = async () => {};
+  let refreshPending = false;
+  const scheduleRefresh = (ms) => {
+    if (silent || refreshPending) return;
+    refreshPending = true;
+    const t = setTimeout(async () => { refreshPending = false; await refreshBalances(); }, ms);
+    t.unref?.();
+  };
   // Set once cloudflared is up (see below). Gating keys off the REQUEST's
   // origin, not off whether the URL exists yet, so there is no startup window
   // where public traffic slips through ungated.
@@ -319,6 +367,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         if (requireToken) log(`${line}  ·  session $${sessionSpent.toFixed(6)}`);
         else if (viaTunnel) log(`${line}  ·  public-url session $${tunnelSpent.toFixed(6)}`);
         else log(line);
+        scheduleRefresh(4000); // settlement lands on-chain in a few seconds
       }
       // Chat completions come back as one JSON object (settle-before-serve).
       // Cache it against retries, and if the harness asked to stream, honour
@@ -366,15 +415,39 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     console.log(`wallet (fund me) · solana: ${client.address}`);
     if (client.evmAddress) console.log(`wallet (fund me) · evm (base / robinhood): ${client.evmAddress}`);
     try {
-      const bals = await Promise.all(
-        FUNDING_ASSETS.map((a) => tokenBalance(client.connection, client.keypair.publicKey, a.mint)),
-      );
-      const parts = FUNDING_ASSETS.map((a, i) => `${bals[i].ui ?? 0} ${a.symbol}`);
-      console.log(`balance: ${parts.join('  ·  ')}`);
-      if (!bals.some((b) => b.raw)) {
+      lastSnap = await snapshotBalances(client);
+      console.log(`balance: ${balanceLine(lastSnap) || '(no RPC reachable — advisory only)'}`);
+      if (!lastSnap.some((b) => b.ui > 0)) {
         console.log(`fund it: ${fundingLine('the address above')} — a few cents goes a long way.`);
       }
     } catch { /* RPC hiccup: balance is advisory */ }
+    // LIVE REFRESH: the startup line goes stale the moment a call settles or
+    // the user funds mid-session. Poll on an interval (and shortly after each
+    // paid call), print ONLY on change, and call out arrivals explicitly so
+    // "did my top-up land?" answers itself in the running log.
+    refreshBalances = async () => {
+      try {
+        const snap = await snapshotBalances(client);
+        if (!snap.length) return;
+        const prev = new Map((lastSnap || []).map((b) => [`${b.chain}:${b.symbol}`, b.ui]));
+        const changed = snap.some((b) => Math.abs((prev.get(`${b.chain}:${b.symbol}`) ?? 0) - b.ui) > 1e-9)
+          || snap.length !== (lastSnap || []).length;
+        if (!changed) return;
+        if (lastSnap) {
+          for (const b of snap) {
+            const gain = b.ui - (prev.get(`${b.chain}:${b.symbol}`) ?? 0);
+            if (gain > 1e-9) console.log(`funding arrived: +${gain.toFixed(6)} ${b.symbol}${b.chain !== 'solana' ? ` (${b.chain})` : ''}`);
+          }
+        }
+        lastSnap = snap;
+        console.log(`balance: ${balanceLine(snap)}`);
+      } catch { /* advisory — never noisy on RPC trouble */ }
+    };
+    const pollSecs = Number(process.env.OPENZOO_BALANCE_POLL_SECS ?? 45);
+    if (pollSecs > 0) {
+      const timer = setInterval(refreshBalances, pollSecs * 1000);
+      timer.unref?.();
+    }
     // Which rails the zoo will actually settle right now, straight off a live
     // 402 — so nobody funds a lane the resource is not currently offering.
     try {

package/lib/x402.js

@@ -74,8 +74,20 @@ export function evmChainId(network) {
  * but RH stays opt-in for DEFAULT selection because its settlement asset has
  * no auto-conversion path here.
  */
-export function pickAccept(body, preferredSymbol, { allowRH = false, forceRail = null } = {}) {
+/**
+ * ALL payable rows from a 402, best-first. The wallet pays with whatever it
+ * HOLDS — the caller walks this list and takes the first affordable row, so
+ * a wallet rich in TOKEN but short of USDC pays the TOKEN row instead of
+ * erroring on the USDC one. Preference order within the list: the preferred
+ * symbol, then the rest of Solana (sponsored fees), then Base, then Robinhood
+ * (gated — paying there costs the wallet its own gas).
+ */
+export function orderAccepts(body, preferredSymbol, { allowRH = false, forceRail = null } = {}) {
   const rows = parse402(body).accepts.filter((a) => a?.scheme === 'exact');
+  const bySym = (list) => [
+    ...list.filter((a) => a?.extra?.symbol === preferredSymbol),
+    ...list.filter((a) => a?.extra?.symbol !== preferredSymbol),
+  ];
   if (forceRail) {
     const want = String(forceRail).toLowerCase();
     if (!['solana', 'base', 'robinhood', 'evm'].includes(want)) {
@@ -88,19 +100,24 @@ export function pickAccept(body, preferredSymbol, { allowRH = false, forceRail =
         `OPENZOO_RAIL=${want} but the live 402 offers no ${want} rail (offered: ${offered.join(', ') || 'none'})`,
       );
     }
-    return match.find((a) => a?.extra?.symbol === preferredSymbol) || match[0];
+    return bySym(match);
+  }
+  const out = [
+    ...bySym(rows.filter((a) => railOf(a) === 'solana')),
+    ...rows.filter((a) => railOf(a) === 'base'),
+    ...rows.filter((a) => railOf(a) === 'evm'),
+    ...(allowRH ? rows.filter((a) => railOf(a) === 'robinhood') : []),
+  ];
+  if (!out.length) {
+    throw new Error(rows.some((a) => railOf(a) === 'robinhood')
+      ? 'only Robinhood Chain rails offered — set OPENZOO_ENABLE_RH=1 or OPENZOO_RAIL=robinhood to use them (the rail settles; you must hold its settlement asset, see https://x402.accrue.fund/start)'
+      : 'no payable rail in 402 accepts[]');
   }
-  const sol = rows.filter((a) => railOf(a) === 'solana');
-  if (sol.length) return sol.find((a) => a?.extra?.symbol === preferredSymbol) || sol[0];
-  const base = rows.filter((a) => railOf(a) === 'base');
-  if (base.length) return base[0];
-  const evm = rows.filter((a) => railOf(a) === 'evm');
-  if (evm.length) return evm[0];
-  const rh = rows.filter((a) => railOf(a) === 'robinhood');
-  if (allowRH && rh.length) return rh[0];
-  throw new Error(rh.length
-    ? 'only Robinhood Chain rails offered — set OPENZOO_ENABLE_RH=1 or OPENZOO_RAIL=robinhood to use them (the rail settles; you must hold its settlement asset, see https://x402.accrue.fund/start)'
-    : 'no payable rail in 402 accepts[]');
+  return out;
+}
+
+export function pickAccept(body, preferredSymbol, opts = {}) {
+  return orderAccepts(body, preferredSymbol, opts)[0];
 }
 
 const mintCache = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",