openzoo 0.49.2 → 0.49.4

package/README.md

@@ -187,7 +187,7 @@ All three rails have settled real payments (2026-08-14):
 
 | rail | network | status |
 |---|---|---|
-| **Solana** (default) | `solana:5eykt…` | **live** — Token-2022 `TransferChecked`, partial-signed, gateway pays fees. Settles daily; tested end-to-end against the production 402. Settlement uses a wrapped settlement mint as internal plumbing; you only ever hold and send USDC or TOKEN. |
+| **Solana** (default) | `solana:5eykt…` | **live** — Token-2022 payment `TransferChecked`, partial-signed, gateway pays fees. Settles daily; tested end-to-end against the production 402. Settlement uses a wrapped mint as internal plumbing; you only ever hold and send USDC or TOKEN. Funding wrap is a 9-account ix (program pulls the deposit; old 5-account wrap is rejected `0x6a`). |
 | Base | `eip155:8453` | **live** — standard x402 EIP-3009 `transferWithAuthorization` against native USDC, batched settle through the facilitator. Fund the wallet's EVM address with USDC on Base; nothing is converted. |
 | Robinhood Chain | `eip155:4663` | **live** — EIP-3009, batched settle through the facilitator. Hold the plain token a row is quoted in (USDG, or the ODDBALLER / IOU / ROBINHOODS memecoins) and the shim converts exactly enough at payment time, automatically — two small on-chain steps paid from the wallet's own RH ETH. No gas? The error says exactly how much ETH to send and where. Default rail selection skips this chain unless `OPENZOO_ENABLE_RH=1`; `OPENZOO_RAIL=robinhood` forces it outright. |
 

package/lib/grokui.mjs

@@ -691,6 +691,7 @@ const AUTO_RACE_RETRY = 'AUTO is still on — the last model call failed (race/e
   + 'Do not stop and do not ask the user to type continue. '
   + 'Emit the next directive now (RUN:/SPAWN:/SEND:/READ:/WRITE:/GLOB:/FETCH:/MCP:/SERVE:), '
   + 'or DONE: if the job is actually finished.';
+const AUTO_EMPTY_RETRY = 'AUTO_EMPTY_RETRY: the command produced no output, try a different command or a different path, do not stop.';
 // Said it would, without a directive line. "Spawned X" and "working on it" are
 // in here because they are FALSE without a SPAWN: in the same reply — the bot
 // reports success for something the harness never saw.
@@ -709,13 +710,43 @@ function isTransientModelFail(text) {
 function isPaymentFailed(text) {
   return /\b(?:payment failed|HTTP 402|wallet is empty|empty wallet)\b/i.test(String(text || ''));
 }
+// Empty stdout, "(no output)", or a directive that found nothing. That is
+// still a command-output hop today, so AUTO used to chain once and then park
+// as if the job had succeeded. It has not — try another command or path.
+function isEmptyExecOutput(text) {
+  const s = String(text ?? '').trim();
+  return !s || s === '(no output)';
+}
+function isEmptyDirectiveAck(text) {
+  const s = String(text ?? '').trim();
+  if (isEmptyExecOutput(s)) return true;
+  if (/:\s*\(empty\)$/i.test(s)) return true;
+  if (/:\s*no matches\s*$/i.test(s)) return true;
+  return false;
+}
+function isEmptyToolResult(text) {
+  if (text == null) return false;
+  const s = String(text).trim();
+  if (isEmptyExecOutput(s)) return true;
+  const cmd = /^\(command output\)\s*([\s\S]*)$/.exec(s);
+  if (cmd) return isEmptyExecOutput(cmd[1]);
+  const dir = /^\(directive result\)\s*([\s\S]*)$/.exec(s);
+  if (dir) return isEmptyDirectiveAck(dir[1]);
+  return false;
+}
+function isEmptyShownRun(text) {
+  const shown = /^\$ [^\n]*\n([\s\S]*)$/.exec(String(text ?? ''));
+  return Boolean(shown && isEmptyExecOutput(shown[1]));
+}
 // Park only: ask mode, pendingRun, DONE:, 402/empty-wallet, or the hard cap.
-function shouldKeepAuto(t, reply) {
+// Empty /(no output) exec is not DONE — keep going with AUTO_EMPTY_RETRY.
+function shouldKeepAuto(t, reply, userText) {
   if (!t || t.runMode !== 'auto') return false;
   if (t.pendingRun) return false;
   if ((t.autoSteps || 0) >= AUTO_MAX_STEPS) return false;
-  if (isDoneReply(reply)) return false;
   if (isPaymentFailed(reply)) return false;
+  if (isEmptyToolResult(userText) || isEmptyShownRun(reply)) return true;
+  if (isDoneReply(reply)) return false;
   return true;
 }
 function enqueueAutoHop(t, threadId, userText, onEvent) {
@@ -725,7 +756,8 @@ function enqueueAutoHop(t, threadId, userText, onEvent) {
   kickTurn(threadId, userText, onEvent).catch(() => {});
   return true;
 }
-function autoHopText(reply) {
+function autoHopText(reply, userText) {
+  if (isEmptyToolResult(userText) || isEmptyShownRun(reply)) return AUTO_EMPTY_RETRY;
   return isTransientModelFail(reply) ? AUTO_RACE_RETRY : AUTO_CONTINUE;
 }
 // PING used to be a read: last-line status, no turn. Idle children stayed idle
@@ -805,7 +837,8 @@ without a fact only the user has.
 
 When the job is actually finished, emit DONE: as the first line. A status
 sentence is not a stop — the harness keeps this thread working until DONE:,
-a real blocking question, or the step cap.`;
+a real blocking question, or the step cap. Empty output, "(no output)", and
+GLOB/GREP with no matches are not finished — try a different command or path.`;
 async function bindThread(t) {
   // Only bind what's NEW since the last successful bind, continuing the
   // existing context_id — previously this rebuilt and re-sent the WHOLE
@@ -992,7 +1025,7 @@ function execCommand(command, cwd) {
     exec(command, { cwd, shell: RUN_SHELL, timeout: RUN_TIMEOUT_MS, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
       let out = (stdout || '') + (stderr ? '\n' + stderr : '');
       if (err) out += `\n(exit ${err.code ?? 1})`;
-      resolve(keepWhole(out) || '(no output)');
+      resolve(keepWhole(out).trim() || '(no output)');
     });
   });
 }
@@ -1411,7 +1444,7 @@ setInterval(() => {
     const lastBot = [...(t.history || [])].reverse().find((h) => h.who === 'bot');
     const lastText = lastBot?.text || '';
     if (shouldKeepAuto(t, lastText)) {
-      kickTurn(t.id, isTransientModelFail(lastText) ? AUTO_RACE_RETRY : AUTO_CONTINUE).catch(() => {});
+      kickTurn(t.id, autoHopText(lastText)).catch(() => {});
     } else {
       t.status = 'idle';
       t.liveStatus = '';
@@ -1676,7 +1709,9 @@ function isHarnessUserText(text) {
   return /^\((command output|directive result)\)/.test(String(text || ''))
     || String(text || '') === NUDGE
     || String(text || '') === AUTO_CONTINUE
-    || String(text || '') === AUTO_RACE_RETRY;
+    || String(text || '') === AUTO_RACE_RETRY
+    || String(text || '') === AUTO_EMPTY_RETRY
+    || String(text || '').startsWith('AUTO_EMPTY_RETRY:');
 }
 
 function firstUserAsk(t) {
@@ -2502,8 +2537,8 @@ async function runTurn(threadId, userText, onEvent, images) {
     }
     bindThread(t).catch(() => {});
     lastReply = memberReply;
-    if (shouldKeepAuto(t, memberReply)) {
-      chained = enqueueAutoHop(t, threadId, autoHopText(memberReply), onEvent);
+    if (shouldKeepAuto(t, memberReply, userText)) {
+      chained = enqueueAutoHop(t, threadId, autoHopText(memberReply, userText), onEvent);
     }
     return;
   }
@@ -2638,7 +2673,11 @@ async function runTurn(threadId, userText, onEvent, images) {
       // most material (command output, GLOB results, MCP tool lists). The
       // holographic context stopped growing precisely when it mattered.
       lastReply = shown;
-      chained = enqueueAutoHop(t, threadId, condense('(command output)', output), onEvent);
+      chained = enqueueAutoHop(
+        t, threadId,
+        isEmptyExecOutput(output) ? AUTO_EMPTY_RETRY : condense('(command output)', output),
+        onEvent,
+      );
       return;
     }
     {
@@ -2668,8 +2707,12 @@ async function runTurn(threadId, userText, onEvent, images) {
   // Same budget as RUN (shared t.autoSteps, reset when the user speaks), so
   // this cannot spend more than a chained RUN loop already could.
   if (t.runMode === 'auto' && ack !== null && ack !== undefined
-      && !isDoneReply(reply)) {
-    chained = enqueueAutoHop(t, threadId, condense('(directive result)', ack), onEvent);
+      && (isEmptyDirectiveAck(ack) || !isDoneReply(reply))) {
+    chained = enqueueAutoHop(
+      t, threadId,
+      isEmptyDirectiveAck(ack) ? AUTO_EMPTY_RETRY : condense('(directive result)', ack),
+      onEvent,
+    );
     return;
   }
 
@@ -2699,17 +2742,18 @@ async function runTurn(threadId, userText, onEvent, images) {
 
   // After any auto reply that is not DONE: and not waiting on approval,
   // kick immediately. Race/empty/error uses AUTO_RACE_RETRY.
-  if (shouldKeepAuto(t, reply)) {
-    chained = enqueueAutoHop(t, threadId, autoHopText(reply), onEvent);
+  if (shouldKeepAuto(t, reply, userText)) {
+    chained = enqueueAutoHop(t, threadId, autoHopText(reply, userText), onEvent);
     return;
   }
   bindThread(t).catch(() => {});
   } finally {
     // Idle only when this hop should not keep AUTO going: DONE:, pendingRun,
-    // ask mode, 402/empty-wallet, or the hard cap. Otherwise kick again.
+    // ask mode, 402/empty-wallet, or the hard cap. Empty /(no output) is not
+    // DONE — AUTO_EMPTY_RETRY. Otherwise kick again.
     if (stillMine() && !chained && !parked) {
-      if (shouldKeepAuto(t, lastReply)) {
-        enqueueAutoHop(t, threadId, autoHopText(lastReply), onEvent);
+      if (shouldKeepAuto(t, lastReply, userText)) {
+        enqueueAutoHop(t, threadId, autoHopText(lastReply, userText), onEvent);
       } else if (!t.pendingRun) {
         t.status = 'idle';
         t.liveStatus = '';
@@ -4973,12 +5017,12 @@ const APP_HTML = `<!doctype html>
         // is shipping the WHOLE corpus), so 2dp would read as noise up there.
         savedEl.textContent = (mult >= 100 ? Math.round(mult) : mult.toFixed(mult >= 10 ? 1 : 2)) + 'x';
         savedEl.className = mult >= 1 ? 'hlime' : 'hember';
-        // Session direct/spent (never first-call). Cogs-over-paid is the
-        // louder warn — unused grant-back should have kept used cogs ≤ billed.
+        // Session direct/spent (never first-call). Ember when cogs > spent —
+        // house losing. Do not treat race_unused as a user refund.
         if (cogsOver) {
           hintEl.className = 'hhint show';
-          hintEl.innerHTML = '<b>cogs above paid.</b> our cost exceeded what you were billed '
-            + '— this line is used racers, not the N+judge ceiling.';
+          hintEl.innerHTML = '<b>cogs above paid.</b> house is losing — our cost exceeded what you were billed. '
+            + 'you pay for every entrant we actually launched; failures still cost us.';
         } else {
           hintEl.className = mult >= 1 ? 'hhint' : 'hhint show';
           hintEl.innerHTML = '<b>feed it more.</b> you\\'re billed on the slice actually sent, '
@@ -5423,8 +5467,8 @@ export {
   tryDirective, ensureWorkspacePort, isPreviewableRel, previewAck, workspaceFileUrl,
   parseRun, looksLikeMcpAsBash, stripThinkTags, safeResolveIn, inDir, listDir,
   handleSlash, newThread, setRunTurnForTest, setBrainAskForTest, runTurn,
-  AUTO_CONTINUE, AUTO_RACE_RETRY, pingWakeText, pingCanWake, shouldKeepAuto,
-  isDoneReply, isTransientModelFail, enqueueAutoHop, childKickoff, findByName,
+  AUTO_CONTINUE, AUTO_RACE_RETRY, AUTO_EMPTY_RETRY, pingWakeText, pingCanWake, shouldKeepAuto,
+  isDoneReply, isTransientModelFail, isEmptyToolResult, enqueueAutoHop, childKickoff, findByName,
   attachChildDir, finishChildDir,
   lockWorktree, unlockWorktree, parsePrRef, fetchSpecsForOrigin, agentSlug,
 };

package/lib/pay.js

@@ -12,6 +12,7 @@ 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';
@@ -434,7 +435,7 @@ export class PayClient {
       body: JSON.stringify(bodyObj),
     }, { onStage });
     if (!response.ok) {
-      const text = (await response.text()).slice(0, 500);
+      const text = rewriteWrapClientError((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

@@ -258,6 +258,19 @@ 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
@@ -407,7 +420,7 @@ export async function brainStream(messages, onDelta, contextId, modelOverride, m
     // fall back to the non-streaming path rather than fail outright
     const j = await r.json().catch(() => ({}));
     const content = j?.choices?.[0]?.message?.content;
-    const proxied = j?.error?.message;
+    const proxied = sanitizeProxiedError(j?.error?.message);
     const text = content || (r.ok ? '' : (proxied ? `(request failed — HTTP ${r.status}: ${proxied})` : await httpErrorNote(r.status)));
     if (text) onDelta(text);
     return text;
@@ -753,7 +766,7 @@ async function brainGatewayRace(messages, onDelta, contextId, models, need, maxT
       if (!r.ok || !r.body) {
         const j = await r.json().catch(() => ({}));
         const content = j?.choices?.[0]?.message?.content;
-        const proxied = j?.error?.message;
+        const proxied = sanitizeProxiedError(j?.error?.message);
         const text = 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)) {
@@ -936,6 +949,7 @@ async function readGatewayRaceStream(r, feed, signal) {
  *
  * Every entrant is paid for, including the abandoned one — this trades money
  * for latency and quality, which is why it is opt-in and capped.
+ * grokui does not grant unused or failed racers back to the user.
  *
  * `hooks` is for tests: `{ stream, classify, pairwise, minScore }`.
  */

package/lib/proxy.js

@@ -27,6 +27,7 @@ import { creditBalance, quotedPrices } from './info.js';
 import { subscriptionPublicView } from './subscription.js';
 import { priceHoldings } from './livestatus.js';
 import { receiptUsedCogs } from './racesettle.js';
+import { rewriteWrapClientError } from './wrap.js';
 
 const HOP_BY_HOP = new Set([
   'host', 'connection', 'keep-alive', 'transfer-encoding', 'upgrade',
@@ -1726,7 +1727,8 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         // network error in `cause`. Surface it (and log the stack) or every
         // transport hiccup looks identical to a payment bug.
         const cause = err.cause?.message || err.cause?.code || err.cause;
-        const detail = cause ? `${err.message} (${cause})` : err.message;
+        const raw = cause ? `${err.message} (${cause})` : err.message;
+        const detail = rewriteWrapClientError(raw);
         log(`proxy error: ${detail}`);
         if (process.env.OPENZOO_DEBUG) console.error(err.stack);
         jsonErr(res, 502, `openzoo proxy error: ${detail}`);

package/lib/racesettle.js

@@ -1,6 +1,9 @@
 /**
- * Fly gateway race: one POST { race, race_need, tier }, unused grant-back,
- * and HUD cogs for the racers that actually ran — never the N+judge ceiling.
+ * Fly gateway race: one POST { race, race_need, tier }.
+ * User pays for every entrant we actually launched. Failures still cost us
+ * (OpenRouter was paid). race_unused on a receipt is informational — do not
+ * treat it as a user refund or shrink HUD cogs to hide a house loss.
+ * HUD embers when cogs > spent.
  */
 
 export const FLY_GATEWAY_HOST = 'x402-tokens.fly.dev';
@@ -92,40 +95,23 @@ export function capRaceByCredit(n, { creditUsd, quoteUsd } = {}) {
   return { n: Math.min(want, maxN), reason: 'shrunk' };
 }
 
-function unusedGrant(x) {
-  const u = x?.race_unused ?? x?.raceUnused ?? x?.unused;
-  if (u == null) return { billed: 0, cogs: 0 };
-  if (typeof u === 'number' && Number.isFinite(u)) return { billed: u, cogs: u };
-  if (typeof u !== 'object') return { billed: 0, cogs: 0 };
-  const billed = Number(u.billedUsd ?? u.refundUsd ?? u.unusedBilledUsd ?? u.usd ?? 0);
-  const cogs = Number(u.cogsUsd ?? u.unusedCogsUsd ?? u.refundCogsUsd ?? billed);
-  return {
-    billed: Number.isFinite(billed) && billed > 0 ? billed : 0,
-    cogs: Number.isFinite(cogs) && cogs > 0 ? cogs : 0,
-  };
-}
-
 /**
- * Actual used-racer cogs after unused grant-back.
- * Never the N+judge ceiling. Does not clamp to billed — HUD embers when
- * used cogs still exceed what was paid.
+ * House cost from the receipt. Do not subtract race_unused — unused
+ * grant-back is not a user refund, and shrinking cogs would hide house loss.
+ * Does not clamp to billed — HUD embers when cogs exceed what was paid.
  */
 export function receiptUsedCogs(x, markup = 3) {
   if (!x || typeof x !== 'object') return 0;
   const billedRaw = Number(x.billedUsd);
   const billedOk = Number.isFinite(billedRaw) && billedRaw >= 0;
-  let cogs = typeof x.cogsUsd === 'number' && Number.isFinite(x.cogsUsd)
-    ? x.cogsUsd
-    : (billedOk ? billedRaw / markup : 0);
-  const grant = unusedGrant(x);
-  if (grant.cogs > 0) cogs = Math.max(0, cogs - grant.cogs);
-  return cogs;
+  if (typeof x.cogsUsd === 'number' && Number.isFinite(x.cogsUsd)) return x.cogsUsd;
+  return billedOk ? billedRaw / markup : 0;
 }
 
 /**
- * Session meter. spent/direct are the receipt totals (already net of unused
- * when the gateway refunds into billedUsd) — never a first-call rewrite.
- * cogs is used racers after unused grant-back.
+ * Session meter. spent/direct are the receipt totals as billed — never a
+ * first-call rewrite, never a race_unused user refund.
+ * cogs is the house cost on that receipt (HUD embers when cogs > spent).
  */
 export function meterRaceReceipt(x, markup = 3) {
   const billed = Number(x?.billedUsd);

package/lib/wrap.js

@@ -8,23 +8,45 @@
  * shim. Nothing here is user-facing; never surface wrapped tickers or mints
  * in messages that reach the user.
  *
- * Verified against the deployed program's own e2e (solana-token-wrap/e2e/e2e.mjs)
- * and live mainnet wrap transactions:
- *   wrap ix: data = [1][amount u64 LE][authority bump]
- *            keys = [escrow(w), wrappedMint(w), userWrappedAta(w),
- *                    authorityPDA, wrappedTokenProgram]
- *   shares minted = floor(amount * supply / reserves), reserves read at ix
- *   execution — so the wrap ix is placed BEFORE the deposit TransferChecked.
- *   First deposit is 1:1 minus MINIMUM_LIQUIDITY (1000) locked forever.
- *   authority = PDA(['mint_authority', wrappedMint]); escrow = ATA(underlying,
- *   authority); registry = PDA(['backpointer', wrappedMint]) when present.
+ * CLIENT BUILDER COPY — extra.acquire.steps / 402 help (WRAP_ACQUIRE_STEPS).
+ *
+ * Wrap ix has 9 accounts. 0x6a = 106 = NotEnoughAccounts, thrown at
+ * need(accounts, 9)?. Old 5-account Wrap is rejected.
+ *
+ * Program FrSERTNCPvTtaDS9AvQp9u1nYGzXDb3kC9MdL8Xxn2NE now CPIs the deposit.
+ * Delete the separate TransferChecked. Sending both double-transfers.
+ *
+ * data = [1] ++ u64 amount LE ++ [bump]  (authority PDA bump, passed not derived)
+ *
+ * Accounts in exact order:
+ *   0 [writable] escrow (authority PDA ATA for UNDERLYING mint)
+ *   1 [writable] wrapped mint
+ *   2 [writable] recipient wrapped token account
+ *   3 []         wrapped mint authority PDA = PDA(["mint_authority", wrapped_mint], FrSER…)
+ *   4 []         wrapped token program (must equal wrapped_mint.owner; Token-2022 on shares)
+ *   5 [writable] depositor UNDERLYING token account
+ *   6 [signer]   depositor (owner of account 5)
+ *   7 []         unwrapped mint
+ *   8 []         unwrapped token program (must equal escrow.owner)
+ *
+ * Account 4 and 8 are not interchangeable (LEOS: shares Token-2022, escrow
+ * TokenkegQ). Derive each ATA under its own token program.
+ * Prepend createAssociatedTokenAccountIdempotentInstruction for the recipient
+ * wrapped ATA. The program mints into it; it does not create it.
+ *
+ * Unwrap: 9 accounts, account 8 = unwrapped token program. 8 accounts → 0x70
+ * TokenProgramMismatch. Prepend idempotent ATA create for recipient underlying
+ * (may have been closed after wrapping).
+ *
+ * First deposit is 1:1 minus MINIMUM_LIQUIDITY (1000) locked forever.
+ * authority = PDA(['mint_authority', wrappedMint]); escrow = ATA(underlying,
+ * authority); registry = PDA(['backpointer', wrappedMint]) when present.
  */
 import { PublicKey, Transaction, TransactionInstruction } from '@solana/web3.js';
 import {
   TOKEN_PROGRAM_ID,
   TOKEN_2022_PROGRAM_ID,
   createAssociatedTokenAccountIdempotentInstruction,
-  createTransferCheckedInstruction,
   getAssociatedTokenAddressSync,
   unpackAccount,
   unpackMint,
@@ -34,6 +56,47 @@ export const WRAP_PROGRAM_ID = new PublicKey('FrSERTNCPvTtaDS9AvQp9u1nYGzXDb3kC9
 const AUTHORITY_SEED = Buffer.from('mint_authority');
 const BACKPOINTER_SEED = Buffer.from('backpointer');
 export const MINIMUM_LIQUIDITY = 1000n;
+export const WRAP_IX_ACCOUNT_COUNT = 9;
+export const WRAP_TOO_FEW_ACCOUNTS =
+  'wrap ix has too few accounts (need 9); old 5-account wrap is dead';
+
+/** extra.acquire.steps / 402 help — the copy clients build the Wrap ix from. */
+export const WRAP_ACQUIRE_STEPS = {
+  method: 'spl-token-wrap',
+  program: 'FrSERTNCPvTtaDS9AvQp9u1nYGzXDb3kC9MdL8Xxn2NE',
+  help: 'Wrap ix has 9 accounts. Program CPIs the deposit — do not send a separate TransferChecked. 0x6a = NotEnoughAccounts (old 5-account wrap is dead).',
+  data: '[1] ++ u64 amount LE ++ [bump] (authority PDA bump, passed not derived)',
+  prepend: 'createAssociatedTokenAccountIdempotentInstruction for the recipient wrapped ATA',
+  accounts: [
+    { i: 0, writable: true, name: 'escrow', note: 'authority PDA ATA for UNDERLYING mint' },
+    { i: 1, writable: true, name: 'wrappedMint' },
+    { i: 2, writable: true, name: 'recipientWrappedAta' },
+    { i: 3, writable: false, name: 'mintAuthorityPda', note: 'PDA(["mint_authority", wrapped_mint], FrSER…)' },
+    { i: 4, writable: false, name: 'wrappedTokenProgram', note: 'must equal wrapped_mint.owner; Token-2022 on shares' },
+    { i: 5, writable: true, name: 'depositorUnderlyingAta' },
+    { i: 6, writable: false, signer: true, name: 'depositor', note: 'owner of account 5' },
+    { i: 7, writable: false, name: 'unwrappedMint' },
+    { i: 8, writable: false, name: 'unwrappedTokenProgram', note: 'must equal escrow.owner; not interchangeable with account 4' },
+  ],
+  unwrap: {
+    accounts: 9,
+    account8: 'unwrapped token program',
+    prepend: 'idempotent ATA create for recipient underlying (may have been closed)',
+    note: '8 accounts → 0x70 TokenProgramMismatch',
+  },
+};
+
+/** Short 402-help / chat copy. Never dump raw Solana simulation logs. */
+export function rewriteWrapClientError(message) {
+  const s = String(message ?? '');
+  if (/0x6a\b|custom program error:\s*106\b|NotEnoughAccounts/i.test(s)) {
+    return WRAP_TOO_FEW_ACCOUNTS;
+  }
+  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;
+}
 
 // Machine-readable per-asset acquire directory published by the facilitator.
 // Consulted first so newly listed twins work with zero code changes; on-chain
@@ -172,27 +235,15 @@ export async function poolState(connection, pool) {
 }
 
 /**
- * The three instructions of a conversion, in the mainnet-proven order:
- * ensure the wrapped ATA, mint shares (program reads pre-deposit reserves),
- * then move the deposit into escrow. `rentPayer` funds ATA creation (defaults
+ * ATA-create + 9-account Wrap. The program CPIs the deposit itself — there
+ * is no trailing TransferChecked. `rentPayer` funds ATA creation (defaults
  * to the owner; the gateway feePayer when riding inside a payment tx).
  */
 export function buildWrapInstructions({ pool, owner, depositRaw, rentPayer = owner }) {
   const userWrapped = getAssociatedTokenAddressSync(pool.wrapped, owner, false, pool.wrappedProgram);
   const userUnderlying = getAssociatedTokenAddressSync(pool.underlying, owner, false, pool.underlyingProgram);
-  // NINE ACCOUNTS, AND THE PROGRAM PULLS THE DEPOSIT ITSELF.
-  //
-  // This used to emit three instructions — ensure ATA, Wrap, then a separate
-  // TransferChecked moving the underlying into escrow — because the program
-  // only minted shares and trusted that the caller's own transfer would follow.
-  // Nothing enforced it. On 2026-08-18 a caller sent the Wrap instruction ALONE
-  // and minted shares backed by nothing, then unwrapped them: 829,559 TOKEN out
-  // of the vault, NAV 1 -> 0.000177.
-  //
-  // The deployed program (slot 440219442) now CPIs the transfer itself, so the
-  // Wrap instruction carries the depositor's source account and signature and
-  // the separate transfer is GONE. A 5-account call is rejected outright with
-  // NotEnoughAccounts (0x6a) — verified against mainnet by simulation.
+  // 9-account Wrap. Program CPIs the deposit. No TransferChecked after this.
+  // Old 5-account Wrap is rejected 0x6a (NotEnoughAccounts).
   const wrapIx = new TransactionInstruction({
     programId: pool.programId || WRAP_PROGRAM_ID,
     keys: [
@@ -254,6 +305,14 @@ export async function sendWrap(connection, keypair, pool, depositRaw) {
   tx.recentBlockhash = blockhash;
   tx.feePayer = keypair.publicKey;
   tx.sign(keypair);
-  const sig = await connection.sendRawTransaction(tx.serialize());
-  return confirmSignatureByPolling(connection, sig, { commitment: 'confirmed' });
+  try {
+    const sig = await connection.sendRawTransaction(tx.serialize());
+    return confirmSignatureByPolling(connection, sig, { commitment: 'confirmed' });
+  } catch (err) {
+    const rewritten = rewriteWrapClientError(err?.message || String(err));
+    if (rewritten !== (err?.message || String(err))) {
+      throw new Error(rewritten);
+    }
+    throw err;
+  }
 }

package/lib/x402.js

@@ -22,12 +22,18 @@ import {
  *                  payTo: "<wallet>", resource, description, maxTimeoutSeconds,
  *                  extra: { facilitator, feePayer, symbol, billedUsd, tokenUsd,
  *                           pricedAt, pricing: "markup"|"counterfactual",
- *                           markup? , directUsd?, savesVsDirect? } } ],
- *     error: "payment required", help: "..." }
+ *                           markup? , directUsd?, savesVsDirect?,
+ *                           acquire?: { method: "spl-token-wrap", steps: WRAP_ACQUIRE_STEPS } } } ],
+ *     error: "payment required",
+ *     help: "Wrap ix has 9 accounts. Program CPIs the deposit — do not send a separate TransferChecked. 0x6a = NotEnoughAccounts (old 5-account wrap is dead)." }
  *
- * Payment: ONE Token-2022 TransferChecked (payer ATA -> payTo ATA) for exactly
- * maxAmountRequired, feePayer = extra.feePayer (the gateway pays SOL fees),
- * partial-signed by the payer, serialized requireAllSignatures=false, base64.
+ * Payment of the quoted (already-wrapped) mint: ONE Token-2022 TransferChecked
+ * (payer ATA -> payTo ATA) for exactly maxAmountRequired, feePayer =
+ * extra.feePayer (the gateway pays SOL fees), partial-signed by the payer,
+ * serialized requireAllSignatures=false, base64.
+ * Funding a short wrapped balance is a *separate* 9-account Wrap prepended as
+ * preInstructions (lib/wrap.js WRAP_ACQUIRE_STEPS). Do not follow Wrap with a
+ * deposit TransferChecked — the program pulls the underlying itself.
  * X-PAYMENT header = base64 of
  *   {"x402Version":1,"scheme":"exact","network":"<network>","payload":{"transaction":"<b64 tx>"}}
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.49.2",
+  "version": "0.49.4",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun \u2014 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",