agent402-tollbooth 0.6.0 → 0.6.2

package/edge.js

@@ -130,6 +130,11 @@ export function createEdgeTollbooth(config = {}) {
     powDifficulty,
     secret,
     store,
+    // Same contract as the Node build's verifyX402: (request, requirements) =>
+    // boolean | Promise<boolean>. Without it this build has NO way to accept a
+    // payment, which is why the accepts block below is withheld when it is
+    // absent - see the note there.
+    verifyX402 = null,
     botUserAgents = AI_BOTS,
     // "bots" (default, charge AI crawler UAs) | "all" (charge all but free()) |
     // "strict" (charge anything that isn't a real-browser request). An explicit
@@ -148,6 +153,16 @@ export function createEdgeTollbooth(config = {}) {
     message = "This resource charges automated / AI clients per request. Humans browse free; bots pay in USDC via x402 or by solving a proof-of-work.",
   } = config;
 
+  // Say it at construction, not when a buyer gives up. An operator who sets a
+  // payTo here reasonably believes they are charging; without a verifier this
+  // build can only ever serve proof-of-work, and the price would be fiction.
+  if (payTo && !verifyX402) {
+    console.warn(
+      "agent402-tollbooth: payTo is set but no verifyX402 was supplied, so this edge build cannot accept a USDC payment. " +
+      "The USDC quote is being WITHHELD from the 402 (proof-of-work still works). Pass verifyX402 to charge, or drop payTo to stop implying it."
+    );
+  }
+
   const isBot = makeBotMatcher(botUserAgents);
   const powEngine = pow ? createEdgePow({ secret, difficulty: powDifficulty, store }) : null;
   const mem = memorySink();
@@ -194,6 +209,21 @@ export function createEdgeTollbooth(config = {}) {
     // stays a plain URL for wire compatibility).
     const powResource = `${request.method || "GET"} ${resource}`;
 
+    // An x402 payment presented on either header name. @x402/core emits
+    // PAYMENT-SIGNATURE while older clients send X-PAYMENT, and a gate that
+    // reads only one of them refuses buyers who did everything right.
+    const paymentHeader = request.headers.get("payment-signature") || request.headers.get("x-payment");
+    if (paymentHeader && verifyX402) {
+      let paid = false;
+      try {
+        paid = await verifyX402(request, { price, network, asset, payTo, resource });
+      } catch {
+        // Fail CLOSED: a verifier that throws must not open the gate.
+        paid = false;
+      }
+      if (paid) { incr("paid"); return null; }
+    }
+
     const sol = request.headers.get("x-pow-solution");
     if (powEngine && sol) {
       const r = await powEngine.verify(sol, powResource);
@@ -204,7 +234,12 @@ export function createEdgeTollbooth(config = {}) {
     const body = {
       error: "Payment Required",
       message,
-      accepts: payTo ? [{ scheme: "exact", network, maxAmountRequired: String(price), asset, payTo, resource }] : [],
+      // Only advertise USDC when this build can actually ACCEPT it. Emitting an
+      // accepts block with no verifier configured published a price that no
+      // code path could honour: a crawler that paid correctly was 402'd
+      // forever, money never moved, and the operator believed they were
+      // charging. Quoting a price you cannot take is worse than quoting none.
+      accepts: (payTo && verifyX402) ? [{ scheme: "exact", network, maxAmountRequired: String(price), asset, payTo, resource }] : [],
     };
     if (powEngine) body.proofOfWork = await powEngine.challenge(powResource);
     return new Response(JSON.stringify(body), {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent402-tollbooth",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Open-source, self-hostable x402 pay-per-crawl tollbooth: charge AI bots per request (USDC via x402 — or USDG on Robinhood Chain — or free proof-of-work) while humans browse free. Drop-in Express middleware or reverse proxy — no Cloudflare, no Stripe, no signup.",
   "type": "module",
   "main": "index.js",

package/replay.js

@@ -100,8 +100,61 @@ export function redisReplayStore(client, { prefix = "tollbooth:pow:" } = {}) {
   // mode of guessing wrong is not an exception but a SET without the NX flag,
   // which overwrites the record and grants every replay.
   const isIoredis = typeof client.defineCommand === "function";
+  const isNodeRedis = typeof client.sendCommand === "function" || typeof client.sSet === "function" || Boolean(client.options && client.options.socket);
+  if (!isIoredis && !isNodeRedis) {
+    // Fail CLOSED on an unrecognised client instead of guessing a SET shape.
+    // The failure mode of a wrong guess is not an exception: the flag argument
+    // is silently ignored, the key is overwritten every time, and single-use
+    // stops existing while everything still looks healthy.
+    throw new TypeError(
+      "redisReplayStore(client): could not identify this client as node-redis or ioredis. " +
+      "Pass one of those, or supply your own { claim(token, expiresAtMs) } store - guessing the SET argument shape risks dropping NX and granting every replay."
+    );
+  }
+  // Prove NX is actually being honoured, once, before this store is trusted.
+  // Detection above is a heuristic; this is the observation. Two claims of a
+  // throwaway key must produce a win and then a refusal. Anything else means
+  // single-use is not working, and the store refuses rather than pretending.
+  // Tri-state on PURPOSE: null = not yet observed, true = proven, false = proven
+  // BROKEN and permanently refused.
+  //
+  // A verdict of false must keep throwing on EVERY later call, not just the one
+  // that discovered it. Memoising false and returning it as a resolved value
+  // would make the store refuse exactly once and then grant every replay
+  // forever - the precise failure this self-test exists to prevent, reached one
+  // request later. A caller that solves one challenge could then replay that
+  // token for its whole TTL.
+  //
+  // A probe that THROWS (Redis unreachable) leaves the verdict at null so the
+  // next call re-probes: a transient outage must not be remembered as a verdict.
+  let nxProven = null;
+  const NX_BROKEN =
+    "redisReplayStore: SET NX is not honoured by this client, so proof-of-work single-use cannot be enforced. " +
+    "The gate refuses rather than granting replays. Pass a client whose SET supports NX, or supply your own { claim(token, expiresAtMs) } store.";
+  const proveNx = async () => {
+    if (nxProven === true) return true;
+    if (nxProven === false) throw new Error(NX_BROKEN);
+    const probe = `${prefix}__nxselftest__${Math.random().toString(36).slice(2)}${Date.now()}`;
+    const px = 5000;
+    const set = (k) => (isIoredis ? client.set(k, "1", "PX", px, "NX") : client.set(k, "1", { NX: true, PX: px }));
+    // Deliberately NOT wrapped: a throw here leaves nxProven null (re-probe).
+    const first = await set(probe);
+    const second = await set(probe);
+    const firstWon = first === "OK" || first === true;
+    const secondRefused = !(second === "OK" || second === true);
+    nxProven = firstWon && secondRefused;
+    if (!nxProven) {
+      throw new Error(
+        `${NX_BROKEN} (first claim won: ${firstWon}, second refused: ${secondRefused})`
+      );
+    }
+    return true;
+  };
   return {
     claim: async (token, expiresAtMs) => {
+      // Respect the verdict: proveNx throws when unproven, but assert anyway so
+      // no future refactor can turn "unproven" into a silently ignored value.
+      if ((await proveNx()) !== true) throw new Error(NX_BROKEN);
       const key = prefix + token;
       // Floor of 1ms: Redis rejects a non-positive PX. pow.js has already
       // refused anything actually expired, so a tiny window here just means the