agent402-tollbooth 0.9.2 → 0.10.0

package/README.md

@@ -5,22 +5,17 @@ any site or API: humans browse free, AI crawlers and agents pay per request** -
 in USDC over the [x402 protocol](https://x402.org), over
 [MPP](https://mpp.dev) (the Machine Payments Protocol `Payment` HTTP auth
 scheme, settled through the same stack), or for free by solving a
-proof-of-work. No Cloudflare, no Stripe, no Merchant-of-Record, no signup.
+proof-of-work. No platform lock-in, no card processor required, no Merchant-of-Record, no signup.
 The first self-hostable pay-per-crawl gate that speaks both wires on one 402 -
 the sell side of [Agentic Finance](https://agent402.tools/agentic-finance),
 where agents pay and sites get paid, per request, with no account in between.
 
-The big platforms are converging on the same model: Cloudflare's
-[pay-per-crawl](https://stackoverflow.blog/2026/02/26/how-pay-per-crawl-is-reshaping-data-monetization/)
-and now its [Monetization Gateway](https://blog.cloudflare.com/monetization-gateway/)
-(launched July 2026 - x402 charging in USDC on Base for anything behind Cloudflare:
-pages, APIs, datasets, MCP tools) confirm that pay-per-request is the business model
-of the agentic web. Tollbooth is the **open-source monetization gateway**: the same
-idea, but MIT-licensed and live today, running in
-front of *any* origin (even a Cloudflare Worker), non-custodial (you hold the wallet,
-no signup or Merchant-of-Record), and - the wedge the platform gateways don't offer -
-with a **proof-of-work free tier** so a walletless agent still has a path through.
-Built on the same hardened 402 + proof-of-work machinery as
+Tollbooth is an **open-source monetization gateway**: MIT-licensed, running in
+front of *any* origin (Express, a reverse proxy, Next.js, a Cloudflare Worker),
+non-custodial (you hold the wallet, no signup or Merchant-of-Record), settling
+over x402 and MPP on one 402 - including native MPP on Tempo with split
+payments - and with a **proof-of-work free tier** so a walletless agent still
+has a path through. Built on the same hardened 402 + proof-of-work machinery as
 [Agent402](https://github.com/MikeyPetrillo/Agent402).
 
 ## See it work (one command)
@@ -123,8 +118,7 @@ must pay, or `null` to let it through.
 **Ready-to-deploy templates** (copy a folder, don't assemble from docs):
 
 - **Cloudflare Workers** → [`deploy/cloudflare/`](deploy/cloudflare/) - a ready
-  `wrangler.toml` + a 3-step deploy guide (the open pay-per-crawl, on the
-  incumbent's own platform).
+  `wrangler.toml` + a 3-step deploy guide.
 - **Next.js / Vercel** → [`deploy/nextjs/`](deploy/nextjs/) - a drop-in
   `middleware.js` + a 3-step deploy guide.
 - **Docker** → [`deploy/docker/`](deploy/docker/) - a `Dockerfile` +
@@ -162,8 +156,16 @@ export const config = { matcher: ["/((?!_next/static|_next/image|favicon.ico).*)
 > On the edge, pass a stable `secret` (PoW tokens are HMAC-signed). For
 > single-use replay protection across stateless invocations, supply a `store`
 > (e.g. a Cloudflare KV wrapper - the Worker entry wires this for you).
-> The `x402:` middleware mode and MPP are Node/Express features today; the
-> edge gate offers proof-of-work plus the `verifyX402` callback.
+> The `x402:` middleware mode and the native Tempo rail are Node/Express
+> features; the edge gate offers proof-of-work plus the `verifyX402` callback,
+> and since 0.10.0 **MPP on that same verifier**: with `secret`, `payTo` and
+> `verifyX402` set, every 402 also carries a `WWW-Authenticate: Payment`
+> evm/charge challenge for the quote, and an `Authorization: Payment`
+> credential (HMAC-bound to our challenge, unexpired, minted for that exact
+> resource) is translated to `PAYMENT-SIGNATURE` and handed to `verifyX402` as
+> if an x402 client had sent it. `mpp:false` turns it off; `mppAssetAddress` +
+> `mppAssetName` name a token outside the built-in USDC table (Base, Celo,
+> Polygon, Arbitrum, Optimism, Avalanche, Sei).
 
 ## Accepting USDC: x402 and MPP on the same 402
 
@@ -240,9 +242,21 @@ app.use(createTollbooth({
 }));
 ```
 
+The `tempo` object takes `apiKey` (required), `recipient` (required, your
+Tempo payTo), `currency` or `currencies` (TIP-20 token addresses; default USDC.e
+`0x20C000000000000000000000b9537d11c60E8b50`, one challenge minted per currency,
+first = preferred), `splits` (up to 10, total below the price, same transaction),
+`chainId` (default 4217, Tempo mainnet), `apiBaseUrl` (relay, default
+`https://api.tempo.xyz`), `decimals` (6), `timeoutSeconds` (300), plus the
+confirm knobs below. A bad config throws at construction - the gate never boots
+minting unpayable challenges.
+
 Or from env on the CLI: `TOLLBOOTH_TEMPO_API_KEY`, `TOLLBOOTH_TEMPO_RECIPIENT`
-(defaults to `TOLLBOOTH_PAYTO`), optional `TOLLBOOTH_TEMPO_CURRENCY`,
-`TOLLBOOTH_TEMPO_SPLITS="0xabc:0.0002,0xdef:0.0001"`.
+(defaults to `TOLLBOOTH_PAYTO`), optional `TOLLBOOTH_TEMPO_CURRENCY` (CSV of
+token addresses), `TOLLBOOTH_TEMPO_SPLITS="0xabc:0.0002,0xdef:0.0001"`,
+`TOLLBOOTH_TEMPO_API_BASE` (relay override), `TOLLBOOTH_TEMPO_RPC_URL` (confirm
+RPC override). Tempo works with NO x402 middleware at all (a Tempo-only
+tollbooth) and next to one.
 
 Every 402 then carries a `WWW-Authenticate: Payment` tempo/charge challenge
 (next to any evm challenges from the x402 rail, if you run both); a stock
@@ -293,6 +307,9 @@ live incident transaction in the tests).
 | `mpp` | `true` when `x402` set | Accept MPP (`WWW-Authenticate: Payment` / `Authorization: Payment`) through the `x402` middleware |
 | `mppSecret` | `powSecret` / `TOLLBOOTH_SECRET` | HMAC secret binding MPP challenge ids (stable across workers) |
 | `mppNetworks` | `[8453, 42220]` | EVM chain ids to offer as MPP challenges (`"all"` = every EVM chain the middleware advertises) |
+| `tempo` | env (`TOLLBOOTH_TEMPO_*`) or off | Native MPP on Tempo (0.9.0): `{ apiKey, recipient, currency \| currencies, splits, chainId, apiBaseUrl, decimals, timeoutSeconds, confirm, confirmRpcUrl }` - mints `tempo/charge` challenges, validates with Tempo's relay before the handler, broadcasts after a <400 response. Works with or without `x402` |
+| `tempo.confirm` | `true` | Chain-truth confirm (0.9.2): on a relay broadcast failure, check the chain for the credential's own txid before answering 402; `false` disables |
+| `tempo.confirmRpcUrl` | `https://rpc.tempo.xyz` (`TOLLBOOTH_TEMPO_RPC_URL`) | Tempo JSON-RPC used by the confirm step |
 | `verifyX402(req, opts)` | – | Legacy verify-only USDC check (deprecated for settle-after-handler middlewares; see above) |
 | `resourceBaseUrl` | `""` | Absolute base used for the `resource` field / PoW binding |
 | `observe` | `false` | Observe-only: classify and count, but never 402. For pre-launch traffic measurement. |
@@ -309,11 +326,18 @@ Read by the bundled proxy / Express entry point (`index.js`):
 | `TOLLBOOTH_PAYTO` | – | Wallet address; advertises a USDC x402 quote (and, with `TOLLBOOTH_FACILITATOR_URL`, settles it) |
 | `TOLLBOOTH_FACILITATOR_URL` | – | x402 facilitator that settles your network. With `TOLLBOOTH_PAYTO` the CLI builds a real `@x402/express` middleware and takes payment over x402 **and** MPP (0.8.0). Needs `@x402/express @x402/core @x402/evm` installed; refuses to start without them |
 | `TOLLBOOTH_FACILITATOR_HEADERS` | – | Optional JSON object of auth headers sent on the facilitator's `/verify`, `/settle`, `/supported` (e.g. `{"X-API-Key":"…"}`) |
+| `TOLLBOOTH_CDP_API_KEY_ID` + `TOLLBOOTH_CDP_API_KEY_SECRET` | – | Settle through Coinbase's facilitator (CDP) instead of a URL (no fee is taken from the payment itself; Coinbase's facilitator is free for the first 1,000 settlements a month and $0.001 each after). Needs `npm i @coinbase/x402`. This is how a Coinbase Business account gets paid by agents: `TOLLBOOTH_PAYTO` = the account's USDC (Base) receive address. |
 | `TOLLBOOTH_PRICE` | `"$0.001"` | Advertised price per request |
 | `TOLLBOOTH_NETWORK` | `"base"` | x402 network. CLI settlement mode accepts `base`, `base-sepolia`, `polygon`, `arbitrum`, `optimism`, `avalanche`, `celo`, `sei`, `monad`, or a raw `eip155:<id>` |
 | `TOLLBOOTH_MPP` | on when `x402` set | `false` to switch MPP off |
 | `TOLLBOOTH_MPP_SECRET` | `TOLLBOOTH_SECRET` | HMAC secret for MPP challenge ids |
 | `TOLLBOOTH_MPP_NETWORKS` | `8453,42220` | CSV of EVM chain ids to offer as MPP challenges, or `all` |
+| `TOLLBOOTH_TEMPO_API_KEY` | – | Tempo API key (`mpp:write` scope). Presence switches on the native Tempo rail (0.9.0) |
+| `TOLLBOOTH_TEMPO_RECIPIENT` | `TOLLBOOTH_PAYTO` | Tempo payTo (0x address) |
+| `TOLLBOOTH_TEMPO_CURRENCY` | USDC.e on Tempo | CSV of TIP-20 token addresses to offer (one challenge each, first = preferred) |
+| `TOLLBOOTH_TEMPO_SPLITS` | – | `0xabc:0.0002,0xdef:0.0001` - split recipients + USD amounts paid in the same transaction (≤10, total below the price) |
+| `TOLLBOOTH_TEMPO_API_BASE` | `https://api.tempo.xyz` | Tempo relay base URL override |
+| `TOLLBOOTH_TEMPO_RPC_URL` | `https://rpc.tempo.xyz` | Tempo JSON-RPC for the chain-truth confirm step (0.9.2) |
 | `TOLLBOOTH_ASSET` | `"USDC"` | Asset symbol in the quote (`USDG` charges in USDG on Robinhood Chain) |
 | `TOLLBOOTH_POW_BITS` | `18` | Proof-of-work difficulty in leading zero bits |
 | `TOLLBOOTH_MODE` | `"bots"` | Who pays: `bots` · `all` · `strict` |
@@ -381,7 +405,7 @@ changes. Bots see a `X-Tollbooth-Observed: would-charge` header in observe mode
 ## Analytics
 
 The middleware keeps aggregate counters (no per-request data):
-- `gate.stats()` → sync, in-process mirror: `{ requests, freeAllowed, wouldCharge, charged, powSolved, x402Paid, mppPaid, difficultyNow, observe }`.
+- `gate.stats()` → sync, in-process mirror: `{ requests, freeAllowed, wouldCharge, charged, powSolved, x402Paid, mppPaid, tempoPaid, difficultyNow, observe }`.
 - `gate.snapshot()` → async, reads from the configured durable sink (defaults to memory).
 - `gate.flush()` → flush any buffered deltas to the durable sink (call inside `ctx.waitUntil` on edge runtimes).
 
@@ -585,3 +609,27 @@ Celo by default - what a stock mppx client can sign); add `4663` there or pass
 ## Legal
 
 Use of the hosted instance at agent402.tools is subject to its [Terms of Service](https://agent402.tools/terms) (acceptable-use policy included) and [Privacy Policy](https://agent402.tools/privacy). This package is MIT-licensed; the hosted server is AGPL-3.0. Both are provided as-is without warranty, and self-hosted deployments are their operator's responsibility.
+
+## Get paid into a Coinbase Business account
+
+Coinbase Business accounts receive x402 payments from AI agents directly. The
+tollbooth is the "integrate x402 into your API" step: point `TOLLBOOTH_PAYTO`
+at the account's USDC receive address on Base and settle through Coinbase's
+facilitator with a CDP API key.
+
+```bash
+npm i agent402-tollbooth @x402/express @x402/core @x402/evm @coinbase/x402
+TOLLBOOTH_PAYTO=0xYourCoinbaseBusinessBaseAddress \
+TOLLBOOTH_CDP_API_KEY_ID=... TOLLBOOTH_CDP_API_KEY_SECRET=... \
+TOLLBOOTH_PRICE='$0.005' TOLLBOOTH_UPSTREAM=http://localhost:8080 \
+npx agent402-tollbooth
+```
+
+Load the three values from a `.env` or a secret store rather than typing the
+key on the command line. Live-proven 2026-08-27 with real USDC through
+Coinbase's facilitator ([tx](https://basescan.org/tx/0x8175178ac4e2229dfd9385a3c78c491ffe554b08fdf52cf92f99425c983ec5d1));
+note the facilitator refuses a payer paying itself (`self_send_not_allowed`),
+so test from a second wallet. Every paid request settles as USDC into the Coinbase Business account; humans
+browse your site normally. Full walkthrough with an Express example:
+https://agent402.tools/guides/coinbase-business-get-paid-by-agents
+

package/edge-mpp.js

@@ -0,0 +1,139 @@
+// MPP (Machine Payments Protocol) for the EDGE gate - Web Crypto HMAC, no
+// node:* imports, so it runs where edge.js runs (Cloudflare Workers, Next.js
+// edge middleware, Deno, Bun, Node 20+).
+//
+// Same design as the Node build's mpp.js: settlement authority stays with the
+// operator's x402 verifier, and MPP is pure header translation around it.
+//
+//   OUTBOUND  the gate's USDC quote (price / network / asset / payTo) becomes
+//             ONE HMAC-bound `WWW-Authenticate: Payment` evm/charge challenge
+//             on the 402, next to the JSON `accepts` block the x402 path reads.
+//             The x402-v2-shaped accept it stands for, plus the resource it
+//             was minted for, ride in the challenge's opaque slot so inbound
+//             is stateless and byte-exact.
+//   INBOUND   an `Authorization: Payment` credential whose challenge id
+//             HMAC-verifies, is unexpired and was minted for THIS resource is
+//             re-encoded as an x402 v2 PAYMENT-SIGNATURE and handed to the
+//             SAME verifyX402 callback the x402 path uses - so an operator who
+//             already settles x402 on the edge takes MPP with no new code.
+//
+// Receipts: the edge gate answers null (allow) and never sees the operator's
+// response, so it cannot mirror a Payment-Receipt; `receiptFor(tx)` is
+// exported for an operator whose verifier learns the settlement hash.
+import {
+  META_ACCEPTS_KEY, STABLECOIN_DECIMALS, encodeRequest, challengeIdInput, serializeChallenge, bytesToB64url,
+  decodeCredentialHeader, challengeShapeOk, metaFromChallenge, authorizationFromPayload, paymentSignatureFor, receiptFor,
+} from "./mpp-codec.js";
+export { receiptFor, isMppCredential } from "./mpp-codec.js";
+
+const META_RESOURCE_KEY = "resource";
+const te = new TextEncoder();
+
+/** USDC on the chains the CLI names (same table as CLI_NETWORKS, plus the
+ *  token address and its EIP-712 domain name, which a facilitator needs to
+ *  verify the EIP-3009 signature). Robinhood Chain (USDG) and non-EVM rails
+ *  are not MPP evm/charge targets here. */
+export const EDGE_USDC = {
+  8453: { asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", name: "USD Coin" },
+  42220: { asset: "0xcebA9300f2b948710d2653dD7B07f33A8B32118C", name: "USDC" },
+  137: { asset: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", name: "USD Coin" },
+  42161: { asset: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", name: "USD Coin" },
+  10: { asset: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85", name: "USD Coin" },
+  43114: { asset: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E", name: "USD Coin" },
+  1329: { asset: "0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392", name: "USDC" },
+};
+const CHAIN_BY_NAME = { base: 8453, celo: 42220, polygon: 137, arbitrum: 42161, optimism: 10, avalanche: 43114, sei: 1329 };
+
+/** "base" | "eip155:8453" -> chain id, or null. */
+export function edgeChainId(network) {
+  const n = String(network || "").trim().toLowerCase();
+  if (CHAIN_BY_NAME[n]) return CHAIN_BY_NAME[n];
+  const m = n.match(/^eip155:(\d+)$/);
+  return m ? Number(m[1]) : null;
+}
+
+/** "$0.001" | "0.001" | 0.001 -> base units at 6 decimals ("1000"), or null. */
+export function toBaseUnits(price, decimals = STABLECOIN_DECIMALS) {
+  const s = String(price ?? "").trim().replace(/^\$/, "");
+  if (!/^\d+(\.\d+)?$/.test(s)) return null;
+  const [whole, frac = ""] = s.split(".");
+  if (frac.length > decimals) return null; // sub-unit prices cannot be settled
+  const units = BigInt(whole) * 10n ** BigInt(decimals) + BigInt((frac + "0".repeat(decimals)).slice(0, decimals));
+  return units > 0n ? units.toString() : null;
+}
+
+async function hmacId(secret, c) {
+  const key = await crypto.subtle.importKey("raw", te.encode(String(secret)), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return bytesToB64url(await crypto.subtle.sign("HMAC", key, te.encode(challengeIdInput(c))));
+}
+function constEq(a, b) {
+  if (a.length !== b.length) return false;
+  let r = 0;
+  for (let i = 0; i < a.length; i++) r |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return r === 0;
+}
+
+/**
+ * Mint the gate's one MPP challenge. Returns { header, accepted } or null when
+ * the quote cannot be expressed as evm/charge (unknown chain, non-USDC asset
+ * with no `assetAddress`, unparseable price, no secret).
+ */
+export async function mintEdgeChallenge({ secret, realm, price, network, asset = "USDC", assetAddress, assetName, payTo, resource, ttlSeconds = 300 } = {}) {
+  if (!secret || !realm || !payTo || !resource) return null;
+  const chainId = edgeChainId(network);
+  if (!chainId) return null;
+  const known = EDGE_USDC[chainId];
+  const token = assetAddress || (String(asset).toUpperCase() === "USDC" && known ? known.asset : null);
+  if (!token) return null;
+  const amount = toBaseUnits(price);
+  if (!amount) return null;
+  // Any finite non-zero ttl is honoured (a negative one mints an already-expired
+  // challenge - the refusal path tests use it); 0/unset = 300 s.
+  const ttl = Number.isFinite(Number(ttlSeconds)) && Number(ttlSeconds) !== 0 ? Number(ttlSeconds) : 300;
+  const accepted = {
+    scheme: "exact",
+    network: `eip155:${chainId}`,
+    amount,
+    asset: token,
+    payTo,
+    maxTimeoutSeconds: ttl,
+    extra: { name: assetName || (assetAddress ? String(asset) : known.name), version: "2" },
+  };
+  const c = {
+    realm,
+    method: "evm",
+    intent: "charge",
+    request: encodeRequest({
+      amount,
+      currency: token,
+      recipient: payTo,
+      methodDetails: { chainId, credentialTypes: ["authorization"], decimals: STABLECOIN_DECIMALS },
+    }),
+    expires: new Date(Date.now() + ttl * 1000).toISOString(),
+    opaque: encodeRequest({ [META_ACCEPTS_KEY]: JSON.stringify(accepted), [META_RESOURCE_KEY]: resource }),
+  };
+  c.id = await hmacId(secret, c);
+  return { header: serializeChallenge(c), accepted };
+}
+
+/**
+ * Validate an MPP credential against our HMAC binding and re-encode it as an
+ * x402 v2 PAYMENT-SIGNATURE value. Returns { paymentSignature, accepted,
+ * authorization, signature, resource } or null for anything that is not a
+ * valid, unexpired, HMAC-bound evm/charge credential of ours.
+ */
+export async function translateEdgeCredential(authorizationHeader, { secret } = {}) {
+  if (!secret) return null;
+  const wire = decodeCredentialHeader(authorizationHeader);
+  const ch = wire?.challenge;
+  if (!challengeShapeOk(ch)) return null;
+  if (!constEq(String(ch.id), await hmacId(secret, ch))) return null;
+  if (ch.expires && !(Date.parse(ch.expires) > Date.now())) return null;
+  const meta = metaFromChallenge(ch);
+  let accepted;
+  try { accepted = JSON.parse(meta[META_ACCEPTS_KEY]); } catch { return null; }
+  if (!accepted || typeof accepted !== "object") return null;
+  const auth = authorizationFromPayload(wire.payload);
+  if (!auth) return null;
+  return { paymentSignature: paymentSignatureFor(accepted, auth), accepted, ...auth, resource: typeof meta[META_RESOURCE_KEY] === "string" ? meta[META_RESOURCE_KEY] : null };
+}

package/edge.js

@@ -8,6 +8,7 @@
 // See worker.js for a Cloudflare Worker entry, and the README for Next.js.
 import { makeBotMatcher, AI_BOTS } from "./bots.js";
 import { memorySink } from "./sinks.js";
+import { mintEdgeChallenge, translateEdgeCredential, isMppCredential } from "./edge-mpp.js";
 
 export { memorySink, kvStatsSink, httpStatsSink } from "./sinks.js";
 
@@ -135,6 +136,17 @@ export function createEdgeTollbooth(config = {}) {
     // payment, which is why the accepts block below is withheld when it is
     // absent - see the note there.
     verifyX402 = null,
+    // MPP (the "Payment" HTTP auth scheme) on the same verifier: default ON
+    // whenever the USDC quote is live (payTo + verifyX402 + secret). The 402
+    // gains a WWW-Authenticate: Payment challenge and an Authorization: Payment
+    // credential is translated to PAYMENT-SIGNATURE and handed to verifyX402.
+    // See edge-mpp.js. `mppAssetAddress`/`mppAssetName` name a token the
+    // built-in USDC table does not know (the domain name is what a facilitator
+    // verifies the EIP-3009 signature under).
+    mpp = true,
+    mppAssetAddress,
+    mppAssetName,
+    mppRealm,
     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
@@ -163,6 +175,7 @@ export function createEdgeTollbooth(config = {}) {
     );
   }
 
+  const mppOn = Boolean(mpp && secret && payTo && verifyX402);
   const isBot = makeBotMatcher(botUserAgents);
   const powEngine = pow ? createEdgePow({ secret, difficulty: powDifficulty, store }) : null;
   const mem = memorySink();
@@ -222,6 +235,23 @@ export function createEdgeTollbooth(config = {}) {
         paid = false;
       }
       if (paid) { incr("paid"); return null; }
+    } else if (mppOn && isMppCredential(request.headers.get("authorization"))) {
+      // MPP inbound: only a credential whose challenge id HMAC-verifies as
+      // OURS, unexpired, and minted for THIS resource (a credential for /a
+      // must not pay for /b - the challenge carries the resource it was minted
+      // for). The verifier sees the same request with PAYMENT-SIGNATURE in
+      // place of Authorization, exactly as an x402 client would have sent it.
+      let paid = false;
+      try {
+        const t = await translateEdgeCredential(request.headers.get("authorization"), { secret });
+        if (t && t.resource === resource) {
+          const headers = new Headers(request.headers);
+          headers.set("payment-signature", t.paymentSignature);
+          headers.delete("authorization");
+          paid = await verifyX402(new Request(request, { headers }), { price, network, asset, payTo, resource, accepted: t.accepted });
+        }
+      } catch { paid = false; }
+      if (paid) { incr("paid"); incr("mppPaid"); return null; }
     }
 
     const sol = request.headers.get("x-pow-solution");
@@ -242,10 +272,16 @@ export function createEdgeTollbooth(config = {}) {
       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), {
-      status: 402,
-      headers: { "content-type": "application/json", "x-tollbooth": "pay-per-crawl" },
-    });
+    const headers = { "content-type": "application/json", "x-tollbooth": "pay-per-crawl" };
+    if (mppOn) {
+      // One evm/charge challenge for the gate's quote (never a price the
+      // x402 path would not honour - both are built from the same fields).
+      try {
+        const minted = await mintEdgeChallenge({ secret, realm: mppRealm || u.host, price, network, asset, assetAddress: mppAssetAddress, assetName: mppAssetName, payTo, resource });
+        if (minted) headers["www-authenticate"] = minted.header;
+      } catch { /* a quote MPP cannot express is still a valid x402 402 */ }
+    }
+    return new Response(JSON.stringify(body), { status: 402, headers });
   }
 
   // Operator surface: in-process mirror (sync), durable snapshot (async),

package/index.js

@@ -98,6 +98,8 @@ const STRIP_INBOUND = new Set([
   "host", "connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
   "te", "trailer", "transfer-encoding", "upgrade", "content-length",
   "x-tollbooth-paid", "x-tollbooth-error", "x-pow-error", "x-forwarded-host", "forwarded",
+  // client-IP / scheme trust headers an upstream might honour (spoofable by the bot)
+  "x-real-ip", "cf-connecting-ip", "true-client-ip", "x-client-ip", "fastly-client-ip", "x-forwarded-proto", "x-forwarded-port", "via",
 ]);
 
 /**
@@ -686,9 +688,17 @@ export const CLI_NETWORKS = {
 export async function buildCliX402Middleware(env = process.env) {
   const payTo = env.TOLLBOOTH_PAYTO || "";
   const facilitatorUrl = env.TOLLBOOTH_FACILITATOR_URL || "";
+  // Coinbase's facilitator (CDP) authenticates every verify/settle call with
+  // a short-lived JWT signed by a CDP API key, so a static header cannot
+  // reach it; @coinbase/x402's createFacilitatorConfig mints them. With the
+  // two keys set the CLI settles through CDP (no fee is taken from the
+  // payment; CDP's own free tier is 1,000 settlements a month, then $0.001
+  // each), no URL needed. This is
+  // the path a Coinbase Business account uses to get paid by agents.
+  const cdpKeys = env.TOLLBOOTH_CDP_API_KEY_ID && env.TOLLBOOTH_CDP_API_KEY_SECRET;
   if (!payTo) return null;
-  if (!facilitatorUrl) {
-    console.warn("⚠ TOLLBOOTH_PAYTO is set without TOLLBOOTH_FACILITATOR_URL: the 402 advertises a USDC quote but nothing here can verify or settle a payment, so every paid request is refused. Set TOLLBOOTH_FACILITATOR_URL (a public x402 facilitator that settles your network - keyless free tiers exist; https://x402.org/facilitator for base-sepolia) to actually charge, over x402 and MPP.");
+  if (!facilitatorUrl && !cdpKeys) {
+    console.warn("⚠ TOLLBOOTH_PAYTO is set without TOLLBOOTH_FACILITATOR_URL (or TOLLBOOTH_CDP_API_KEY_ID/SECRET): the 402 advertises a USDC quote but nothing here can verify or settle a payment, so every paid request is refused. Set TOLLBOOTH_FACILITATOR_URL (a public x402 facilitator that settles your network - keyless free tiers exist; https://x402.org/facilitator for base-sepolia) to actually charge, over x402 and MPP.");
     return null;
   }
   const asset = (env.TOLLBOOTH_ASSET || "USDC").toUpperCase();
@@ -708,7 +718,7 @@ export async function buildCliX402Middleware(env = process.env) {
     ({ HTTPFacilitatorClient, x402ResourceServer } = await import("@x402/core/server"));
     ({ ExactEvmScheme } = await import("@x402/evm/exact/server"));
   } catch (e) {
-    console.error(`✖ TOLLBOOTH_FACILITATOR_URL is set, so this gate must settle x402 payments, but the x402 packages are not installed (${String(e?.message || e).slice(0, 120)}). Install them next to agent402-tollbooth: npm i @x402/express @x402/core @x402/evm . Refusing to start rather than advertise a quote it cannot settle.`);
+    console.error(`✖ TOLLBOOTH_FACILITATOR_URL or TOLLBOOTH_CDP_API_KEY_ID/SECRET is set, so this gate must settle x402 payments, but the x402 packages are not installed (${String(e?.message || e).slice(0, 120)}). Install them next to agent402-tollbooth: npm i @x402/express @x402/core @x402/evm . Refusing to start rather than advertise a quote it cannot settle.`);
     process.exit(1);
   }
   // Optional facilitator auth headers, sent on /verify, /settle and /supported
@@ -717,7 +727,26 @@ export async function buildCliX402Middleware(env = process.env) {
   if (env.TOLLBOOTH_FACILITATOR_HEADERS) {
     try { authHeaders = JSON.parse(env.TOLLBOOTH_FACILITATOR_HEADERS); } catch { console.error("✖ TOLLBOOTH_FACILITATOR_HEADERS must be a JSON object of header name -> value. Refusing to start."); process.exit(1); }
   }
-  const client = new HTTPFacilitatorClient({
+  let cdpConfig = null;
+  if (cdpKeys) {
+    if (facilitatorUrl || authHeaders) console.warn("⚠ TOLLBOOTH_CDP_API_KEY_ID/SECRET are set, so TOLLBOOTH_FACILITATOR_URL / TOLLBOOTH_FACILITATOR_HEADERS are ignored: settlement goes through Coinbase's facilitator.");
+    let createFacilitatorConfig;
+    try { ({ createFacilitatorConfig } = await import("@coinbase/x402")); } catch (e) {
+      console.error(`✖ TOLLBOOTH_CDP_API_KEY_ID/SECRET are set, so this gate must settle through Coinbase's facilitator, but @coinbase/x402 is not installed (${String(e?.message || e).slice(0, 120)}). Install it: npm install @coinbase/x402`);
+      process.exit(1);
+    }
+    cdpConfig = createFacilitatorConfig(env.TOLLBOOTH_CDP_API_KEY_ID, env.TOLLBOOTH_CDP_API_KEY_SECRET);
+    // Prove the key can sign BEFORE claiming to settle: createFacilitatorConfig
+    // validates nothing, and a key that cannot mint a JWT would otherwise boot
+    // "settling via Coinbase CDP" and answer every paid request 500 (nobody
+    // charged, every agent turned away). Minting one JWT is local, no network.
+    try { await cdpConfig.createAuthHeaders(); } catch (e) {
+      const why = String(e?.message || e).replace(env.TOLLBOOTH_CDP_API_KEY_SECRET, "<secret>").slice(0, 160);
+      console.error(`✖ TOLLBOOTH_CDP_API_KEY_SECRET cannot sign a facilitator request (${why}). Check the CDP API key secret; nothing is being charged.`);
+      process.exit(1);
+    }
+  }
+  const client = new HTTPFacilitatorClient(cdpConfig || {
     url: facilitatorUrl,
     ...(authHeaders ? { createAuthHeaders: async () => ({ verify: authHeaders, settle: authHeaders, supported: authHeaders }) } : {}),
   });
@@ -856,12 +885,29 @@ async function startCli() {
   } else {
     app.use((_req, res) => res.json({ ok: true, note: "Bare tollbooth gate (no TOLLBOOTH_UPSTREAM set). Clients that reach here paid or solved a proof-of-work." }));
   }
-  app.listen(port, () => {
-    const paidLabel = x402mw ? `x402 + MPP (${process.env.TOLLBOOTH_ASSET || "USDC"}, settling via ${process.env.TOLLBOOTH_FACILITATOR_URL})` : (process.env.TOLLBOOTH_PAYTO ? `x402 quote only (${process.env.TOLLBOOTH_ASSET || "USDC"}, NOT settling - set TOLLBOOTH_FACILITATOR_URL)` : "");
+  const server = app.listen(port, () => {
+    const paidLabel = x402mw ? `x402 + MPP (${process.env.TOLLBOOTH_ASSET || "USDC"}, settling via ${process.env.TOLLBOOTH_CDP_API_KEY_ID && process.env.TOLLBOOTH_CDP_API_KEY_SECRET ? "Coinbase CDP" : process.env.TOLLBOOTH_FACILITATOR_URL})` : (process.env.TOLLBOOTH_PAYTO ? `x402 quote only (${process.env.TOLLBOOTH_ASSET || "USDC"}, NOT settling - set TOLLBOOTH_FACILITATOR_URL)` : "");
     const rails = [gate.pow ? "proof-of-work" : "", paidLabel].filter(Boolean).join(" + ");
-    console.log(`agent402-tollbooth listening on :${port} — charging AI bots via ${rails || "proof-of-work"}`);
+    // The BOUND port, so PORT=0 (let the OS pick) prints something a caller can use.
+    const bound = server.address()?.port ?? port;
+    console.log(`agent402-tollbooth listening on :${bound} — charging AI bots via ${rails || "proof-of-work"}`);
     if (upstream) console.log(`  proxying → ${upstream}`);
   });
+  // Evidence for a process that leaves without being told to. Four times
+  // (2026-08-19, 08-22, 08-26, 08-27; CI only, never locally) the CLI printed the
+  // banner above and then exited 0 with no signal and no --trace-exit stack: the
+  // event loop drained under a LISTENING server, which should be impossible while
+  // the handle is ref'd. `beforeExit` is the one hook that fires exactly then;
+  // naming the live handles and the server's own state at that instant is the
+  // record every earlier occurrence lacked. Costs nothing in a healthy process
+  // (it never fires while the server listens).
+  server.on("close", () => console.error("[agent402-tollbooth] http server closed"));
+  server.on("error", (e) => console.error(`[agent402-tollbooth] http server error: ${e?.code || ""} ${e?.message || e}`));
+  process.on("beforeExit", (code) => {
+    let active = "?";
+    try { active = JSON.stringify(process.getActiveResourcesInfo()); } catch { /* older node */ }
+    console.error(`[agent402-tollbooth] event loop drained (exit code ${code}) while listening=${server.listening} address=${JSON.stringify(server.address())} active=${active}`);
+  });
 }
 
 if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) startCli();

package/mpp-codec.js

@@ -0,0 +1,139 @@
+// MPP wire codec shared by the Node build (mpp.js, HMAC via node:crypto) and
+// the edge build (edge-mpp.js, HMAC via Web Crypto). Runtime-agnostic on
+// purpose: no node:* imports, no Buffer - only TextEncoder/TextDecoder,
+// btoa/atob, which every Fetch-API runtime (Workers, Next.js edge, Deno, Bun,
+// Node 20+) provides. Nothing in here signs or verifies; the two builds own
+// that, so this file cannot mint a challenge on its own.
+//
+// Wire (tempoxyz/mpp, paymentauth.org):
+//   challenge   WWW-Authenticate: Payment id="...", realm="...", method="evm",
+//               intent="charge", request="<b64url JCS>", expires="...", opaque="<b64url JCS>"
+//   credential  Authorization: Payment <b64url JSON{challenge, payload, source?}>
+//   receipt     Payment-Receipt: <b64url JSON{method, status, reference, timestamp}>
+export const SCHEME = "Payment";
+export const META_ACCEPTS_KEY = "x402";
+export const STABLECOIN_DECIMALS = 6; // Circle USDC + Paxos USDG on every EVM rail
+// What a stock mppx client can auto-sign (its built-in asset registry covers
+// Base + Celo mainnets); every extra challenge costs ~800 bytes on every 402.
+export const DEFAULT_MPP_CHAIN_IDS = [8453, 42220];
+
+const te = new TextEncoder();
+const td = new TextDecoder();
+function bytesToBinary(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i += 0x8000) s += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000));
+  return s;
+}
+const binaryToBytes = (bin) => Uint8Array.from(bin, (c) => c.charCodeAt(0));
+/** utf8 string -> standard base64 */
+export const b64std = (s) => btoa(bytesToBinary(te.encode(String(s))));
+/** standard base64 -> utf8 string (throws on junk) */
+export const unb64std = (s) => td.decode(binaryToBytes(atob(String(s).replace(/-/g, "+").replace(/_/g, "/").replace(/\s+/g, ""))));
+/** utf8 string -> base64url (no padding) */
+export const b64url = (s) => b64std(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+/** base64url -> utf8 string (padding optional; throws on junk) */
+export function unb64url(s) {
+  let v = String(s).replace(/-/g, "+").replace(/_/g, "/");
+  while (v.length % 4) v += "=";
+  return td.decode(binaryToBytes(atob(v)));
+}
+/** bytes -> base64url, for HMAC digests */
+export const bytesToB64url = (bytes) => btoa(bytesToBinary(new Uint8Array(bytes))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+
+/** RFC 8785-style canonical JSON (sorted object keys, no whitespace) - what the
+ *  reference implementation uses for the `request`/`opaque` slots. */
+export function canonicalJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const keys = Object.keys(value).filter((k) => value[k] !== undefined).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`).join(",")}}`;
+}
+export const encodeRequest = (obj) => b64url(canonicalJson(obj));
+
+/** Positional id-binding input - the same slot layout the reference
+ *  implementation HMACs, so its Challenge.verify() agrees with ours given the
+ *  same secret. The builds sign this string. */
+export const challengeIdInput = (c) =>
+  [c.realm, c.method, c.intent, c.request, c.expires ?? "", c.digest ?? "", c.opaque ?? ""].join("|");
+
+export const authParam = (name, value) => {
+  const v = String(value);
+  if (/[\r\n]/.test(v)) throw new Error("invalid auth-param value");
+  return `${name}="${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+};
+
+/** One serialized challenge (the caller has already set `c.id`). */
+export function serializeChallenge(c) {
+  return `${SCHEME} ` + [
+    authParam("id", c.id), authParam("realm", c.realm), authParam("method", c.method), authParam("intent", c.intent),
+    authParam("request", c.request), authParam("expires", c.expires), authParam("opaque", c.opaque),
+  ].join(", ");
+}
+
+/** The evm/charge request slot for one x402-shaped accept. */
+export function chargeRequestFor({ amount, asset, chainId }) {
+  return encodeRequest({
+    amount: String(amount),
+    currency: asset,
+    // `recipient` is filled by the caller's accept; kept explicit there.
+    methodDetails: { chainId, credentialTypes: ["authorization"], decimals: STABLECOIN_DECIMALS },
+  });
+}
+
+/** True when the header looks like an MPP credential (scheme check only). */
+export function isMppCredential(authorizationHeader) {
+  return typeof authorizationHeader === "string" && /^Payment\s+\S/i.test(authorizationHeader);
+}
+
+/** Decode `Authorization: Payment <b64url JSON>` to its wire object, or null. */
+export function decodeCredentialHeader(authorizationHeader) {
+  if (typeof authorizationHeader !== "string") return null;
+  const m = authorizationHeader.match(/^Payment\s+([A-Za-z0-9_-]+=*)\s*$/i);
+  if (!m) return null;
+  try { return JSON.parse(unb64url(m[1])); } catch { return null; }
+}
+
+/** Shape-check an evm/charge challenge object from a credential (no HMAC here). */
+export function challengeShapeOk(ch) {
+  return !!ch && typeof ch === "object" && ch.method === "evm" && ch.intent === "charge"
+    && typeof ch.request === "string" && typeof ch.opaque === "string" && typeof ch.id === "string";
+}
+
+/** The meta object bound into the challenge's opaque slot, or null. */
+export function metaFromChallenge(ch) {
+  try {
+    const meta = JSON.parse(unb64url(ch.opaque));
+    return meta && typeof meta === "object" ? meta : null;
+  } catch { return null; }
+}
+
+const HEX_ADDR = /^0x[0-9a-fA-F]{40}$/;
+const HEX_32 = /^0x[0-9a-fA-F]{64}$/;
+const HEX_SIG = /^0x[0-9a-fA-F]+$/;
+const UINT = /^\d+$/;
+/** Validate an `authorization` payload; returns {authorization, signature} or null. */
+export function authorizationFromPayload(p) {
+  if (!p || p.type !== "authorization") return null;
+  const { from, to, value, validAfter, validBefore, nonce, signature } = p;
+  if (!HEX_ADDR.test(String(from)) || !HEX_ADDR.test(String(to)) || !HEX_32.test(String(nonce)) || !HEX_SIG.test(String(signature))) return null;
+  if (!UINT.test(String(value)) || !UINT.test(String(validAfter)) || !UINT.test(String(validBefore))) return null;
+  return { authorization: { from, to, value: String(value), validAfter: String(validAfter), validBefore: String(validBefore), nonce }, signature };
+}
+
+/** x402 v2 PAYMENT-SIGNATURE value (standard base64 JSON) for an accept + authorization. */
+export function paymentSignatureFor(accepted, { authorization, signature }) {
+  return b64std(JSON.stringify({ x402Version: 2, accepted, payload: { authorization, signature } }));
+}
+
+/** MPP Payment-Receipt value for a settled transaction reference. */
+export function receiptFor(transaction) {
+  return b64url(JSON.stringify({ method: "evm", status: "success", reference: transaction, timestamp: new Date().toISOString() }));
+}
+
+/** Decode a settled x402 PAYMENT-RESPONSE header to its transaction, or null. */
+export function transactionFromPaymentResponse(paymentResponseHeader) {
+  let settle;
+  try { settle = JSON.parse(unb64std(paymentResponseHeader)); } catch { return null; }
+  if (!settle || settle.success !== true || typeof settle.transaction !== "string") return null;
+  return settle.transaction;
+}

package/mpp.js

@@ -29,47 +29,28 @@
 // reference client is proven by scripts/test-tollbooth-mpp.js in the parent
 // repo, which drives a REAL mppx client through this codec.
 import { createHmac, timingSafeEqual } from "node:crypto";
+import {
+  META_ACCEPTS_KEY, STABLECOIN_DECIMALS, DEFAULT_MPP_CHAIN_IDS, b64url, unb64url, b64std, unb64std,
+  canonicalJson, encodeRequest, challengeIdInput, serializeChallenge, decodeCredentialHeader, challengeShapeOk,
+  metaFromChallenge, authorizationFromPayload, paymentSignatureFor, receiptFor, transactionFromPaymentResponse,
+} from "./mpp-codec.js";
 
-const SCHEME = "Payment";
-const META_ACCEPTS_KEY = "x402";
-const STABLECOIN_DECIMALS = 6; // Circle USDC + Paxos USDG on every EVM rail
-// What a stock mppx client can auto-sign (its built-in asset registry covers
-// Base + Celo mainnets); every extra challenge costs ~800 bytes on every 402.
-export const DEFAULT_MPP_CHAIN_IDS = [8453, 42220];
-
-// ---- encoding primitives ---------------------------------------------------
-export const b64url = (s) => Buffer.from(s, "utf8").toString("base64url");
-export const unb64url = (s) => Buffer.from(String(s), "base64url").toString("utf8");
-const b64std = (s) => Buffer.from(s, "utf8").toString("base64");
-const unb64std = (s) => Buffer.from(String(s), "base64").toString("utf8");
-
-/** RFC 8785-style canonical JSON (sorted object keys, no whitespace) - what the
- *  reference implementation uses for the `request`/`opaque` slots. */
-export function canonicalJson(value) {
-  if (value === null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-  const keys = Object.keys(value).filter((k) => value[k] !== undefined).sort();
-  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`).join(",")}}`;
-}
-const encodeRequest = (obj) => b64url(canonicalJson(obj));
+// The wire primitives live in mpp-codec.js (runtime-agnostic, shared with the
+// edge build); this file adds the node:crypto HMAC binding on top.
+export { DEFAULT_MPP_CHAIN_IDS, b64url, unb64url, canonicalJson };
+export { isMppCredential } from "./mpp-codec.js";
 
 // Positional HMAC binding of the challenge id - the same slot layout the
 // reference implementation uses, so its Challenge.verify() agrees with ours
 // given the same secret (handy in tests; the spec only requires that WE bind).
 function challengeId(secretKey, c) {
-  const input = [c.realm, c.method, c.intent, c.request, c.expires ?? "", c.digest ?? "", c.opaque ?? ""].join("|");
-  return createHmac("sha256", Buffer.from(secretKey, "utf8")).update(input, "utf8").digest("base64url");
+  return createHmac("sha256", Buffer.from(secretKey, "utf8")).update(challengeIdInput(c), "utf8").digest("base64url");
 }
 function idMatches(secretKey, c) {
   const a = Buffer.from(String(c.id || ""), "utf8");
   const b = Buffer.from(challengeId(secretKey, c), "utf8");
   return a.length === b.length && timingSafeEqual(a, b);
 }
-const authParam = (name, value) => {
-  const v = String(value);
-  if (/[\r\n]/.test(v)) throw new Error("invalid auth-param value");
-  return `${name}="${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-};
 
 // ---- OUTBOUND: PAYMENT-REQUIRED -> WWW-Authenticate: Payment ---------------
 /**
@@ -110,67 +91,37 @@ export function challengesFromPaymentRequired(paymentRequiredHeader, { secretKey
       opaque: encodeRequest({ [META_ACCEPTS_KEY]: JSON.stringify(a) }),
     };
     c.id = challengeId(secretKey, c);
-    out.push([
-      authParam("id", c.id), authParam("realm", c.realm), authParam("method", c.method), authParam("intent", c.intent),
-      authParam("request", c.request), authParam("expires", c.expires), authParam("opaque", c.opaque),
-    ].join(", "));
+    out.push(serializeChallenge(c));
   }
   if (!out.length) return null;
-  return out.map((p) => `${SCHEME} ${p}`).join(", ");
+  return out.join(", ");
 }
 
 // ---- INBOUND: Authorization: Payment -> PAYMENT-SIGNATURE ------------------
-const HEX_ADDR = /^0x[0-9a-fA-F]{40}$/;
-const HEX_32 = /^0x[0-9a-fA-F]{64}$/;
-const HEX_SIG = /^0x[0-9a-fA-F]+$/;
-const UINT = /^\d+$/;
-
 /**
  * Validate an MPP credential against our HMAC binding and re-encode it as an
  * x402 v2 PAYMENT-SIGNATURE value. Returns null for anything that is not a
  * valid, unexpired, HMAC-bound evm/charge credential of ours.
  */
 export function translateCredential(authorizationHeader, { secretKey } = {}) {
-  if (!secretKey || typeof authorizationHeader !== "string") return null;
-  const m = authorizationHeader.match(/^Payment\s+([A-Za-z0-9_-]+=*)\s*$/i);
-  if (!m) return null;
-  let wire;
-  try { wire = JSON.parse(unb64url(m[1])); } catch { return null; }
+  if (!secretKey) return null;
+  const wire = decodeCredentialHeader(authorizationHeader);
   const ch = wire?.challenge;
-  if (!ch || typeof ch !== "object") return null;
-  if (ch.method !== "evm" || ch.intent !== "charge") return null;
-  if (typeof ch.request !== "string" || typeof ch.opaque !== "string") return null;
+  if (!challengeShapeOk(ch)) return null;
   // HMAC binding (spec: servers MUST bind ids to challenge params). This also
   // proves the echoed accepts entry in opaque is ours and untampered.
   if (!idMatches(secretKey, ch)) return null;
   if (ch.expires && !(Date.parse(ch.expires) > Date.now())) return null;
   let accepted;
-  try {
-    const meta = JSON.parse(unb64url(ch.opaque));
-    accepted = JSON.parse(meta[META_ACCEPTS_KEY]);
-  } catch { return null; }
+  try { accepted = JSON.parse(metaFromChallenge(ch)[META_ACCEPTS_KEY]); } catch { return null; }
   if (!accepted || typeof accepted !== "object") return null;
-  const p = wire.payload;
-  if (!p || p.type !== "authorization") return null;
-  const { from, to, value, validAfter, validBefore, nonce, signature } = p;
-  if (!HEX_ADDR.test(String(from)) || !HEX_ADDR.test(String(to)) || !HEX_32.test(String(nonce)) || !HEX_SIG.test(String(signature))) return null;
-  if (!UINT.test(String(value)) || !UINT.test(String(validAfter)) || !UINT.test(String(validBefore))) return null;
-  return b64std(JSON.stringify({
-    x402Version: 2,
-    accepted,
-    payload: { authorization: { from, to, value: String(value), validAfter: String(validAfter), validBefore: String(validBefore), nonce }, signature },
-  }));
+  const auth = authorizationFromPayload(wire.payload);
+  if (!auth) return null;
+  return paymentSignatureFor(accepted, auth);
 }
 
 // ---- RECEIPT: PAYMENT-RESPONSE -> Payment-Receipt -------------------------
 export function receiptFromPaymentResponse(paymentResponseHeader) {
-  let settle;
-  try { settle = JSON.parse(unb64std(paymentResponseHeader)); } catch { return null; }
-  if (!settle || settle.success !== true || typeof settle.transaction !== "string") return null;
-  return b64url(JSON.stringify({ method: "evm", status: "success", reference: settle.transaction, timestamp: new Date().toISOString() }));
-}
-
-/** True when the header looks like an MPP credential (scheme check only). */
-export function isMppCredential(authorizationHeader) {
-  return typeof authorizationHeader === "string" && /^Payment\s+\S/i.test(authorizationHeader);
+  const tx = transactionFromPaymentResponse(paymentResponseHeader);
+  return tx ? receiptFor(tx) : null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent402-tollbooth",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Agent402 tollbooth: open-source, self-hostable pay-per-crawl for x402 AND MPP (the sell side of Agentic Finance): charge AI bots per request (USDC via x402, or MPP - the Machine Payments Protocol - through the same settlement, or USDG on Robinhood Chain, or free proof-of-work) while humans browse free. Drop-in Express middleware or reverse proxy that settles both wires from env alone - no Cloudflare, no Stripe, no signup.",
   "type": "module",
   "main": "index.js",
@@ -18,7 +18,10 @@
     "./replay": "./replay.js",
     "./replay.js": "./replay.js",
     "./mpp": "./mpp.js",
-    "./mpp.js": "./mpp.js"
+    "./mpp.js": "./mpp.js",
+    "./edge-mpp": "./edge-mpp.js",
+    "./edge-mpp.js": "./edge-mpp.js",
+    "./mpp-codec.js": "./mpp-codec.js"
   },
   "files": [
     "index.js",
@@ -27,6 +30,8 @@
     "bots.js",
     "pow.js",
     "mpp.js",
+    "mpp-codec.js",
+    "edge-mpp.js",
     "tempo.js",
     "dashboard.js",
     "sinks.js",
@@ -47,11 +52,15 @@
     "express": "^5.0.0"
   },
   "peerDependencies": {
+    "@coinbase/x402": ">=2.0.0",
     "@x402/core": ">=2.0.0",
     "@x402/evm": ">=2.0.0",
     "@x402/express": ">=2.0.0"
   },
   "peerDependenciesMeta": {
+    "@coinbase/x402": {
+      "optional": true
+    },
     "@x402/core": {
       "optional": true
     },