openzoo 0.49.3 → 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/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)) {

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/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.3",
+  "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",