@wafermapxyz/cli 0.4.3 → 0.4.5

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.4.5 (2 Nov 2026)
+
+**Pay Wafermap in $WAFERMAP, at 50% off. The tokens are burned.**
+
+- `wafermap call <id> --pay wafermap` (MCP `wafermap_call` with `payIn: "wafermap"`, SDK `call(id, input, { payIn: "wafermap" })`) pays one of Wafermap's own resources in $WAFERMAP instead of USDG/USDC. $WAFERMAP has no EIP-3009, so the payment is a Uniswap Permit2 signature for one exact amount, spendable for two minutes only by Wafermap's relayer, which sends it to the dead address once the call succeeded. A failed call moves nothing.
+- `wafermap approve-wafermap`: the one-time Permit2 approval (one Robinhood Chain transaction, paid in ETH).
+- What the client checks before it signs, trusting the server for none of it: the spender is Wafermap's relayer as fixed in this release (`WAFERMAP_RELAYERS`); the option names the canonical Permit2, the $WAFERMAP token and the dead address; the amount is valued at a price this client reads itself (GeckoTerminal) and refused when it is worth more than the quote states. The caps count the higher of the two values.
+- Only `call()` to Wafermap ever signs a $WAFERMAP permit. `pay()` to third-party services never does, whatever they offer, because a Permit2 spender chooses where the tokens go.
+
+## 0.4.4 (2 Nov 2026)
+
+**$WAFERMAP holder tiers.**
+
+- **Pro free calls.** A wallet holding 1,000,000 $WAFERMAP on Robinhood Chain gets 10 free calls a day (UTC) to Wafermap resources listed at $0.01 or less. `call()` (CLI `wafermap call`, MCP `wafermap_call`) sends a **holder pass** to Wafermap with each call; when the call is free, the result comes back with `receipt: null` and `free: {left, perDay}`, no payment is signed and nothing is recorded as spending. Otherwise the call is quoted and paid as before.
+- **Holder pass.** A message the wallet signs (`personal_sign`: no transaction, no cost) that proves it holds the wallet, valid for 24 hours and reused until its last 10 minutes (`Wafermap.holderPass()`). It goes to Wafermap only: never with `pay()` to third-party services, and never to marketplace listings (`m/...`). The SDK exports `PASS_HEADER`, `passMessage`, `encodePass`, `decodePass`, `makePass`.
+- **`wafermap holder`** shows what the wallet's $WAFERMAP unlocks: holder price, tier, free calls left today, x402 Tracker Pro. Needs no password (`holderInfo()` in the SDK).
+- **`wafermap pass`** prints a pass for scripts, e.g. the x402 Tracker Pro API (`/api/x402/pro/movers`, `/api/x402/pro/export`, for wallets holding 100,000 $WAFERMAP).
+
 ## 0.4.3 (2 Nov 2026)
 
 The two open points from the third public review by @whoiskn0why (8/10), thank you.

package/README.md

@@ -82,7 +82,11 @@ Pass `approve: (a) => boolean` to confirm each payment or swap yourself, and `le
 
 ## $WAFERMAP holder discount
 
-A wallet that holds at least 100,000 $WAFERMAP on Robinhood Chain pays 50% less for Wafermap's own resources when it pays on an EVM network (Robinhood Chain, Base, Arbitrum, Polygon). Nothing to set up: `wafermap call` names the wallet to Wafermap and the quote comes back discounted; the server re-checks the balance of the wallet that signs. Marketplace listings and Solana payments keep the regular price. Check a wallet: https://wafermap.xyz/api/holder?address=0x…
+A wallet that holds at least 100,000 $WAFERMAP on Robinhood Chain pays 50% less for Wafermap's own resources when it pays on an EVM network (Robinhood Chain, Base, Arbitrum, Polygon). Nothing to set up: `wafermap call` names the wallet to Wafermap and the quote comes back discounted; the server re-checks the balance of the wallet that signs. Marketplace listings and Solana payments keep the regular price. Check a wallet: https://wafermap.xyz/api/holder?address=0x…, or run `wafermap holder`.
+
+Wafermap's own resources can also be **paid in $WAFERMAP at 50% off, and the tokens are burned**: `wafermap approve-wafermap` once (a Permit2 approval, one Robinhood Chain transaction), then `wafermap call <id> --pay wafermap`. Each payment is a Permit2 signature for one exact amount, usable for two minutes only by Wafermap's relayer (fixed in the client), checked against a market price the client reads itself.
+
+With 1,000,000 $WAFERMAP the wallet is **Pro**: 10 free calls a day (UTC) to resources listed at $0.01 or less. `wafermap call` sends a holder pass (a signed message, no transaction, valid 24 hours) to Wafermap only; when a call is free, nothing is signed for payment and it prints `✓ Free call`. Holders of 100,000 also unlock x402 Tracker Pro: `wafermap pass` prints a pass for its API. Details: https://wafermap.xyz/docs#holders
 
 ## Where the limits live
 

package/dist/cli.js

@@ -296,6 +296,34 @@ var init_solana = __esm({
 });
 
 // shared/x402client.ts
+async function wafermapPriceUsd(f = fetch) {
+  const res = await f(`https://api.geckoterminal.com/api/v2/simple/networks/robinhood/token_price/${WAFERMAP_TOKEN}`, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(15e3) });
+  const j = await res.json().catch(() => null);
+  const p = Number(j?.data?.attributes?.token_prices?.[WAFERMAP_TOKEN]);
+  if (!res.ok || !(p > 0)) throw new X402Error("price_unavailable", "The $WAFERMAP market price could not be read, so the amount cannot be checked. Nothing was signed; pay in USDG or USDC.");
+  return p;
+}
+function tokenOption(r) {
+  const e = r?.extra ?? {};
+  const same = (a, b) => String(a ?? "").toLowerCase() === b.toLowerCase();
+  if (r?.scheme !== TOKEN_SCHEME || r.network !== "eip155:4663" || !same(r.asset, WAFERMAP_TOKEN) || !same(r.payTo, DEAD) || !same(e.permit2, PERMIT2)) return;
+  if (!/^\d{1,40}$/.test(String(r.amount)) || !/^0x[0-9a-fA-F]{40}$/.test(String(e.spender)) || !(Number(e.usd) > 0)) return;
+  if (!WAFERMAP_RELAYERS.some((a) => same(e.spender, a))) return;
+  return { amount: String(r.amount), usd: Number(e.usd), spender: e.spender, maxTimeoutSeconds: Number(r.maxTimeoutSeconds) || 120, raw: r };
+}
+async function signTokenPayment(signer, t, resource) {
+  const nonce = BigInt(randomNonce()) >> 8n;
+  const deadline = BigInt(Math.floor(Date.now() / 1e3) + Math.min(t.maxTimeoutSeconds, 120));
+  const permitted = { token: WAFERMAP_TOKEN, amount: BigInt(t.amount) };
+  let signature;
+  try {
+    signature = await signer.signTypedData({ domain: { name: "Permit2", chainId: 4663, verifyingContract: PERMIT2 }, types: PERMIT_TYPES, primaryType: "PermitTransferFrom", message: { permitted, spender: t.spender, nonce, deadline } });
+  } catch (e) {
+    throw new X402Error("sign_rejected", e?.shortMessage ?? e?.message ?? "Signature rejected.");
+  }
+  const payload = { owner: signer.address, permit: { permitted: { token: WAFERMAP_TOKEN, amount: t.amount }, nonce: nonce.toString(), deadline: deadline.toString() }, signature };
+  return { name: "PAYMENT-SIGNATURE", value: b64encode(JSON.stringify({ x402Version: 2, resource, accepted: t.raw, payload })), deadline: Number(deadline) };
+}
 function chainOf(network) {
   const n = String(network ?? "").toLowerCase();
   return PAY_CHAINS.find((c) => c.caip.toLowerCase() === n || c.v1 === n || c.id > 0 && String(c.id) === n);
@@ -314,8 +342,13 @@ async function readQuote(res) {
   const version = Number(body.x402Version) === 1 ? 1 : 2;
   const accepts = [];
   const offered = [];
+  let token;
   for (const r of body.accepts) {
     offered.push(`${r.scheme ?? "?"}/${r.network ?? "?"}`);
+    if (r?.scheme === TOKEN_SCHEME) {
+      token ??= tokenOption(r);
+      continue;
+    }
     const chain = chainOf(r.network);
     if (!chain || r.scheme !== "exact") continue;
     if (chain.vm === "evm" ? String(r.asset ?? "").toLowerCase() !== chain.stable.toLowerCase() : r.asset !== chain.stable) continue;
@@ -329,7 +362,7 @@ async function readQuote(res) {
     accepts.push({ version, chain, amount, usd: Number(amount) / 1e6, payTo: r.payTo, asset: r.asset, maxTimeoutSeconds: Number(r.maxTimeoutSeconds) || 120, extra, raw: r });
   }
   const inputError = body.inputError?.message ? { code: String(body.inputError.code ?? "invalid_input"), message: String(body.inputError.message) } : void 0;
-  return { version, resource: body.resource ?? null, accepts, offered, inputError };
+  return { version, resource: body.resource ?? null, accepts, offered, inputError, ...token ? { token } : {} };
 }
 function choose(q, prefer = CHAIN_KEYS) {
   for (const k of prefer) {
@@ -381,6 +414,23 @@ async function x402fetch(url, init, opts) {
   if (first.status !== 402) return { res: first, paid: null };
   const quote = await readQuote(first);
   if (quote.inputError) throw new X402Error(quote.inputError.code, quote.inputError.message);
+  if (opts.payIn === "wafermap") {
+    const t = quote.token;
+    if (!t) throw new X402Error("token_not_offered", "This call is not offered in $WAFERMAP right now (or not to a known Wafermap relayer). Pay in USDG or USDC.");
+    const value = Number(BigInt(t.amount) / 10n ** 12n) / 1e6 * await (opts.tokenPriceUsd ?? (() => wafermapPriceUsd(fetch)))();
+    if (value > t.usd * TOKEN_VALUE_SLACK + 5e-4) throw new X402Error("price_mismatch", `The quote asks for $WAFERMAP worth about $${value.toFixed(4)} at the market price, more than the $${t.usd} it states. Nothing was signed.`);
+    const usd = Math.max(t.usd, Math.round(value * 1e6) / 1e6);
+    const req2 = { version: 2, chain: PAY_CHAINS[0], amount: String(Math.round(usd * 1e6)), usd, payTo: DEAD, asset: WAFERMAP_TOKEN, maxTimeoutSeconds: t.maxTimeoutSeconds, extra: {}, raw: t.raw };
+    if (opts.approve) await opts.approve(req2);
+    const signer2 = typeof opts.signer === "function" ? await opts.signer() : opts.signer;
+    const header2 = await signTokenPayment(signer2, t, quote.resource);
+    const signed2 = { req: req2, from: signer2.address, token: { amount: t.amount } };
+    opts.onSigned?.(signed2);
+    const headers2 = new Headers(init.headers);
+    headers2.set(header2.name, header2.value);
+    const res2 = await f(url, { ...init, headers: headers2 });
+    return { res: res2, paid: { ...signed2, tx: readSettlement(res2)?.tx ?? null } };
+  }
   const req = choose(quote, (opts.prefer ?? CHAIN_KEYS).filter((k) => k !== "solana" || opts.solana));
   if (opts.approve) await opts.approve(req);
   const svm = req.chain.vm === "svm";
@@ -393,7 +443,7 @@ async function x402fetch(url, init, opts) {
   const res = await f(url, { ...init, headers });
   return { res, paid: { ...signed, tx: readSettlement(res)?.tx ?? null } };
 }
-var USDC_DOMAIN, PAY_CHAINS, EVM_CHAINS, CHAIN_KEYS, X402Error, b64encode, b64decode, TYPES, MAX_VALIDITY_SECONDS, randomNonce;
+var USDC_DOMAIN, PAY_CHAINS, EVM_CHAINS, CHAIN_KEYS, WAFERMAP_TOKEN, PERMIT2, DEAD, TOKEN_SCHEME, WAFERMAP_RELAYERS, TOKEN_VALUE_SLACK, PERMIT_TYPES, X402Error, b64encode, b64decode, TYPES, MAX_VALIDITY_SECONDS, randomNonce;
 var init_x402client = __esm({
   "shared/x402client.ts"() {
     "use strict";
@@ -408,6 +458,24 @@ var init_x402client = __esm({
     ];
     EVM_CHAINS = PAY_CHAINS.filter((c) => c.vm === "evm");
     CHAIN_KEYS = PAY_CHAINS.map((c) => c.key);
+    WAFERMAP_TOKEN = "0xfda080f64d84c989cfc50ff18253542cfe502db3";
+    PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+    DEAD = "0x000000000000000000000000000000000000dEaD";
+    TOKEN_SCHEME = "wafermap-permit2";
+    WAFERMAP_RELAYERS = ["0xD21547a387a9CfFb747211983c91f457742Ef00D"];
+    TOKEN_VALUE_SLACK = 1.25;
+    PERMIT_TYPES = {
+      PermitTransferFrom: [
+        { name: "permitted", type: "TokenPermissions" },
+        { name: "spender", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ],
+      TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" }
+      ]
+    };
     X402Error = class extends Error {
       constructor(code, message) {
         super(message);
@@ -437,6 +505,47 @@ var init_x402client = __esm({
   }
 });
 
+// shared/pass.ts
+function passMessage(address, iat, exp) {
+  return [
+    "wafermap.xyz holder pass",
+    "",
+    `Wallet: ${address}`,
+    `Issued: ${new Date(iat * 1e3).toISOString()}`,
+    `Expires: ${new Date(exp * 1e3).toISOString()}`,
+    "",
+    "Proves you hold this wallet, so Wafermap can apply what your $WAFERMAP unlocks. It costs nothing and moves no funds."
+  ].join("\n");
+}
+function decodePass(s) {
+  if (!s || s.length > 1e3 || !/^[A-Za-z0-9_-]+$/.test(s)) return null;
+  try {
+    const p = JSON.parse(unb64url(s));
+    if (p?.v !== 1 || typeof p.address !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(p.address)) return null;
+    if (!Number.isInteger(p.iat) || !Number.isInteger(p.exp) || typeof p.sig !== "string" || !/^0x[0-9a-fA-F]{130}$/.test(p.sig)) return null;
+    return { v: 1, address: p.address, iat: p.iat, exp: p.exp, sig: p.sig };
+  } catch {
+    return null;
+  }
+}
+async function makePass(signer, seconds = PASS_MAX_SECONDS, now = Math.floor(Date.now() / 1e3)) {
+  const iat = now;
+  const exp = now + Math.min(Math.max(60, seconds), PASS_MAX_SECONDS);
+  const sig = await signer.signMessage({ message: passMessage(signer.address, iat, exp) });
+  return { v: 1, address: signer.address, iat, exp, sig };
+}
+var PASS_HEADER, PASS_MAX_SECONDS, b64url, unb64url, encodePass;
+var init_pass = __esm({
+  "shared/pass.ts"() {
+    "use strict";
+    PASS_HEADER = "x-wafermap-pass";
+    PASS_MAX_SECONDS = 86400;
+    b64url = (s) => btoa(unescape(encodeURIComponent(s))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    unb64url = (s) => decodeURIComponent(escape(atob(s.replace(/-/g, "+").replace(/_/g, "/"))));
+    encodePass = (p) => b64url(JSON.stringify(p));
+  }
+});
+
 // src/core.ts
 var core_exports = {};
 __export(core_exports, {
@@ -446,6 +555,7 @@ __export(core_exports, {
   Wafermap: () => Wafermap,
   WafermapError: () => WafermapError,
   checkPayment: () => checkPayment,
+  holderInfo: () => holderInfo,
   isNet: () => isNet,
   listResources: () => listResources,
   mergeLog: () => mergeLog
@@ -473,6 +583,15 @@ async function checkPayment(e, rpc) {
     return "error";
   }
 }
+async function holderInfo(address, baseUrl = "https://wafermap.xyz", timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const host = new URL(baseUrl).host;
+  const r = await fetch(`${baseUrl.replace(/\/$/, "")}/api/holder?address=${encodeURIComponent(address)}`, { signal: AbortSignal.timeout(timeoutMs) }).catch((e) => {
+    throw timedOut(e) ? new WafermapError("timeout", `${host} did not answer within ${Math.round(timeoutMs / 1e3)} s.`) : new WafermapError("network_error", `${host}: ${e?.message ?? "request failed"}`);
+  });
+  const j = await r.json().catch(() => null);
+  if (!r.ok || !j) throw new WafermapError(j?.error?.code ?? "network_error", j?.error?.message ?? `${host} answered HTTP ${r.status}.`);
+  return j;
+}
 async function listResources(baseUrl = "https://wafermap.xyz", timeoutMs = DEFAULT_TIMEOUT_MS) {
   const host = new URL(baseUrl).host;
   const gaveUp = () => new WafermapError("timeout", `${host} did not answer within ${Math.round(timeoutMs / 1e3)} s. Nothing was paid.`);
@@ -494,6 +613,7 @@ var init_core = __esm({
     init_swap();
     init_solana();
     init_x402client();
+    init_pass();
     NETS = CHAIN_KEYS;
     isNet = (v) => NETS.includes(v);
     isSwapNet = (v) => v === "robinhood" || v === "base";
@@ -523,6 +643,7 @@ var init_core = __esm({
       timeoutMs;
       /** fetch with this wallet's time limit: a server that never answers cannot hold a call forever. */
       fetch;
+      tokenPriceUsd;
       constructor(o) {
         const account = o.account ?? (o.privateKey ? privateKeyToAccount(o.privateKey) : null);
         if (!account) throw new WafermapError("no_account", "Pass privateKey or account.");
@@ -535,6 +656,7 @@ var init_core = __esm({
         this.approveFn = o.approve;
         this.rpc = o.rpc ?? {};
         this.timeoutMs = o.timeoutMs && o.timeoutMs > 0 ? o.timeoutMs : DEFAULT_TIMEOUT_MS;
+        this.tokenPriceUsd = o.tokenPriceUsd;
         this.fetch = (input, init) => fetch(input, { ...init, signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs) });
         const sol = o.solana ?? (o.privateKey ? solanaKeyFromEvm(o.privateKey) : null);
         const solRpc = this.rpc.solana ?? `${this.baseUrl}/api/solana`;
@@ -608,7 +730,7 @@ var init_core = __esm({
         this.queue = prev.then(() => held);
         return prev.then(() => release);
       }
-      async paidFetch(kind, what, url, init, network) {
+      async paidFetch(kind, what, url, init, network, payIn) {
         let id = null;
         let release = null;
         const unlock = () => {
@@ -621,9 +743,11 @@ var init_core = __esm({
             solana: this.solana ?? void 0,
             prefer: this.prefer(network),
             fetch: this.fetch,
+            payIn,
+            tokenPriceUsd: this.tokenPriceUsd,
             approve: async (req) => {
               release = await this.acquire();
-              await this.gate({ kind, what, usd: req.usd, network: req.chain.key, detail: `${req.chain.symbol} to ${req.payTo}` });
+              await this.gate({ kind, what, usd: req.usd, network: req.chain.key, detail: req.asset === WAFERMAP_TOKEN ? "in $WAFERMAP at 50% off, burned" : `${req.chain.symbol} to ${req.payTo}` });
             },
             onSigned: (s) => {
               id = this.booked(kind, what, s);
@@ -649,8 +773,43 @@ var init_core = __esm({
       async resources() {
         return listResources(this.baseUrl, this.timeoutMs);
       }
+      passCache = null;
+      /** A holder pass (shared/pass.ts) signed by this wallet, valid 24 h and reused until its last 10 minutes. It
+       *  proves the wallet to Wafermap for what its $WAFERMAP unlocks (Pro free calls, x402 Tracker Pro). Signing
+       *  a message moves no funds. */
+      async holderPass() {
+        const p = decodePass(this.passCache);
+        if (this.passCache && p && p.exp - 600 > Date.now() / 1e3) return this.passCache;
+        this.passCache = encodePass(await makePass({ address: this.account.address, signMessage: (a) => this.account.signMessage(a) }));
+        return this.passCache;
+      }
+      // ---- Paying in $WAFERMAP (Permit2; the tokens are burned) ----
+      /** Whether this wallet has approved Permit2 to move its $WAFERMAP (needed once before paying in $WAFERMAP). */
+      async wafermapApproved() {
+        const a = await this.client("robinhood").readContract({ address: WAFERMAP_TOKEN, abi: erc20Abi2, functionName: "allowance", args: [this.address, PERMIT2] });
+        return a >= 10n ** 30n;
+      }
+      /** Approves Permit2 (Uniswap's, at its canonical address) to move this wallet's $WAFERMAP: one on-chain
+       *  transaction on Robinhood Chain, paid in ETH. Each payment after that is a signature for one exact amount,
+       *  spendable only by Wafermap's relayer for two minutes. */
+      async approveWafermap() {
+        const wallet = createWalletClient({ account: this.account, chain: CHAINS.robinhood, transport: http(this.rpc.robinhood) });
+        try {
+          const tx = await wallet.writeContract({ address: WAFERMAP_TOKEN, abi: erc20Abi2, functionName: "approve", args: [PERMIT2, 2n ** 256n - 1n] });
+          const rc = await this.client("robinhood").waitForTransactionReceipt({ hash: tx, timeout: 6e4 });
+          if (rc.status !== "success") throw new WafermapError("approve_failed", `The approval reverted: ${tx}`);
+          return tx;
+        } catch (e) {
+          if (e instanceof WafermapError) throw e;
+          throw new WafermapError("approve_failed", e?.shortMessage ?? e?.message ?? "The approval failed.");
+        }
+      }
       async call(id, input = {}, o = {}) {
-        const go = () => this.paidFetch("resource", id, `${this.baseUrl}/v1/${id}`, { method: "POST", headers: { "content-type": "application/json", "x-wafermap-payer": this.address }, body: JSON.stringify(input) }, o.network);
+        const inToken = o.payIn === "wafermap";
+        if (inToken && id.startsWith("m/")) throw new WafermapError("token_not_offered", "Marketplace listings are paid in USDG or USDC to their seller, not in $WAFERMAP.");
+        if (inToken && !await this.wafermapApproved().catch(() => true)) throw new WafermapError("permit2_not_approved", "Paying in $WAFERMAP needs a one-time approval of Permit2. Run `wafermap approve-wafermap` (one transaction on Robinhood Chain, paid in ETH), then call again.");
+        const pass = id.startsWith("m/") ? null : await this.holderPass();
+        const go = () => this.paidFetch("resource", id, `${this.baseUrl}/v1/${id}`, { method: "POST", headers: { "content-type": "application/json", "x-wafermap-payer": this.address, ...pass ? { [PASS_HEADER]: pass } : {} }, body: JSON.stringify(input) }, o.network, inToken ? "wafermap" : void 0);
         const settle = (r2, out2) => {
           if (!r2.paid || !r2.id) return;
           const status = r2.res.status === 402 ? "refused" : r2.res.ok ? "ok" : "failed";
@@ -960,7 +1119,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "0.4.3";
+    VERSION = "0.4.5";
   }
 });
 
@@ -1060,11 +1219,16 @@ async function runMcp() {
     {
       title: "Call a Wafermap resource",
       description: "Run one Wafermap resource and pay its exact price over x402 from the local wallet, within the per-payment and daily caps. Failed calls are not charged.",
-      inputSchema: { resource: z.string().describe("Resource id, e.g. market-brief, prediction-markets, stock-signal, flux-2-dev."), input: z.record(z.string(), z.any()).optional().describe("Input fields for the resource."), network: NET }
+      inputSchema: {
+        resource: z.string().describe("Resource id, e.g. market-brief, prediction-markets, stock-signal, flux-2-dev."),
+        input: z.record(z.string(), z.any()).optional().describe("Input fields for the resource."),
+        network: NET,
+        payIn: z.enum(["stablecoin", "wafermap"]).optional().describe("wafermap: pay Wafermap's own resources in $WAFERMAP at 50% off (the tokens are burned; needs `wafermap approve-wafermap` once). Default: USDG/USDC.")
+      }
     },
-    async ({ resource, input, network }) => {
+    async ({ resource, input, network, payIn }) => {
       try {
-        return result(await wm.call(resource, input ?? {}, { network }));
+        return result(await wm.call(resource, input ?? {}, { network, payIn }));
       } catch (e) {
         return failure(e);
       }
@@ -1515,6 +1679,10 @@ Wallet
 Pay
   wafermap resources [words]            Wafermap's pay-per-call catalog
   wafermap call <id> [field=value ...]  run a resource and pay its price  (--json '{...}' for complex input)
+  wafermap call <id> ... --pay wafermap pay a Wafermap resource in $WAFERMAP at 50% off (the tokens are burned)
+  wafermap approve-wafermap             one-time approval so the wallet can pay in $WAFERMAP (Robinhood Chain, ETH gas)
+  wafermap holder                       what this wallet's $WAFERMAP unlocks: holder price, Pro free calls left today
+  wafermap pass                         print a holder pass (X-Wafermap-Pass) for scripts and x402 Tracker Pro
   wafermap discover <words>             search third-party x402 services
   wafermap pay <url> [field=value ...]  call any x402 URL and pay it       (--post to send a JSON body)
 
@@ -1630,6 +1798,34 @@ async function main() {
   Caps: $0.10 per payment, $1 per day, $25 per swap. Change with \`wafermap limits\`.`);
       return;
     }
+    case "approve-wafermap": {
+      const wm = openWallet(await password());
+      if (await wm.wafermapApproved()) return console.log("\u2713 Already approved: this wallet can pay Wafermap in $WAFERMAP (wafermap call <id> --pay wafermap).");
+      console.error(`This sends one transaction on Robinhood Chain from ${wm.address}, paid in ETH: approve Permit2 (Uniswap, 0x000000000022D473030F116dDEE9F6B43aC78BA3) to move this wallet's $WAFERMAP. Each payment after that is a separate signature for one exact amount, usable only by Wafermap's relayer for two minutes.`);
+      if (!yes && !/^y(es)?$/i.test((await ask("Send the approval? [y/N] ")).trim())) die("Cancelled. Nothing was sent.");
+      const tx = await wm.approveWafermap();
+      return console.log(`\u2713 Approved \xB7 ${EXPLORER("robinhood")}/tx/${tx}`);
+    }
+    case "holder": {
+      const addr = keystoreAddress() ?? die("No wallet yet. Run `wafermap init`.");
+      const j = await holderInfo(addr, process.env.WAFERMAP_URL, Number(process.env.WAFERMAP_TIMEOUT_MS) || void 0);
+      if (!j.active) return console.log("The $WAFERMAP holder program is off.");
+      const n = (v) => Math.floor(v).toLocaleString("en-US");
+      const k = j.perks;
+      console.log(`${addr}
+  holds     ${n(j.balance)} $WAFERMAP on Robinhood Chain`);
+      console.log(`  tier      ${j.tier === "pro" ? "Pro" : j.tier === "holder" ? "Holder" : "none"}`);
+      console.log(`  price     ${j.holder ? `${j.percent}% off Wafermap resources on EVM networks` : `regular (hold ${n(j.minTokens)} for ${j.percent}% off)`}`);
+      if (k) console.log(`  free      ${j.tier === "pro" ? `${k.freeLeftToday ?? "?"} of ${k.freeCallsPerDay} free calls left today (resources up to $${k.freeMaxUsd}); \`wafermap call\` uses them first` : `hold ${n(k.proMinTokens)} for ${k.freeCallsPerDay} free calls a day`}`);
+      return console.log(`  tracker   ${j.holder ? "x402 Tracker Pro unlocked: wafermap.xyz/x402 (or `wafermap pass` for the API)" : `x402 Tracker Pro needs ${n(j.minTokens)}`}`);
+    }
+    case "pass": {
+      const wm = openWallet(await password());
+      const v = await wm.holderPass();
+      console.error(`Holder pass for ${wm.address}, valid 24 hours. It proves you hold the wallet and moves no funds; anyone who has it can use your free calls until it expires, so keep it private. Send it as X-Wafermap-Pass:`);
+      console.error(`  curl -H "X-Wafermap-Pass: $(wafermap pass)" https://wafermap.xyz/api/x402/pro/movers`);
+      return console.log(v);
+    }
     case "address": {
       const evm = keystoreAddress() ?? die("No wallet yet. Run `wafermap init`.");
       let sol = keystoreSolana();
@@ -1709,8 +1905,11 @@ Total $${total.toFixed(4)} in ${pays.length} payments. From 0.3.3 every payment
     case "call": {
       const id = a._[0] ?? die("Which resource? e.g. wafermap call gas-now network=base");
       const wm = openWallet(await password(), approver(yes));
-      const out = await wm.call(id, inputOf(a, 1), { network: net(a.flags.network) });
-      if (out.receipt) console.error(`\u2713 Paid $${out.receipt.amountUsd} ${out.receipt.asset} \xB7 ${EXPLORER(out.receipt.network)}/tx/${out.receipt.tx}`);
+      const payIn = a.flags.pay === "wafermap" ? "wafermap" : a.flags.pay === void 0 || a.flags.pay === "usd" ? void 0 : die("--pay must be wafermap (or leave it out to pay in USDG/USDC)");
+      const out = await wm.call(id, inputOf(a, 1), { network: net(a.flags.network), payIn });
+      if (out.receipt?.asset === "WAFERMAP") console.error(`\u2713 Paid ${out.receipt.amountTokens} $WAFERMAP (\u2248 $${out.receipt.amountUsd}), burned \xB7 ${EXPLORER(out.receipt.network)}/tx/${out.receipt.tx}`);
+      else if (out.receipt) console.error(`\u2713 Paid $${out.receipt.amountUsd} ${out.receipt.asset} \xB7 ${EXPLORER(out.receipt.network)}/tx/${out.receipt.tx}`);
+      else if (out.free) console.error(`\u2713 Free call ($WAFERMAP Pro) \xB7 ${out.free.left} of ${out.free.perDay} left today. Nothing was paid.`);
       if (typeof a.flags.out === "string") await saveMedia(out.result, a.flags.out);
       return printResult(out.result);
     }

package/dist/index.js

@@ -283,6 +283,52 @@ var PAY_CHAINS = [
 ];
 var EVM_CHAINS = PAY_CHAINS.filter((c) => c.vm === "evm");
 var CHAIN_KEYS = PAY_CHAINS.map((c) => c.key);
+var WAFERMAP_TOKEN = "0xfda080f64d84c989cfc50ff18253542cfe502db3";
+var PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var DEAD = "0x000000000000000000000000000000000000dEaD";
+var TOKEN_SCHEME = "wafermap-permit2";
+var WAFERMAP_RELAYERS = ["0xD21547a387a9CfFb747211983c91f457742Ef00D"];
+var TOKEN_VALUE_SLACK = 1.25;
+async function wafermapPriceUsd(f = fetch) {
+  const res = await f(`https://api.geckoterminal.com/api/v2/simple/networks/robinhood/token_price/${WAFERMAP_TOKEN}`, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(15e3) });
+  const j = await res.json().catch(() => null);
+  const p = Number(j?.data?.attributes?.token_prices?.[WAFERMAP_TOKEN]);
+  if (!res.ok || !(p > 0)) throw new X402Error("price_unavailable", "The $WAFERMAP market price could not be read, so the amount cannot be checked. Nothing was signed; pay in USDG or USDC.");
+  return p;
+}
+var PERMIT_TYPES = {
+  PermitTransferFrom: [
+    { name: "permitted", type: "TokenPermissions" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ]
+};
+function tokenOption(r) {
+  const e = r?.extra ?? {};
+  const same = (a, b) => String(a ?? "").toLowerCase() === b.toLowerCase();
+  if (r?.scheme !== TOKEN_SCHEME || r.network !== "eip155:4663" || !same(r.asset, WAFERMAP_TOKEN) || !same(r.payTo, DEAD) || !same(e.permit2, PERMIT2)) return;
+  if (!/^\d{1,40}$/.test(String(r.amount)) || !/^0x[0-9a-fA-F]{40}$/.test(String(e.spender)) || !(Number(e.usd) > 0)) return;
+  if (!WAFERMAP_RELAYERS.some((a) => same(e.spender, a))) return;
+  return { amount: String(r.amount), usd: Number(e.usd), spender: e.spender, maxTimeoutSeconds: Number(r.maxTimeoutSeconds) || 120, raw: r };
+}
+async function signTokenPayment(signer, t, resource) {
+  const nonce = BigInt(randomNonce()) >> 8n;
+  const deadline = BigInt(Math.floor(Date.now() / 1e3) + Math.min(t.maxTimeoutSeconds, 120));
+  const permitted = { token: WAFERMAP_TOKEN, amount: BigInt(t.amount) };
+  let signature;
+  try {
+    signature = await signer.signTypedData({ domain: { name: "Permit2", chainId: 4663, verifyingContract: PERMIT2 }, types: PERMIT_TYPES, primaryType: "PermitTransferFrom", message: { permitted, spender: t.spender, nonce, deadline } });
+  } catch (e) {
+    throw new X402Error("sign_rejected", e?.shortMessage ?? e?.message ?? "Signature rejected.");
+  }
+  const payload = { owner: signer.address, permit: { permitted: { token: WAFERMAP_TOKEN, amount: t.amount }, nonce: nonce.toString(), deadline: deadline.toString() }, signature };
+  return { name: "PAYMENT-SIGNATURE", value: b64encode(JSON.stringify({ x402Version: 2, resource, accepted: t.raw, payload })), deadline: Number(deadline) };
+}
 var X402Error = class extends Error {
   constructor(code, message) {
     super(message);
@@ -315,8 +361,13 @@ async function readQuote(res) {
   const version = Number(body.x402Version) === 1 ? 1 : 2;
   const accepts = [];
   const offered = [];
+  let token;
   for (const r of body.accepts) {
     offered.push(`${r.scheme ?? "?"}/${r.network ?? "?"}`);
+    if (r?.scheme === TOKEN_SCHEME) {
+      token ??= tokenOption(r);
+      continue;
+    }
     const chain = chainOf(r.network);
     if (!chain || r.scheme !== "exact") continue;
     if (chain.vm === "evm" ? String(r.asset ?? "").toLowerCase() !== chain.stable.toLowerCase() : r.asset !== chain.stable) continue;
@@ -330,7 +381,7 @@ async function readQuote(res) {
     accepts.push({ version, chain, amount, usd: Number(amount) / 1e6, payTo: r.payTo, asset: r.asset, maxTimeoutSeconds: Number(r.maxTimeoutSeconds) || 120, extra, raw: r });
   }
   const inputError = body.inputError?.message ? { code: String(body.inputError.code ?? "invalid_input"), message: String(body.inputError.message) } : void 0;
-  return { version, resource: body.resource ?? null, accepts, offered, inputError };
+  return { version, resource: body.resource ?? null, accepts, offered, inputError, ...token ? { token } : {} };
 }
 function choose(q, prefer = CHAIN_KEYS) {
   for (const k of prefer) {
@@ -394,6 +445,23 @@ async function x402fetch(url, init, opts) {
   if (first.status !== 402) return { res: first, paid: null };
   const quote = await readQuote(first);
   if (quote.inputError) throw new X402Error(quote.inputError.code, quote.inputError.message);
+  if (opts.payIn === "wafermap") {
+    const t = quote.token;
+    if (!t) throw new X402Error("token_not_offered", "This call is not offered in $WAFERMAP right now (or not to a known Wafermap relayer). Pay in USDG or USDC.");
+    const value = Number(BigInt(t.amount) / 10n ** 12n) / 1e6 * await (opts.tokenPriceUsd ?? (() => wafermapPriceUsd(fetch)))();
+    if (value > t.usd * TOKEN_VALUE_SLACK + 5e-4) throw new X402Error("price_mismatch", `The quote asks for $WAFERMAP worth about $${value.toFixed(4)} at the market price, more than the $${t.usd} it states. Nothing was signed.`);
+    const usd = Math.max(t.usd, Math.round(value * 1e6) / 1e6);
+    const req2 = { version: 2, chain: PAY_CHAINS[0], amount: String(Math.round(usd * 1e6)), usd, payTo: DEAD, asset: WAFERMAP_TOKEN, maxTimeoutSeconds: t.maxTimeoutSeconds, extra: {}, raw: t.raw };
+    if (opts.approve) await opts.approve(req2);
+    const signer2 = typeof opts.signer === "function" ? await opts.signer() : opts.signer;
+    const header2 = await signTokenPayment(signer2, t, quote.resource);
+    const signed2 = { req: req2, from: signer2.address, token: { amount: t.amount } };
+    opts.onSigned?.(signed2);
+    const headers2 = new Headers(init.headers);
+    headers2.set(header2.name, header2.value);
+    const res2 = await f(url, { ...init, headers: headers2 });
+    return { res: res2, paid: { ...signed2, tx: readSettlement(res2)?.tx ?? null } };
+  }
   const req = choose(quote, (opts.prefer ?? CHAIN_KEYS).filter((k) => k !== "solana" || opts.solana));
   if (opts.approve) await opts.approve(req);
   const svm = req.chain.vm === "svm";
@@ -407,6 +475,41 @@ async function x402fetch(url, init, opts) {
   return { res, paid: { ...signed, tx: readSettlement(res)?.tx ?? null } };
 }
 
+// shared/pass.ts
+var PASS_HEADER = "x-wafermap-pass";
+var PASS_MAX_SECONDS = 86400;
+function passMessage(address, iat, exp) {
+  return [
+    "wafermap.xyz holder pass",
+    "",
+    `Wallet: ${address}`,
+    `Issued: ${new Date(iat * 1e3).toISOString()}`,
+    `Expires: ${new Date(exp * 1e3).toISOString()}`,
+    "",
+    "Proves you hold this wallet, so Wafermap can apply what your $WAFERMAP unlocks. It costs nothing and moves no funds."
+  ].join("\n");
+}
+var b64url = (s) => btoa(unescape(encodeURIComponent(s))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+var unb64url = (s) => decodeURIComponent(escape(atob(s.replace(/-/g, "+").replace(/_/g, "/"))));
+var encodePass = (p) => b64url(JSON.stringify(p));
+function decodePass(s) {
+  if (!s || s.length > 1e3 || !/^[A-Za-z0-9_-]+$/.test(s)) return null;
+  try {
+    const p = JSON.parse(unb64url(s));
+    if (p?.v !== 1 || typeof p.address !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(p.address)) return null;
+    if (!Number.isInteger(p.iat) || !Number.isInteger(p.exp) || typeof p.sig !== "string" || !/^0x[0-9a-fA-F]{130}$/.test(p.sig)) return null;
+    return { v: 1, address: p.address, iat: p.iat, exp: p.exp, sig: p.sig };
+  } catch {
+    return null;
+  }
+}
+async function makePass(signer, seconds = PASS_MAX_SECONDS, now = Math.floor(Date.now() / 1e3)) {
+  const iat = now;
+  const exp = now + Math.min(Math.max(60, seconds), PASS_MAX_SECONDS);
+  const sig = await signer.signMessage({ message: passMessage(signer.address, iat, exp) });
+  return { v: 1, address: signer.address, iat, exp, sig };
+}
+
 // src/core.ts
 var NETS = CHAIN_KEYS;
 var isSwapNet = (v) => v === "robinhood" || v === "base";
@@ -442,6 +545,15 @@ async function checkPayment(e, rpc) {
 var DEFAULT_LIMITS = { perPayment: 0.1, perDay: 1, perSwap: 25 };
 var DEFAULT_TIMEOUT_MS = 6e4;
 var timedOut = (e) => e?.name === "TimeoutError" || e?.cause?.name === "TimeoutError";
+async function holderInfo(address, baseUrl = "https://wafermap.xyz", timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const host = new URL(baseUrl).host;
+  const r = await fetch(`${baseUrl.replace(/\/$/, "")}/api/holder?address=${encodeURIComponent(address)}`, { signal: AbortSignal.timeout(timeoutMs) }).catch((e) => {
+    throw timedOut(e) ? new WafermapError("timeout", `${host} did not answer within ${Math.round(timeoutMs / 1e3)} s.`) : new WafermapError("network_error", `${host}: ${e?.message ?? "request failed"}`);
+  });
+  const j = await r.json().catch(() => null);
+  if (!r.ok || !j) throw new WafermapError(j?.error?.code ?? "network_error", j?.error?.message ?? `${host} answered HTTP ${r.status}.`);
+  return j;
+}
 async function listResources(baseUrl = "https://wafermap.xyz", timeoutMs = DEFAULT_TIMEOUT_MS) {
   const host = new URL(baseUrl).host;
   const gaveUp = () => new WafermapError("timeout", `${host} did not answer within ${Math.round(timeoutMs / 1e3)} s. Nothing was paid.`);
@@ -470,6 +582,7 @@ var Wafermap = class {
   timeoutMs;
   /** fetch with this wallet's time limit: a server that never answers cannot hold a call forever. */
   fetch;
+  tokenPriceUsd;
   constructor(o) {
     const account = o.account ?? (o.privateKey ? privateKeyToAccount(o.privateKey) : null);
     if (!account) throw new WafermapError("no_account", "Pass privateKey or account.");
@@ -482,6 +595,7 @@ var Wafermap = class {
     this.approveFn = o.approve;
     this.rpc = o.rpc ?? {};
     this.timeoutMs = o.timeoutMs && o.timeoutMs > 0 ? o.timeoutMs : DEFAULT_TIMEOUT_MS;
+    this.tokenPriceUsd = o.tokenPriceUsd;
     this.fetch = (input, init) => fetch(input, { ...init, signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs) });
     const sol = o.solana ?? (o.privateKey ? solanaKeyFromEvm(o.privateKey) : null);
     const solRpc = this.rpc.solana ?? `${this.baseUrl}/api/solana`;
@@ -555,7 +669,7 @@ var Wafermap = class {
     this.queue = prev.then(() => held);
     return prev.then(() => release);
   }
-  async paidFetch(kind, what, url, init, network) {
+  async paidFetch(kind, what, url, init, network, payIn) {
     let id = null;
     let release = null;
     const unlock = () => {
@@ -568,9 +682,11 @@ var Wafermap = class {
         solana: this.solana ?? void 0,
         prefer: this.prefer(network),
         fetch: this.fetch,
+        payIn,
+        tokenPriceUsd: this.tokenPriceUsd,
         approve: async (req) => {
           release = await this.acquire();
-          await this.gate({ kind, what, usd: req.usd, network: req.chain.key, detail: `${req.chain.symbol} to ${req.payTo}` });
+          await this.gate({ kind, what, usd: req.usd, network: req.chain.key, detail: req.asset === WAFERMAP_TOKEN ? "in $WAFERMAP at 50% off, burned" : `${req.chain.symbol} to ${req.payTo}` });
         },
         onSigned: (s) => {
           id = this.booked(kind, what, s);
@@ -596,8 +712,43 @@ var Wafermap = class {
   async resources() {
     return listResources(this.baseUrl, this.timeoutMs);
   }
+  passCache = null;
+  /** A holder pass (shared/pass.ts) signed by this wallet, valid 24 h and reused until its last 10 minutes. It
+   *  proves the wallet to Wafermap for what its $WAFERMAP unlocks (Pro free calls, x402 Tracker Pro). Signing
+   *  a message moves no funds. */
+  async holderPass() {
+    const p = decodePass(this.passCache);
+    if (this.passCache && p && p.exp - 600 > Date.now() / 1e3) return this.passCache;
+    this.passCache = encodePass(await makePass({ address: this.account.address, signMessage: (a) => this.account.signMessage(a) }));
+    return this.passCache;
+  }
+  // ---- Paying in $WAFERMAP (Permit2; the tokens are burned) ----
+  /** Whether this wallet has approved Permit2 to move its $WAFERMAP (needed once before paying in $WAFERMAP). */
+  async wafermapApproved() {
+    const a = await this.client("robinhood").readContract({ address: WAFERMAP_TOKEN, abi: erc20Abi2, functionName: "allowance", args: [this.address, PERMIT2] });
+    return a >= 10n ** 30n;
+  }
+  /** Approves Permit2 (Uniswap's, at its canonical address) to move this wallet's $WAFERMAP: one on-chain
+   *  transaction on Robinhood Chain, paid in ETH. Each payment after that is a signature for one exact amount,
+   *  spendable only by Wafermap's relayer for two minutes. */
+  async approveWafermap() {
+    const wallet = createWalletClient({ account: this.account, chain: CHAINS.robinhood, transport: http(this.rpc.robinhood) });
+    try {
+      const tx = await wallet.writeContract({ address: WAFERMAP_TOKEN, abi: erc20Abi2, functionName: "approve", args: [PERMIT2, 2n ** 256n - 1n] });
+      const rc = await this.client("robinhood").waitForTransactionReceipt({ hash: tx, timeout: 6e4 });
+      if (rc.status !== "success") throw new WafermapError("approve_failed", `The approval reverted: ${tx}`);
+      return tx;
+    } catch (e) {
+      if (e instanceof WafermapError) throw e;
+      throw new WafermapError("approve_failed", e?.shortMessage ?? e?.message ?? "The approval failed.");
+    }
+  }
   async call(id, input = {}, o = {}) {
-    const go = () => this.paidFetch("resource", id, `${this.baseUrl}/v1/${id}`, { method: "POST", headers: { "content-type": "application/json", "x-wafermap-payer": this.address }, body: JSON.stringify(input) }, o.network);
+    const inToken = o.payIn === "wafermap";
+    if (inToken && id.startsWith("m/")) throw new WafermapError("token_not_offered", "Marketplace listings are paid in USDG or USDC to their seller, not in $WAFERMAP.");
+    if (inToken && !await this.wafermapApproved().catch(() => true)) throw new WafermapError("permit2_not_approved", "Paying in $WAFERMAP needs a one-time approval of Permit2. Run `wafermap approve-wafermap` (one transaction on Robinhood Chain, paid in ETH), then call again.");
+    const pass = id.startsWith("m/") ? null : await this.holderPass();
+    const go = () => this.paidFetch("resource", id, `${this.baseUrl}/v1/${id}`, { method: "POST", headers: { "content-type": "application/json", "x-wafermap-payer": this.address, ...pass ? { [PASS_HEADER]: pass } : {} }, body: JSON.stringify(input) }, o.network, inToken ? "wafermap" : void 0);
     const settle = (r2, out2) => {
       if (!r2.paid || !r2.id) return;
       const status = r2.res.status === 402 ? "refused" : r2.res.ok ? "ok" : "failed";
@@ -711,19 +862,30 @@ export {
   DEFAULT_TIMEOUT_MS,
   KYBER_ROUTER,
   MAX_VALIDITY_SECONDS,
+  PASS_HEADER,
   PAY_CHAINS,
+  PERMIT2,
   SwapError,
+  WAFERMAP_RELAYERS,
+  WAFERMAP_TOKEN,
   Wafermap,
   WafermapError,
   X402Error,
   checkPayment,
   choose,
+  decodePass,
   decodeSwap,
+  encodePass,
   executeSwap,
+  holderInfo,
   listResources,
+  makePass,
   mergeLog,
+  passMessage,
   quoteSwap,
   readQuote,
   signPayment,
+  signTokenPayment,
+  wafermapPriceUsd,
   x402fetch
 };

package/dist/types/shared/pass.d.ts

@@ -0,0 +1,21 @@
+export declare const PASS_HEADER = "x-wafermap-pass";
+export declare const PASS_MAX_SECONDS = 86400;
+export type Pass = {
+    v: 1;
+    address: string;
+    iat: number;
+    exp: number;
+    sig: string;
+};
+/** The exact text the wallet signs. */
+export declare function passMessage(address: string, iat: number, exp: number): string;
+export declare const encodePass: (p: Pass) => string;
+/** The pass's fields, or null when it is not a well-formed pass (the signature is not checked here). */
+export declare function decodePass(s: string | undefined | null): Pass | null;
+/** Signs a new pass with any signer that can personal_sign. Valid for `seconds` (at most a day). */
+export declare function makePass(signer: {
+    address: string;
+    signMessage: (a: {
+        message: string;
+    }) => Promise<string>;
+}, seconds?: number, now?: number): Promise<Pass>;

package/dist/types/shared/x402client.d.ts

@@ -56,7 +56,30 @@ export type Quote = {
         code: string;
         message: string;
     };
+    token?: TokenRequirement;
 };
+export declare const WAFERMAP_TOKEN = "0xfda080f64d84c989cfc50ff18253542cfe502db3";
+export declare const PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+export declare const DEAD = "0x000000000000000000000000000000000000dEaD";
+export declare const TOKEN_SCHEME = "wafermap-permit2";
+/** Wafermap's relayer wallets, the only spenders this client signs a $WAFERMAP permit for. Empty: paying in
+ *  $WAFERMAP is off in this build. A new relayer address ships as a new client release. */
+export declare const WAFERMAP_RELAYERS: string[];
+/** $WAFERMAP in USD, read by the client itself from GeckoTerminal. Throws when it cannot be read. */
+export declare function wafermapPriceUsd(f?: typeof fetch): Promise<number>;
+export type TokenRequirement = {
+    amount: string;
+    usd: number;
+    spender: Hex;
+    maxTimeoutSeconds: number;
+    raw: any;
+};
+/** Signs a Permit2 transfer of exactly the quoted $WAFERMAP to Wafermap's relayer, valid for at most 120 s. */
+export declare function signTokenPayment(signer: Signer, t: TokenRequirement, resource: any): Promise<{
+    name: string;
+    value: string;
+    deadline: number;
+}>;
 export declare class X402Error extends Error {
     code: string;
     constructor(code: string, message: string);
@@ -92,6 +115,9 @@ export type Signed = {
     req: Requirement;
     from: string;
     auth?: SignedAuth;
+    token?: {
+        amount: string;
+    };
 };
 export type PaidCall = {
     res: Response;
@@ -113,4 +139,6 @@ export declare function x402fetch(url: string, init: RequestInit, opts: {
     approve?: (req: Requirement) => Promise<void> | void;
     onSigned?: (s: Signed) => void;
     fetch?: typeof fetch;
+    payIn?: "stablecoin" | "wafermap";
+    tokenPriceUsd?: () => Promise<number>;
 }): Promise<PaidCall>;

package/dist/types/src/core.d.ts

@@ -71,6 +71,9 @@ export type WafermapOptions = {
     /** Give up on any HTTP request (quote, paid call, discovery, swap API) after this long. Default 60000 ms.
      *  A paid call that times out after signing stays counted until its authorization expires. */
     timeoutMs?: number;
+    /** Where the $WAFERMAP price comes from when paying in $WAFERMAP (default: GeckoTerminal, read by this client).
+     *  The signed amount is valued at this price and refused when it is worth more than the quote states. */
+    tokenPriceUsd?: () => Promise<number>;
 };
 export declare class WafermapError extends Error {
     code: string;
@@ -87,6 +90,8 @@ export declare function mergeLog(entries: SpendEntry[]): SpendEntry[];
 export declare function checkPayment(e: Pick<SpendEntry, "network" | "payer" | "nonce" | "validBefore">, rpc?: string): Promise<"used" | "unused" | "pending" | "unknown" | "error">;
 export declare const DEFAULT_LIMITS: Limits;
 export declare const DEFAULT_TIMEOUT_MS = 60000;
+/** What a wallet's $WAFERMAP unlocks (holder price, Pro free calls left today), from /api/holder. Needs no key. */
+export declare function holderInfo(address: string, baseUrl?: string, timeoutMs?: number): Promise<any>;
 /** Wafermap's resource catalog. Needs no wallet; gives up after `timeoutMs` like every other request. */
 export declare function listResources(baseUrl?: string, timeoutMs?: number): Promise<any[]>;
 export declare class Wafermap {
@@ -103,6 +108,7 @@ export declare class Wafermap {
     readonly timeoutMs: number;
     /** fetch with this wallet's time limit: a server that never answers cannot hold a call forever. */
     readonly fetch: typeof fetch;
+    private readonly tokenPriceUsd?;
     constructor(o: WafermapOptions);
     get address(): `0x${string}`;
     client(n: EvmNet): PublicClient;
@@ -126,8 +132,20 @@ export declare class Wafermap {
     private acquire;
     private paidFetch;
     resources(): Promise<any[]>;
+    private passCache;
+    /** A holder pass (shared/pass.ts) signed by this wallet, valid 24 h and reused until its last 10 minutes. It
+     *  proves the wallet to Wafermap for what its $WAFERMAP unlocks (Pro free calls, x402 Tracker Pro). Signing
+     *  a message moves no funds. */
+    holderPass(): Promise<string>;
+    /** Whether this wallet has approved Permit2 to move its $WAFERMAP (needed once before paying in $WAFERMAP). */
+    wafermapApproved(): Promise<boolean>;
+    /** Approves Permit2 (Uniswap's, at its canonical address) to move this wallet's $WAFERMAP: one on-chain
+     *  transaction on Robinhood Chain, paid in ETH. Each payment after that is a signature for one exact amount,
+     *  spendable only by Wafermap's relayer for two minutes. */
+    approveWafermap(): Promise<string>;
     call(id: string, input?: Record<string, unknown>, o?: {
         network?: Net;
+        payIn?: "stablecoin" | "wafermap";
     }): Promise<{
         resource: string;
         result: any;
@@ -135,10 +153,17 @@ export declare class Wafermap {
             network: string;
             asset: string;
             amountUsd: number;
+            amountTokens?: number;
+            burned?: boolean;
             payer: string;
             tx: string;
             ms: number;
         } | null;
+        free?: {
+            wallet: string;
+            left: number;
+            perDay: number;
+        };
     }>;
     discover(query: string, limit?: number): Promise<{
         url: string;

package/dist/types/src/index.d.ts

@@ -1,5 +1,6 @@
-export { Wafermap, WafermapError, DEFAULT_LIMITS, DEFAULT_TIMEOUT_MS, checkPayment, listResources, mergeLog } from "./core.js";
+export { Wafermap, WafermapError, DEFAULT_LIMITS, DEFAULT_TIMEOUT_MS, checkPayment, holderInfo, listResources, mergeLog } from "./core.js";
+export { PASS_HEADER, passMessage, encodePass, decodePass, makePass } from "../shared/pass";
 export type { Approval, Limits, Net, PaymentStatus, SpendEntry, SwapQuote, Token, WafermapOptions } from "./core.js";
-export { x402fetch, readQuote, choose, signPayment, PAY_CHAINS, MAX_VALIDITY_SECONDS, X402Error } from "../shared/x402client";
+export { x402fetch, readQuote, choose, signPayment, signTokenPayment, wafermapPriceUsd, PAY_CHAINS, MAX_VALIDITY_SECONDS, WAFERMAP_RELAYERS, WAFERMAP_TOKEN, PERMIT2, X402Error } from "../shared/x402client";
 export { quoteSwap, executeSwap, decodeSwap, KYBER_ROUTER, SwapError } from "../shared/swap";
 export type { Requirement, Quote, Signed, SignedAuth, Signer } from "../shared/x402client";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wafermapxyz/cli",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Wafermap for agents: an encrypted local wallet that pays x402 resources, discovers and pays third-party x402 services (USDG on Robinhood Chain; USDC on Solana, Base, Arbitrum, Polygon), and swaps on Robinhood Chain and Base. CLI, SDK and MCP server.",
   "type": "module",
   "bin": {