openzoo 0.50.12 → 0.50.13

package/lib/evm.js

@@ -63,6 +63,34 @@ export async function buildEvmPayment({ accept, evmPrivateKey, challenge }) {
     nonce: `0x${crypto.randomBytes(32).toString('hex')}`,
   };
 
+  // WHICH TYPED MESSAGE TO SIGN IS THE ROW'S DECISION, NOT OURS.
+  //
+  // Normal rows are EIP-3009 `TransferWithAuthorization` to the payee. A row
+  // marked `extra.settlement === "atomic"` settles through the gateway's
+  // AtomicSettle contract, which calls `receiveWithAuthorization` — and that
+  // requires msg.sender == to, so the payer must sign
+  // **ReceiveWithAuthorization** with `to` = the CONTRACT.
+  //
+  // The two payloads are IDENTICAL IN SHAPE, so signing the wrong one produces
+  // a payment that passes every local check and reverts on chain. The row tells
+  // us which it wants in `extra.eip3009`; we honour that and never guess.
+  //
+  // What the atomic row buys the payer: settlement happens AFTER the work, so
+  // the on-chain receipt binds the hash of the response they were served AND
+  // the upstream's own COGS transaction — a receipt for the delivery, not just
+  // a record of the debit.
+  const primaryType = accept.extra?.eip3009 === 'ReceiveWithAuthorization'
+    ? 'ReceiveWithAuthorization'
+    : 'TransferWithAuthorization';
+  const authFields = [
+    { name: 'from', type: 'address' },
+    { name: 'to', type: 'address' },
+    { name: 'value', type: 'uint256' },
+    { name: 'validAfter', type: 'uint256' },
+    { name: 'validBefore', type: 'uint256' },
+    { name: 'nonce', type: 'bytes32' },
+  ];
+
   const signature = await account.signTypedData({
     domain: {
       name: accept.extra?.name || 'USDC',
@@ -70,17 +98,8 @@ export async function buildEvmPayment({ accept, evmPrivateKey, challenge }) {
       chainId,
       verifyingContract: accept.asset,
     },
-    types: {
-      TransferWithAuthorization: [
-        { name: 'from', type: 'address' },
-        { name: 'to', type: 'address' },
-        { name: 'value', type: 'uint256' },
-        { name: 'validAfter', type: 'uint256' },
-        { name: 'validBefore', type: 'uint256' },
-        { name: 'nonce', type: 'bytes32' },
-      ],
-    },
-    primaryType: 'TransferWithAuthorization',
+    types: { [primaryType]: authFields },
+    primaryType,
     message: authorization,
   });
 

package/lib/pay.js

@@ -268,6 +268,22 @@ export class PayClient {
     // 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 || {}) };
+    // ASK FOR THE RECEIPT-BEARING ROW.
+    //
+    // The gateway offers an AtomicSettle row on Base only to callers that say
+    // they understand it, because it changes WHICH typed message the payer must
+    // sign (ReceiveWithAuthorization, `to` = the contract) and a client that
+    // signed the standard one would produce a payment that reverts on chain.
+    // buildEvmPayment honours `extra.eip3009`, so this client does understand
+    // it — and what it gets in return is a settlement whose on-chain leaf binds
+    // the hash of the response it was served and the upstream's own COGS
+    // transaction, instead of a bare debit.
+    //
+    // Opt out with OPENZOO_ATOMIC=0 if a gateway ever offers the row and gets
+    // it wrong; the plain rows are always still there.
+    if (process.env.OPENZOO_ATOMIC !== '0') {
+      init = { ...init, headers: { ...(init.headers || {}), 'x-402-atomic': '1' } };
+    }
     const first = await fetchHeaders(url, init);
     if (first.status !== 402) {
       return { response: first, paid: false };

package/lib/x402.js

@@ -178,9 +178,22 @@ export function orderAccepts(body, preferredSymbol, { allowRH = false, forceRail
     const v = Number(a?.extra?.billedUsd);
     return Number.isFinite(v) && v > 0 ? v : Infinity;
   };
+  // AT THE SAME PRICE, TAKE THE ROW THAT COMES WITH A RECEIPT.
+  //
+  // The gateway's AtomicSettle row costs exactly what the plain Base row costs
+  // — it is the same quote, settled through a contract instead of the
+  // facilitator. What it adds is that the on-chain receipt binds the hash of
+  // the response we were served and the upstream's own COGS transaction, so
+  // "what we paid for" stops being something we have to take on trust.
+  //
+  // It is appended last in accepts[], so without this it never wins a tie and
+  // the plain row is always taken. Price still dominates: a cheaper row beats
+  // an atomic one, because a receipt is not worth paying extra for.
+  const atomic = (a) => (a?.extra?.settlement === 'atomic' ? 1 : 0);
+  const rank = (x, y) => priceOf(x) - priceOf(y) || atomic(y) - atomic(x);
   const bySym = (list) => [
-    ...list.filter((a) => a?.extra?.symbol === preferredSymbol),
-    ...list.filter((a) => a?.extra?.symbol !== preferredSymbol).sort((x, y) => priceOf(x) - priceOf(y)),
+    ...list.filter((a) => a?.extra?.symbol === preferredSymbol).sort(rank),
+    ...list.filter((a) => a?.extra?.symbol !== preferredSymbol).sort(rank),
   ];
   if (forceRail) {
     const want = String(forceRail).toLowerCase();

package/lib/xbot.js

@@ -717,6 +717,9 @@ const LOOSE_GATE = process.env.OPENZOO_XBOT_LOOSE_GATE !== '0';
 
 /** Entries that mean work happened and must never repeat. Everything else in
  *  `answered` is a re-derivable judgement — see the note at the skip. */
+/** How long to stay quiet after telling an asker their burner is empty. */
+const PAYWALL_COOLDOWN_MS = Math.max(0, Number(process.env.OPENZOO_XBOT_PAYWALL_COOLDOWN_MS || 30 * 60_000));
+
 const TERMINAL_VERDICTS = new Set(['answered', 'paid', 'paywalled', 'self', 'in_progress', 'failed']);
 
 const SELF_TAG_RE = new RegExp(`@(?:${WATCH_HANDLES.map((h) => h.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')})`, 'gi');
@@ -2642,10 +2645,31 @@ export async function runXBot({ once = false, intervalMs = POLL_MS, dryRun = fal
             saveState(state);
             return;
           }
-          const text = composePaywallReply(t.author_id, t.id, { address: burner.address, returning: Boolean(state.freeUsed[t.author_id]), quotedUsd: quotedUsdFrom(e.message) });
-          console.error(`  ${t.id} @${t.author_id}: PAYWALL → burner ${burner.address}`);
-          await postAndLog({ creds, text, inReplyTo: t.id, state, dryRun, tag: 'paywall', conversationId: t.conversation_id })
-            .catch((err) => console.error(`   reply failed: ${err.message}`));
+          // ONE FUNDING REQUEST, NOT ONE PER MENTION.
+          //
+          // OBSERVED 2026-08-26: six mentions from the same author between
+          // 21:35 and 22:02 produced six IDENTICAL "your burner is out of
+          // funds" replies, addresses and all. Nothing was duplicated — each
+          // was a distinct tweet answered exactly once, and every dedupe guard
+          // worked. The bug is that the answer to "you have no funds" does not
+          // change when you ask again ninety seconds later, so repeating it is
+          // pure noise in the asker's mentions and looks like a broken loop.
+          //
+          // The mention is still CLAIMED either way; the asker just does not
+          // get told twice. Funding is what clears the cooldown — the balance
+          // check on the next question is the real reset, this timer only
+          // stops the shouting in between.
+          const lastPw = Number((state.paywallAt || {})[t.author_id] || 0);
+          const quiet = Date.now() - lastPw < PAYWALL_COOLDOWN_MS;
+          if (quiet) {
+            console.error(`  ${t.id} @${t.author_id}: PAYWALL suppressed (told ${Math.round((Date.now() - lastPw) / 1000)}s ago)`);
+          } else {
+            const text = composePaywallReply(t.author_id, t.id, { address: burner.address, returning: Boolean(state.freeUsed[t.author_id]), quotedUsd: quotedUsdFrom(e.message) });
+            console.error(`  ${t.id} @${t.author_id}: PAYWALL → burner ${burner.address}`);
+            await postAndLog({ creds, text, inReplyTo: t.id, state, dryRun, tag: 'paywall', conversationId: t.conversation_id })
+              .catch((err) => console.error(`   reply failed: ${err.message}`));
+            state.paywallAt = { ...(state.paywallAt || {}), [t.author_id]: Date.now() };
+          }
           state.answered[t.id] = 'paywalled';
         }
         saveState(state);

package/package.json

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