openzoo 0.49.16 → 0.49.17

package/lib/pay.js

@@ -1,22 +1,23 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import { getAssociatedTokenAddressSync } from '@solana/spl-token';
-import { config, fundingLine, evmRpcFor, FUNDING_ASSETS } from './config.js';
+import { Connection } from '@solana/web3.js';
+import { config, fundingLine, evmRpcFor } from './config.js';
 import { loadOrCreateWallet } from './wallet.js';
 import {
   parse402, orderAccepts, railOf, buildPaymentOnline, tokenBalance,
-  receiptLine, decodeSettleHeader,
+  receiptLine, decodeSettleHeader, paymentEnvelope, encodeEnvelope, paymentHeaders,
 } from './x402.js';
 import { buildEvmPayment, evmTokenBalance } from './evm.js';
-import { acquireWrappedIfNeeded } from './evmwrap.js';
 import { privateKeyToAccount } from 'viem/accounts';
 import { withNamespace } from './namespace.js';
-import {
-  resolvePool, poolState, depositForShares, buildWrapInstructions, sendWrap,
-  rewriteWrapClientError,
-} from './wrap.js';
-import { applySubscriptionHeaders, loadSubscription, stripAuthorization } from './subscription.js';
 import { fetchHeaders } from './fetch.js';
 
+/** Drop any inherited bearer — see the call site: x402 is the only pay lane. */
+function stripAuthorization(headers = {}) {
+  const out = { ...headers };
+  delete out.authorization;
+  delete out.Authorization;
+  return out;
+}
+
 export class QuoteTooHighError extends Error {
   constructor(billedUsd, quote) {
     super(`openzoo: quote $${billedUsd} exceeds local cap $${config.maxUsdPerCall}. Raise OPENZOO_MAX_USD_PER_CALL to allow.`);
@@ -42,7 +43,8 @@ export class UnderfundedError extends Error {
 /**
  * Shared x402-paying HTTP client — the single place payment happens.
  * The proxy, the demo, and the MCP server all go through PayClient.fetch:
- * request → 402 → pick rail (Solana first) → sign → retry with X-PAYMENT.
+ * request → 402 → pick rail (Solana first) → sign → retry with the payment
+ * headers. x402 is the ONLY pay lane here; there is no bearer that skips it.
  */
 /**
  * Which offered asset last paid, and which are known underfunded — see the
@@ -52,11 +54,11 @@ export class UnderfundedError extends Error {
 /**
  * BALANCE CACHE — checked semi-frequently in the background, not per call.
  *
- * MEASURED: a per-request balance probe put a mainnet round trip (and, when the
- * row came back short, a full top-up probe: resolvePool + poolState + rent) on
- * the critical path of EVERY inference — 4.52s of the 7s a one-line completion
- * took. Balances do not move at request rate; a wallet spending $0.00004 a call
- * has the same balance it had a minute ago.
+ * MEASURED: a per-request balance probe put a mainnet round trip on the critical
+ * path of EVERY inference — 4.52s of the 7s a one-line completion took, most of
+ * it the since-deleted conversion probe a short row triggered. Balances do not
+ * move at request rate; a wallet spending $0.00004 a call has the same balance
+ * it had a minute ago.
  *
  * Stale-while-revalidate: a cached value is returned IMMEDIATELY and a refresh is
  * kicked off in the background when it is older than the TTL, so no request ever
@@ -120,53 +122,16 @@ export function resetRailMemory() {
   lastGoodAsset = null;
 }
 
-/**
- * Skip wrap / pool / sendWrap when there is nothing to convert.
- * wrapped < need AND underlying == 0 → UnderfundedError, no RPC walk.
- * A funded wallet (underlying > 0) still wraps.
- */
-export function skipWrapWhenEmpty(wrappedRaw, underlyingRaw, need) {
-  const wrapped = wrappedRaw == null ? 0n : BigInt(wrappedRaw);
-  const underlying = underlyingRaw == null ? 0n : BigInt(underlyingRaw);
-  const want = need == null ? 0n : BigInt(need);
-  return wrapped < want && underlying <= 0n;
-}
-
-/**
- * Cheap underlying mint for a 402 row — directory acquire address, or the
- * known USDC / TOKEN / LEOS twin named in extra.symbol. No chain probe.
- */
-export function hintedUnderlyingMint(accept) {
-  const acq = accept?.extra?.acquire?.underlying;
-  const addr = typeof acq === 'string' ? acq : acq?.address;
-  if (addr && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(addr)) return addr;
-  const plain = String(accept?.extra?.symbol || '').replace(/^[wy]/i, '').replace(/x$/i, '').toUpperCase();
-  return FUNDING_ASSETS.find((a) => a.symbol === plain)?.mint || null;
-}
-
-/** True when every Solana funding mint (USDC / TOKEN / LEOS) reads 0. */
-export function solanaFundingEmpty(balances) {
-  const rows = Array.isArray(balances) ? balances : [];
-  if (!rows.length) return false;
-  return rows.every((b) => (b?.raw == null ? 0n : BigInt(b.raw)) <= 0n);
-}
 
 export class PayClient {
   /**
-   * @param {{keypair?: import('@solana/web3.js').Keypair, evmPrivateKey?: string}} [burner]
-   *   Spend from a SPECIFIC wallet instead of this machine's ~/.openzoo/wallet.json.
-   *   @openzoobot needs this: the asker pays from their own derived burner, so
-   *   one poller process settles from a different wallet per question. Without
-   *   the override every X user's question would be paid by the operator's
-   *   machine wallet — which is not "the asker pays", it is us paying for
-   *   everyone and calling it x402.
+   * Always this machine's ~/.openzoo/wallet.json. The constructor used to take
+   * a per-user derived burner so the X bot could make each asker pay their own
+   * way; that bot is gone and nothing else ever passed one, so the override was
+   * a second wallet path with no caller and no test.
    */
-  constructor(burner) {
-    // A derived burner is only ever used to make SOMEONE ELSE pay, so it
-    // implies x402-only. Defaulting this off would silently reintroduce the
-    // bug it exists to prevent.
-    this.noSubscription = Boolean(burner?.keypair) && burner?.allowSubscription !== true;
-    const w = burner?.keypair ? { ...burner, created: false, path: '(derived)' } : loadOrCreateWallet();
+  constructor() {
+    const w = loadOrCreateWallet();
     this.keypair = w.keypair;
     this.evmPrivateKey = w.evmPrivateKey;
     this.walletCreated = w.created;
@@ -198,71 +163,30 @@ export class PayClient {
   }
 
   /**
-   * What this wallet can actually PAY with on this rail, in settlement-asset
-   * units — wrapped holdings PLUS the plain token it can convert on the fly.
-   *
-   * balanceForAccept answers a different question: how much of the WRAPPED
-   * asset is sitting there right now. Every quote names the wrapper (wTOKENx,
-   * the RH vault twins), so a wallet holding 845,486 plain TOKEN read as
-   * "$3.14 covered" — only the sliver already wrapped — while `openzoo balance`
-   * showed the full holding priced as `$?`. Two different wrong answers about
-   * the same wallet, and a user was told to fund an account with $177 in it.
+   * What this wallet can PAY with on this rail, in whole-dollar units.
    *
-   * buildPaymentFor already wraps what it needs at payment time (topUpQuotedAsset
-   * on Solana, acquireWrappedIfNeeded on EVM), so the convertible balance IS
-   * spendable and the estimate was simply lying by omission. Advisory only:
-   * anything unreadable degrades to the wrapped figure rather than throwing,
-   * because this feeds a display and a top-up hint, never a settlement.
+   * This used to add a second term: the plain token behind the quoted WRAPPER,
+   * because every row named a twin (yUSDCx / wTOKENx / the RH vault) and a
+   * wallet holding 845,486 plain TOKEN read as "$3.14 covered" — the sliver
+   * already wrapped. The gateway now quotes the raw native mint on every rail,
+   * so the balance the row asks about is the balance the wallet holds and the
+   * second term would double-count it. Advisory only: it feeds a display and a
+   * funding hint, never a settlement.
    */
   async spendableUsdForAccept(accept) {
     const perUsd = BigInt(accept.maxAmountRequired || '0');
     if (perUsd <= 0n) return 0;
-    const wrappedRaw = await this.balanceForAccept(accept).catch(() => 0n);
-    let usd = Number(wrappedRaw * 1000n / perUsd) / 1000;
-
-    // Price the PLAIN token with the quote's own tokenUsd, NOT with the pool's
-    // supply/reserves ratio. That ratio is share accounting, not a price: the
-    // live wTOKENx pool reads supply/reserves ≈ 5659, so treating it as a
-    // conversion rate valued 845,486 TOKEN at $1,004,132. The 402 already
-    // publishes what a whole token is worth, and the wrapper is a claim on the
-    // same asset — so underlying and wrapped are priced identically, which is
-    // exactly what `openzoo balance` now shows.
-    const px = Number(accept?.extra?.tokenUsd);
-    if (!Number.isFinite(px) || px <= 0) return usd;
-    const rail = railOf(accept);
-    try {
-      if (rail === 'solana') {
-        const pool = await resolvePool(this.connection, accept.asset);
-        if (!pool) return usd;
-        const under = await tokenBalance(this.connection, this.keypair.publicKey,
-          pool.underlying.toBase58());
-        usd += Number(under?.ui || 0) * px;
-        return usd;
-      }
-      // EVM wrappers are ERC-4626; asset() names the plain token behind them.
-      const { createPublicClient, http } = await import('viem');
-      const pc = createPublicClient({ transport: http(evmRpcFor(rail)) });
-      const ABI = [
-        { name: 'asset', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
-        { name: 'decimals', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint8' }] },
-      ];
-      const under = await pc.readContract({ address: accept.asset, abi: ABI, functionName: 'asset', args: [] });
-      const raw = await evmTokenBalance({ rpcUrl: evmRpcFor(rail), token: under, owner: this.evmAddress });
-      if (!raw || raw <= 0n) return usd;
-      const dec = Number(accept?.extra?.decimals ?? 18);
-      usd += (Number(raw) / 10 ** dec) * px;
-      return usd;
-    } catch {
-      return usd;          // not a wrapper, or a rail we cannot read
-    }
-  }
-
-  async solanaFundingBalances() {
-    const owner = this.keypair.publicKey;
-    return Promise.all(FUNDING_ASSETS.map((a) => cachedTokenBalance(this.connection, owner, a.mint)));
+    const raw = await this.balanceForAccept(accept).catch(() => 0n);
+    return Number(raw * 1000n / perUsd) / 1000;
   }
 
-  async buildPaymentFor(accept, onStage) {
+  /**
+   * `challenge` is the whole 402 body, not decoration: the envelope echoes its
+   * `resource` block and its `x402` summary decides which network string the
+   * verifier will accept. Both rails build their payload here and the envelope
+   * is assembled once, so neither can drift into the v1 shape on its own.
+   */
+  async buildPaymentFor(accept, onStage, challenge) {
     const rail = railOf(accept);
     if (rail === 'solana') {
       const need = BigInt(accept.maxAmountRequired);
@@ -272,31 +196,13 @@ export class PayClient {
       if (bal.raw < need && bal.cached) {
         bal = await cachedTokenBalance(this.connection, this.keypair.publicKey, accept.asset, { force: true });
       }
-      if (bal.raw < need) {
-        // Empty first-run burner: 0 wrapped + 0 USDC/TOKEN/LEOS. Do not
-        // resolvePool / poolState / sendWrap just to learn that.
-        const funding = await this.solanaFundingBalances();
-        if (solanaFundingEmpty(funding)) {
-          throw new UnderfundedError(accept, 0, this.address);
-        }
-        const underMint = hintedUnderlyingMint(accept);
-        if (underMint) {
-          let under = await cachedTokenBalance(this.connection, this.keypair.publicKey, underMint);
-          if (under.raw <= 0n && under.cached) {
-            under = await cachedTokenBalance(this.connection, this.keypair.publicKey, underMint, { force: true });
-          }
-          if (skipWrapWhenEmpty(bal.raw, under.raw, need)) {
-            throw new UnderfundedError(accept, under.ui, this.address);
-          }
-        }
-        const topUp = await this.topUpQuotedAsset(accept, need, onStage);
-        if (topUp.preInstructions) {
-          return buildPaymentOnline(this.connection, this.keypair, accept, {
-            preInstructions: topUp.preInstructions,
-          });
-        }
-      }
-      return buildPaymentOnline(this.connection, this.keypair, accept);
+      // SHORT IS SHORT. The 402 quotes the raw native mint, so there is nothing
+      // to convert and no pool to walk: the wallet either holds the asset or it
+      // does not. This branch used to run resolvePool + poolState + a wrap
+      // (~4.5s) to mint a Token-2022 twin the gateway no longer accepts.
+      if (bal.raw < need) throw new UnderfundedError(accept, bal.ui, this.address);
+      const built = await buildPaymentOnline(this.connection, this.keypair, accept);
+      return { ...built, header: encodeEnvelope(paymentEnvelope(challenge, accept, built.payload)) };
     }
     // OPENZOO_RAIL=robinhood is explicit intent — it opens the RH gate the
     // same way OPENZOO_ENABLE_RH=1 does.
@@ -309,111 +215,22 @@ export class PayClient {
       if (owner) {
         const bal = await evmTokenBalance({ rpcUrl, token: accept.asset, owner }).catch(() => null);
         if (bal !== null && bal < BigInt(accept.maxAmountRequired)) {
-          if (rail === 'robinhood') {
-            // The RH settlement asset is a vault twin over the plain token the
-            // user actually holds. Convert exactly enough at payment time
-            // (approve + deposit) — the EVM mirror of the Solana top-up above.
-            // Throws NeedsGasError / UnderlyingShortError with exact, plain-
-            // token-named instructions when the wallet cannot convert. An RPC
-            // hiccup mid-probe falls through to the flat underfunded message.
-            let converted = null;
-            try {
-              converted = await acquireWrappedIfNeeded({
-                rpcUrl, accept, evmPrivateKey: this.evmPrivateKey, onStage,
-              });
-            } catch (e) {
-              if (e?.name === 'NeedsGasError' || e?.name === 'UnderlyingShortError' || /openzoo/.test(e?.message || '')) throw e;
-              converted = null;
-            }
-            if (!converted || converted.wrapper === false || (!converted.acquired && converted.wrapper !== null)) {
-              const line = `The wallet must hold the token this row is quoted in — fund ${owner} on Robinhood Chain, or see https://x402.accrue.fund/start.`;
-              throw new UnderfundedError(accept, null, owner, { line });
-            }
-          } else {
-            throw new UnderfundedError(accept, null, owner, { line: `Send a few cents of USDC on Base to ${owner}.` });
-          }
+          // Robinhood used to quote an ERC-4626 vault twin here and the shim
+          // ran approve+deposit to mint it. The gateway now quotes canonical
+          // Paxos USDG, which implements EIP-3009 directly, so the only
+          // question left on every EVM rail is whether the wallet holds enough.
+          const sym = accept?.extra?.symbol || 'the quoted asset';
+          const where = rail === 'robinhood' ? 'Robinhood Chain' : rail === 'base' ? 'Base' : accept.network;
+          throw new UnderfundedError(accept, null, owner, {
+            line: `Send a few cents of ${sym} on ${where} to ${owner}.`,
+          });
         }
       }
-      return buildEvmPayment({ accept, evmPrivateKey: this.evmPrivateKey });
+      return buildEvmPayment({ accept, evmPrivateKey: this.evmPrivateKey, challenge });
     }
     throw new Error(`no payment builder for rail ${rail} (network ${accept.network})`);
   }
 
-  /**
-   * Internal: make sure the wallet holds enough of the exact asset the 402
-   * quotes, by converting the user's plain USDC (or whatever underlying the
-   * pool takes) at payment time. Users never see or hold the quoted asset.
-   *
-   * Returns {} when the balance now covers the quote, or
-   * { preInstructions } when the wallet cannot pay network fees itself — the
-   * conversion then rides inside the gateway-sponsored payment transaction
-   * (the 402's feePayer covers fees and any account rent).
-   * Throws UnderfundedError when the underlying balance cannot cover it.
-   */
-  async topUpQuotedAsset(accept, need, onStage) {
-    const owner = this.keypair.publicKey;
-    const pool = await resolvePool(this.connection, accept.asset).catch(() => null);
-    if (!pool) throw new UnderfundedError(accept, null, this.address);
-
-    // Balances first. 0 wrapped + 0 underlying → throw. Never poolState or
-    // sendWrap just to discover an empty burner (measured ~4.5s per row).
-    const [wrappedNow, underlyingNow] = await Promise.all([
-      tokenBalance(this.connection, owner, accept.asset),
-      tokenBalance(this.connection, owner, pool.underlying.toBase58()),
-    ]);
-    if (skipWrapWhenEmpty(wrappedNow.raw, underlyingNow.raw, need)) {
-      throw new UnderfundedError(accept, underlyingNow.ui, this.address);
-    }
-
-    for (let attempt = 0; attempt < 3; attempt++) {
-      const bal = attempt === 0 ? wrappedNow : await tokenBalance(this.connection, owner, accept.asset);
-      const short = need - bal.raw;
-      if (short <= 0n) return {};
-
-      const { reserves, supply } = await poolState(this.connection, pool);
-      const minDeposit = depositForShares(short, reserves, supply);
-      const underlyingBal = attempt === 0
-        ? underlyingNow
-        : await tokenBalance(this.connection, owner, pool.underlying.toBase58());
-      if (underlyingBal.raw < minDeposit) {
-        throw new UnderfundedError(accept, underlyingBal.ui, this.address);
-      }
-      // WRAP EVERYTHING, NOT THE SHORTFALL. Wrapping per-payment meant every
-      // paid call re-ran resolvePool+poolState+wrap+confirm (~4.5s) and
-      // re-opened the same balance race that false-paywalled a funded wallet.
-      // Wrapped twins exist only to be spent on payments, so there is nothing
-      // to preserve by leaving the underlying raw: convert the full balance
-      // once, and every later payment takes the fast path (measured 0.36s)
-      // straight from wrapped funds. (Operator directive, verbatim: the burner
-      // must "autotopup with all my crypto".) The bundled no-SOL path below
-      // keeps the minimal amount — it rides inside the payment tx, where a
-      // full-balance wrap would bloat a transaction we do not control.
-      const deposit = underlyingBal.raw > minDeposit ? underlyingBal.raw : minDeposit;
-
-      onStage?.('funding');
-      const wrappedAta = getAssociatedTokenAddressSync(pool.wrapped, owner, false, pool.wrappedProgram);
-      const [lamports, ataInfo] = await Promise.all([
-        this.connection.getBalance(owner),
-        this.connection.getAccountInfo(wrappedAta),
-      ]);
-      const lamportsNeeded = 10000 + (ataInfo ? 0 : 2400000); // tx fee + possible ATA rent
-      if (lamports < lamportsNeeded && accept.extra?.feePayer) {
-        // No SOL for a standalone conversion — bundle it into the payment tx.
-        const rentPayer = new PublicKey(accept.extra.feePayer);
-        return {
-          preInstructions: buildWrapInstructions({ pool, owner, depositRaw: minDeposit, rentPayer }),
-        };
-      }
-      const sig = await sendWrap(this.connection, this.keypair, pool, deposit);
-      this.lastTopUpSig = sig; // internal breadcrumb, never printed to users
-      if (process.env.OPENZOO_DEBUG) console.error(`[openzoo debug] top-up tx ${sig}`);
-    }
-
-    const finalBal = await tokenBalance(this.connection, owner, accept.asset);
-    if (finalBal.raw < need) throw new UnderfundedError(accept, null, this.address);
-    return {};
-  }
-
   /**
    * fetch that transparently pays a 402 once.
    * Returns { response, paid, accept?, settle?, receipt? }.
@@ -424,21 +241,14 @@ export class PayClient {
     // Contexts are tenanted by this namespace server-side — a request without
     // it cannot see corpora this wallet bound.
     init = { ...init, headers: withNamespace(init.headers || {}, { keypair: this.keypair }) };
-    // Subscription key · no x402. A stored Stripe key is a bearer on the zoo
-    // API (same as the public /billing/done snippet). Wallet/x402 stays if
-    // there is no key, or if the gateway still answers 402.
-    // `noSubscription` forces the WALLET to pay. @openzoobot needs it: the
-    // operator's stored subscription key is on the same machine as the poller,
-    // so without this every asker's paid question would be settled on OUR key
-    // while the reply claimed x402 — and an empty burner would answer happily,
-    // which is precisely how this was caught.
-    const sub = this.noSubscription ? null : loadSubscription();
-    if (sub?.key) init = { ...init, headers: applySubscriptionHeaders(init.headers, sub) };
-    // Strip any bearer the caller inherited, for the same reason.
-    if (this.noSubscription) init = { ...init, headers: stripAuthorization(init.headers || {}) };
+    // THE WALLET IS THE ONLY PAY LANE. A stored bearer used to short-circuit
+    // everything below it, which meant an inherited Authorization header could
+    // buy inference this wallet never paid for. The gateway is pay-per-request
+    // only, so any bearer the caller carried in is dropped here.
+    init = { ...init, headers: stripAuthorization(init.headers || {}) };
     const first = await fetchHeaders(url, init);
     if (first.status !== 402) {
-      return { response: first, paid: false, subscription: Boolean(sub?.key && first.ok) };
+      return { response: first, paid: false };
     }
 
     const quote = parse402(await first.json());
@@ -448,16 +258,12 @@ export class PayClient {
     // affordable does the call fail — never because the first-choice asset
     // alone ran dry while another funded one sat in the wallet.
     const ordered = orderAccepts(quote, config.token, { allowRH: this.allowRH, forceRail: config.rail });
-    // RAIL MEMORY — the single biggest source of per-call latency.
-    // MEASURED: the first offered row (yUSDCx) was underfunded, and finding that
-    // out costs 4.52s, because an underfunded Solana row attempts a top-up first
-    // (resolvePool + poolState + balances + rent-exemption lookups). The row that
-    // actually pays (wTOKENx) then builds in 0.36s. That 4.5s was being re-paid on
-    // EVERY request to rediscover a fact that had not changed.
-    // So: remember which asset just paid and try it first, and skip assets known
-    // underfunded within the TTL. Bounded and self-healing — the memo expires, a
-    // funded wallet is re-tried automatically, and if every row is memoized we fall
-    // back to the full list rather than manufacturing a dead end.
+    // RAIL MEMORY. Remember which asset just paid and try it first, and skip
+    // assets known underfunded within the TTL, so a wallet with three offered
+    // rows does not re-probe the two it cannot pay on every single call.
+    // Bounded and self-healing — the memo expires, a funded wallet is re-tried
+    // automatically, and if every row is memoized we fall back to the full list
+    // rather than manufacturing a dead end.
     const candidates = orderCandidatesByMemory(ordered);
     onStage?.('quoted');
     let accept = null;
@@ -471,7 +277,7 @@ export class PayClient {
         continue;
       }
       try {
-        payment = await this.buildPaymentFor(cand, onStage);
+        payment = await this.buildPaymentFor(cand, onStage, quote);
         accept = cand;
         lastGoodAsset = memoKey(cand);
         underfundedUntil.delete(memoKey(cand));
@@ -480,9 +286,7 @@ export class PayClient {
         }
         break;
       } catch (e) {
-        const funding = e instanceof UnderfundedError
-          || e?.name === 'UnderlyingShortError' || e?.name === 'NeedsGasError';
-        if (!funding) throw e;
+        if (!(e instanceof UnderfundedError)) throw e;
         // Remember it so the next call does not re-pay the discovery cost.
         underfundedUntil.set(memoKey(cand), Date.now() + RAIL_MEMO_MS);
         fundErrs.push({ sym: cand?.extra?.symbol || cand?.asset, err: e });
@@ -499,7 +303,7 @@ export class PayClient {
     onStage?.('paying');
     const response = await fetchHeaders(url, {
       ...init,
-      headers: { ...stripAuthorization(init.headers || {}), 'X-PAYMENT': payment.header },
+      headers: { ...stripAuthorization(init.headers || {}), ...paymentHeaders(payment.header) },
     });
     const settle = decodeSettleHeader(response.headers.get('x-payment-response'))
       || { signature: payment.ownerSignature };
@@ -533,7 +337,7 @@ export class PayClient {
       body: JSON.stringify(bodyObj),
     }, { onStage });
     if (!response.ok) {
-      const text = rewriteWrapClientError((await response.text()).slice(0, 500));
+      const text = (await response.text()).slice(0, 500);
       throw new Error(`zoo returned HTTP ${response.status}: ${text}`);
     }
     return { data: await response.json(), receipt };

package/lib/podagent.mjs

@@ -257,7 +257,7 @@ async function httpErrorNote(status) {
         if (w.funded === false) {
           return `(payment required — HTTP 402, the wallet is empty. ${w.funding}. EVM (Base/Robinhood): ${w.evm}.)`;
         }
-        return `(payment failed — HTTP 402 after ${PAYMENT_RETRIES} retries, though the wallet holds ${w.balances || 'a balance'}. Send it again; if it keeps failing the quoted asset may not be convertible right now. Fund with: ${w.funding})`;
+        return `(payment failed — HTTP 402 after ${PAYMENT_RETRIES} retries, though the wallet holds ${w.balances || 'a balance'}. Send it again; if it keeps failing, the wallet may hold a different asset than the one this 402 quotes. Fund with: ${w.funding})`;
       }
     } catch { /* proxy unreachable — fall through to the generic note */ }
     return `(payment failed — HTTP 402 after ${PAYMENT_RETRIES} retries. Run \`npx openzoo\` to check wallet balances.)`;
@@ -267,24 +267,13 @@ async function httpErrorNote(status) {
   return status ? `(request failed — HTTP ${status})` : '';
 }
 
-/** Do not dump raw Solana wrap-sim logs into the chat bubble. */
-function sanitizeProxiedError(msg) {
-  if (!msg) return msg;
-  const s = String(msg);
-  if (/0x6a\b|custom program error:\s*106\b|NotEnoughAccounts/i.test(s)) {
-    return 'wrap ix has too few accounts (need 9); old 5-account wrap is dead';
-  }
-  if (/0x70\b|custom program error:\s*112\b|TokenProgramMismatch/i.test(s)) {
-    return 'unwrap ix is missing the unwrapped token program (account 8); 8-account unwrap is dead';
-  }
-  return s;
-}
 
 // A 402 that reached this layer means the proxy's own x402 retry gave up on
 // this attempt, but the NEXT attempt usually settles (measured: same wallet,
 // same rail, second call pays fine). Surfacing that as a chat message makes
 // the user do the retry by hand — so do it here instead.
-// Empty/underfunded is NOT that handshake: retrying just re-walks wrap.
+// Empty/underfunded is NOT that handshake: the balance will not have changed,
+// so retrying just re-reads it and fails the same way.
 const PAYMENT_RETRIES = 3;
 
 export function isUnderfunded402Body(body) {
@@ -443,7 +432,7 @@ export async function brainStream(messages, onDelta, contextId, modelOverride, m
     const msg = j?.choices?.[0]?.message;
     const content = msg?.content;
     const thinking = messageReasoning(msg);
-    const proxied = sanitizeProxiedError(j?.error?.message);
+    const proxied = j?.error?.message;
     const text = content || (r.ok ? '' : (proxied ? `(request failed — HTTP ${r.status}: ${proxied})` : await httpErrorNote(r.status)));
     if (thinking) onDelta(thinking, { think: true });
     if (text) onDelta(text);
@@ -815,7 +804,7 @@ async function brainGatewayRace(messages, onDelta, contextId, models, need, maxT
         const j = await r.json().catch(() => ({}));
         const msg = j?.choices?.[0]?.message;
         const content = msg?.content;
-        const proxied = sanitizeProxiedError(j?.error?.message);
+        const proxied = j?.error?.message;
         const text = wrapThink(messageReasoning(msg), content || (r.ok ? '' : (proxied ? `(request failed — HTTP ${r.status}: ${proxied})` : await httpErrorNote(r.status))));
         lastFail = { model: 'gateway', text: text || '', error: r.ok ? undefined : `HTTP ${r.status}` };
         if (isRaceCountable(lastFail)) {

package/lib/proxy.js

@@ -33,10 +33,8 @@ import { responsesToChat, chatToResponses, writeResponsesSse } from './responses
 import { streamOpenAIToResponses } from './responses-stream.js';
 import { loadSessionSpend, saveSessionSpend } from './session.js';
 import { creditBalance, quotedPrices } from './info.js';
-import { subscriptionPublicView } from './subscription.js';
 import { priceHoldings } from './livestatus.js';
 import { receiptUsedCogs, receiptDirectUsd, pairActualBilled } from './racesettle.js';
-import { rewriteWrapClientError } from './wrap.js';
 import { fetchHeaders } from './fetch.js';
 
 const HOP_BY_HOP = new Set([
@@ -975,7 +973,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         version,
         spentUsd: sessionSpent, cogsUsd: sessionCogs, directUsd: sessionDirect, paidCalls,
         creditUsd, chainUsd: money.chainUsd, lastQuoteUsd,
-        subscription: subscriptionPublicView(),
       }));
       return;
     }
@@ -999,7 +996,6 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         creditUsd,
         chainUsd: money.chainUsd,
         holdings: money.holdings,
-        subscription: subscriptionPublicView(),
       }));
       return;
     }
@@ -1107,9 +1103,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           },
           mcp: `${self.replace(/\/v1$/, '')}/mcp`,
           upstream: config.apiBase,
-          payment: subscriptionPublicView().active
-            ? 'subscription key � no x402 � wallet/x402 remains the other method'
-            : 'x402 per request from the operator\'s local burner wallet � no API key, no account',
+          payment: 'x402 per request from the operator\'s local burner wallet - no API key, no account',
           auth: viaTunnel
             ? 'this public URL requires the oz_… bearer for paid endpoints; /v1/models and /v1/hrr/bind are free'
             : 'localhost is keyless',
@@ -1561,8 +1555,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     // rewrite never gets its chance.
     const path = (req.url || '').split('?')[0];
     if (req.method === 'GET' && path === '/v1/models') {
-      // Catalog is chrome, not a paid call. Paying the list would wrap-walk
-      // an empty burner (~4.5s/row) and stall first paint / harness probe.
+      // Catalog is chrome, not a paid call. Paying the list would put a 402
+      // round trip and a balance read in front of first paint.
       try {
         const response = await fetchHeaders(url, init);
         if (response.ok) {
@@ -1940,7 +1934,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         // transport hiccup looks identical to a payment bug.
         const cause = err.cause?.message || err.cause?.code || err.cause;
         const raw = cause ? `${err.message} (${cause})` : err.message;
-        const detail = rewriteWrapClientError(raw);
+        const detail = raw;
         log(`proxy error: ${detail}`);
         if (process.env.OPENZOO_DEBUG) console.error(err.stack);
         jsonErr(res, 502, `openzoo proxy error: ${detail}`);