openzoo 0.48.23 → 0.48.24

package/lib/info.js

@@ -24,8 +24,53 @@ function fmtUi(raw, decimals) {
  * price is known ($1 stables); everything else gets an honest `?`.
  * A chain whose RPC does not answer prints as unreachable — never as zero.
  */
+/**
+ * USD per whole token, by SYMBOL, straight from the 402 quote.
+ *
+ * The quote already carries `extra.tokenUsd` for every asset it settles in —
+ * the very "priced at the 402" this file kept promising in a footnote while
+ * printing `$?`. So a wallet holding 845,486 TOKEN summed to "≈ $0.11 known".
+ * Symbols come back wrapped (wTOKENx, wLEOSx, wUSDGx); strip the wrapper so a
+ * row for the plain token the user actually holds finds its price.
+ */
+async function quotedPrices() {
+  const out = {};
+  try {
+    // Imported here, not at module scope, matching affordableUsd below — this
+    // file is loaded by `openzoo address`, which must work with no network.
+    const { withNamespace } = await import('./namespace.js');
+    const r = await fetch(`${config.apiBase}/v1/credits/topup`, {
+      method: 'POST',
+      headers: withNamespace({ 'content-type': 'application/json' }),
+      body: JSON.stringify({ usd: 1 }),
+    });
+    if (r.status !== 402) return out;
+    const ch = await r.json().catch(() => ({}));
+    for (const row of ch.accepts || []) {
+      const usd = Number(row?.extra?.tokenUsd);
+      const sym = String(row?.extra?.symbol || '');
+      if (!sym || !Number.isFinite(usd)) continue;
+      // wTOKENx -> TOKEN, wUSDGx -> USDG, yUSDCx -> USDC
+      const plain = sym.replace(/^[wy]/, '').replace(/x$/, '').toUpperCase();
+      out[sym.toUpperCase()] = usd;
+      if (!(plain in out)) out[plain] = usd;
+    }
+  } catch { /* offline: fall back to printing what we know */ }
+  return out;
+}
+
 export async function printBalance() {
   const { keypair, evmPrivateKey } = loadOrCreateWallet();
+  const px = await quotedPrices();
+  const priceOf = (sym) => px[String(sym).toUpperCase()];
+  const show = (sym, ui) => {
+    const p = priceOf(sym);
+    if (p == null) return ' ($?)';
+    const v = ui * p;
+    // Sub-cent holdings read as "$0.00", which is indistinguishable from
+    // worthless; show enough digits that a real balance is visible.
+    return ` ($${v >= 0.01 || v === 0 ? v.toFixed(2) : v.toFixed(6)})`;
+  };
   const evmAddress = privateKeyToAccount(evmPrivateKey).address;
   const connection = new Connection(config.rpcUrl, 'confirmed');
 
@@ -34,14 +79,17 @@ export async function printBalance() {
     Promise.all(FUNDING_ASSETS.map((a) => tokenBalance(connection, keypair.publicKey, a.mint))),
     connection.getBalance(keypair.publicKey),
   ]);
-  const usdcUi = balances[0].ui ?? 0;
-  let knownUsd = usdcUi;
+  // Seeded at zero: every asset is priced from the quote below, so seeding
+  // with USDC would count it twice.
+  let knownUsd = 0;
   let anyFunds = balances.some((b) => b.raw);
 
   console.log(`Solana — ${keypair.publicKey.toBase58()}`);
   FUNDING_ASSETS.forEach((a, i) => {
-    const usd = a.symbol === 'USDC' ? ` ($${(balances[i].ui ?? 0).toFixed(2)})` : ' ($?, valued at the 402)';
-    console.log(`  ${a.symbol.padEnd(11)}: ${balances[i].ui ?? 0}${usd}`);
+    const ui = balances[i].ui ?? 0;
+    const p = priceOf(a.symbol);
+    if (p != null) knownUsd += ui * p;
+    console.log(`  ${a.symbol.padEnd(11)}: ${ui}${show(a.symbol, ui)}`);
   });
   console.log(`  ${'SOL'.padEnd(11)}: ${lamports / 1e9} (gas — optional, payments are sponsored)`);
 
@@ -57,9 +105,9 @@ export async function printBalance() {
       assets.forEach((a, i) => {
         const ui = fmtUi(raws[i], a.decimals);
         if (raws[i] > 0n) anyFunds = true;
-        if (a.usd != null) knownUsd += ui * a.usd;
-        const usd = a.usd != null ? ` ($${(ui * a.usd).toFixed(2)})` : ' ($?)';
-        console.log(`  ${a.symbol.padEnd(11)}: ${ui}${usd}`);
+        const p = priceOf(a.symbol) ?? a.usd;
+        if (p != null) knownUsd += ui * p;
+        console.log(`  ${a.symbol.padEnd(11)}: ${ui}${p != null ? show(a.symbol, ui) : ' ($?)'}`);
       });
       console.log(`  ${'ETH'.padEnd(11)}: ${fmtUi(native, 18)} (gas — optional, payments are sponsored)`);
     } catch {
@@ -67,7 +115,7 @@ export async function printBalance() {
     }
   }
 
-  console.log(`value : ≈ $${knownUsd.toFixed(2)} known (stable legs; TOKEN and the RH memecoins are priced at the 402, shown as $?)`);
+  console.log(`value : ≈ $${knownUsd.toFixed(2)}${Object.keys(px).length ? ' (every asset priced at the 402)' : ' known (402 unreachable — unpriced assets shown as $?)'}`);
   if (!anyFunds) {
     console.log(`fund  : ${fundingLine(keypair.publicKey.toBase58())}`);
     console.log(`        or USDC on Base to ${evmAddress}`);
@@ -110,10 +158,20 @@ export async function affordableUsd() {
     const perUsd = BigInt(row.maxAmountRequired || '0');
     if (perUsd <= 0n) continue;
     try {
-      const bal = await client.balanceForAccept?.(row);
-      const raw = typeof bal === 'bigint' ? bal : BigInt(bal?.raw ?? 0);
-      const usd = Number(raw * 1000n / perUsd) / 1000;
-      if (usd > best) best = usd;
+      // SPENDABLE, not merely wrapped. Every quote names the WRAPPER, and the
+      // plain token is converted at payment time (topUpQuotedAsset /
+      // acquireWrappedIfNeeded) — so counting only pre-wrapped balance told a
+      // user holding 14,847 TOKEN that their wallet "covers only $1.0230" and
+      // sent them off to fund an account that was already funded.
+      let usd;
+      if (client.spendableUsdForAccept) {
+        usd = await client.spendableUsdForAccept(row);
+      } else {
+        const bal = await client.balanceForAccept?.(row);
+        const raw = typeof bal === 'bigint' ? bal : BigInt(bal?.raw ?? 0);
+        usd = Number(raw * 1000n / perUsd) / 1000;
+      }
+      if (Number.isFinite(usd) && usd > best) best = usd;
     } catch { /* a rail we cannot read is simply not a candidate */ }
   }
   return best;

package/lib/pay.js

@@ -150,6 +150,66 @@ export class PayClient {
     return BigInt(raw || 0);
   }
 
+  /**
+   * 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.
+   *
+   * 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.
+   */
+  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 buildPaymentFor(accept, onStage) {
     const rail = railOf(accept);
     if (rail === 'solana') {

package/lib/wrap.js

@@ -180,6 +180,19 @@ export async function poolState(connection, pool) {
 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.
   const wrapIx = new TransactionInstruction({
     programId: pool.programId || WRAP_PROGRAM_ID,
     keys: [
@@ -188,16 +201,17 @@ export function buildWrapInstructions({ pool, owner, depositRaw, rentPayer = own
       { pubkey: userWrapped, isSigner: false, isWritable: true },
       { pubkey: pool.authority, isSigner: false, isWritable: false },
       { pubkey: pool.wrappedProgram, isSigner: false, isWritable: false },
+      // the deposit the program will pull, and who authorises it
+      { pubkey: userUnderlying, isSigner: false, isWritable: true },
+      { pubkey: owner, isSigner: true, isWritable: false },
+      { pubkey: pool.underlying, isSigner: false, isWritable: false },
+      { pubkey: pool.underlyingProgram, isSigner: false, isWritable: false },
     ],
     data: Buffer.concat([Buffer.from([1]), u64le(depositRaw), Buffer.from([pool.bump])]),
   });
   return [
     createAssociatedTokenAccountIdempotentInstruction(rentPayer, userWrapped, owner, pool.wrapped, pool.wrappedProgram),
     wrapIx,
-    createTransferCheckedInstruction(
-      userUnderlying, pool.underlying, pool.escrow, owner,
-      depositRaw, pool.underlyingDecimals, [], pool.underlyingProgram,
-    ),
   ];
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.23",
+  "version": "0.48.24",
   "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",