@wafermapxyz/cli 0.4.11 → 0.4.12

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.4.12 (16 Nov 2026)
+
+**`wafermap call <llm> --metered`: pay only the tokens the model used.**
+
+- Signs one ceiling (x402 scheme `upto`, a Permit2 transfer of at most that much) instead of the flat price. After the model finishes, Wafermap settles only the input and output tokens it reported, never more than the ceiling and never less than $0.001. The confirmation shows the ceiling; the receipt line shows the token counts, what was charged and what was signed.
+- USDC on `base`, `arbitrum` or `polygon` (pick one with `--network`). A wallet that never approved Permit2 for USDC signs an EIP-2612 permit with the payment, so no gas and no extra transaction is needed.
+- The signature can only be spent by the x402 upto proxy (its address is fixed in the client), only to the quote's recipient and only through the facilitator named in the quote, and it expires after at most 5 minutes. Spending caps count the full ceiling, because that is what was signed.
+- Works with `--stream`. Cannot be combined with `--pay wafermap`.
+- SDK: `call(id, input, { metered: true })`; the receipt carries `metered` (`inputTokens`, `outputTokens`, `estimated`, `ceilingUsd`, `chargedUsd`). MCP: `wafermap_call` takes `metered`.
+
 ## 0.4.11 (15 Nov 2026)
 
 **`wafermap statement`: a monthly statement you can check against the chains.**

package/README.md

@@ -86,6 +86,8 @@ Pass `approve: (a) => boolean` to confirm each payment or swap yourself, and `le
 
 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, Arc, Soneium). 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`.
 
+LLM resources can also be **metered**: `wafermap call llama-4-scout prompt="hi" --metered --network base` signs a ceiling (shown before you confirm) and pays only the tokens the model used, at least $0.001, in USDC on Base, Arbitrum or Polygon. No gas needed. Caps count the ceiling. Details: https://wafermap.xyz/docs#metered
+
 LLM resources can **stream**: `wafermap call gemma-4 prompt="hi" --stream` prints the answer as it arrives, and the payment settles only once the model finishes.
 
 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.

package/dist/cli.js

@@ -374,6 +374,36 @@ var init_solana = __esm({
 });
 
 // shared/x402client.ts
+async function signUptoPayment(signer, req, resource, opts = {}) {
+  const fac = String(req.raw?.extra?.facilitatorAddress ?? "");
+  if (!/^0x[0-9a-fA-F]{40}$/.test(fac)) throw new X402Error("bad_quote", "The metered quote names no facilitator. Nothing was signed.");
+  const nonce = BigInt(randomNonce()) >> 8n;
+  const deadline = BigInt(Math.floor(Date.now() / 1e3) + Math.min(req.maxTimeoutSeconds, MAX_METERED_SECONDS));
+  const max = BigInt(req.amount);
+  const witness = { to: req.payTo, facilitator: fac, validAfter: 0n };
+  let signature;
+  try {
+    signature = await signer.signTypedData({ domain: { name: "Permit2", chainId: req.chain.id, verifyingContract: PERMIT2 }, types: UPTO_TYPES, primaryType: "PermitWitnessTransferFrom", message: { permitted: { token: req.asset, amount: max }, spender: UPTO_PROXY, nonce, deadline, witness } });
+  } catch (e) {
+    throw new X402Error("sign_rejected", e?.shortMessage ?? e?.message ?? "Signature rejected.");
+  }
+  let extensions;
+  if (opts.gasless && opts.reader) {
+    const allowance = await opts.reader.allowance(req.chain, signer.address, req.asset).catch(() => 0n);
+    if (allowance < max) {
+      const pn = await opts.reader.permitNonce(req.chain, signer.address, req.asset);
+      let ps;
+      try {
+        ps = await signer.signTypedData({ domain: { name: req.extra.name, version: req.extra.version, chainId: req.chain.id, verifyingContract: req.asset }, types: EIP2612_TYPES, primaryType: "Permit", message: { owner: signer.address, spender: PERMIT2, value: max, nonce: pn, deadline } });
+      } catch (e) {
+        throw new X402Error("sign_rejected", e?.shortMessage ?? e?.message ?? "Signature rejected.");
+      }
+      extensions = { eip2612GasSponsoring: { info: { from: signer.address, asset: req.asset, spender: PERMIT2, amount: max.toString(), nonce: pn.toString(), deadline: deadline.toString(), signature: ps, version: "1" } } };
+    }
+  }
+  const permit2Authorization = { from: signer.address, permitted: { token: req.asset, amount: req.amount }, spender: UPTO_PROXY, nonce: nonce.toString(), deadline: deadline.toString(), witness: { to: req.payTo, facilitator: fac, validAfter: "0" } };
+  return { name: "PAYMENT-SIGNATURE", value: b64encode(JSON.stringify({ x402Version: 2, resource, accepted: req.raw, payload: { signature, permit2Authorization }, ...extensions ? { extensions } : {} })), deadline: Number(deadline) };
+}
 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);
@@ -421,12 +451,19 @@ async function readQuote(res) {
   const accepts = [];
   const offered = [];
   let token;
+  const metered = [];
   for (const r of body.accepts) {
     offered.push(`${r.scheme ?? "?"}/${r.network ?? "?"}`);
     if (r?.scheme === TOKEN_SCHEME) {
       token ??= tokenOption(r);
       continue;
     }
+    if (r?.scheme === "upto" && version === 2) {
+      const ch = chainOf(r.network);
+      if (ch && ch.vm === "evm" && String(r.asset ?? "").toLowerCase() === ch.stable.toLowerCase() && /^\d+$/.test(String(r.amount)) && /^0x[0-9a-fA-F]{40}$/.test(String(r.extra?.facilitatorAddress ?? "")) && /^0x[0-9a-fA-F]{40}$/.test(String(r.payTo ?? "")))
+        metered.push({ version, chain: ch, amount: String(r.amount), usd: Number(r.amount) / 1e6, payTo: r.payTo, asset: r.asset, maxTimeoutSeconds: Number(r.maxTimeoutSeconds) || 120, extra: r.extra?.name && r.extra?.version ? { name: String(r.extra.name), version: String(r.extra.version) } : ch.domain, raw: 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;
@@ -440,7 +477,10 @@ 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, ...token ? { token } : {} };
+  const m = body.metered;
+  const meterInfo = m && Number.isFinite(Number(m.ceilingUsd)) ? { inputPer1kTokensUsd: Number(m.inputPer1kTokensUsd), outputPer1kTokensUsd: Number(m.outputPer1kTokensUsd), ceilingUsd: Number(m.ceilingUsd), minimumUsd: Number(m.minimumUsd) } : void 0;
+  const gasless = !!body.extensions?.eip2612GasSponsoring;
+  return { version, resource: body.resource ?? null, accepts, offered, inputError, ...token ? { token } : {}, ...metered.length ? { metered: metered.map((q) => ({ ...q, gasless })) } : {}, ...meterInfo ? { meterInfo } : {} };
 }
 function choose(q, prefer = CHAIN_KEYS) {
   for (const k of prefer) {
@@ -512,6 +552,20 @@ async function x402fetch(url, init, opts) {
     const res2 = await f(url, { ...init, headers: headers2 });
     return { res: res2, paid: { ...signed2, tx: readSettlement(res2)?.tx ?? null } };
   }
+  if (opts.meter) {
+    const pref = (opts.prefer ?? CHAIN_KEYS).filter((k) => k !== "solana");
+    const req2 = pref.map((k) => quote.metered?.find((q) => q.chain.key === k)).find(Boolean);
+    if (!req2) throw new X402Error("metered_not_offered", quote.metered?.length ? `Metered calls are offered on ${quote.metered.map((q) => q.chain.name).join(", ")}; pick one of those networks.` : "This call is not offered as a metered (pay per token) call. Pay the flat price instead.");
+    if (opts.approve) await opts.approve(req2);
+    const signer2 = typeof opts.signer === "function" ? await opts.signer() : opts.signer;
+    const header2 = await signUptoPayment(signer2, req2, quote.resource, { reader: opts.reader, gasless: !!req2.gasless });
+    const signed2 = { req: req2, from: signer2.address, metered: { ceiling: req2.amount, deadline: header2.deadline } };
+    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";
@@ -524,7 +578,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, WAFERMAP_TOKEN, PERMIT2, DEAD, TOKEN_SCHEME, WAFERMAP_RELAYERS, TOKEN_VALUE_SLACK, PERMIT_TYPES, X402Error, b64encode, b64decode, TYPES, MAX_VALIDITY_SECONDS, randomNonce;
+var USDC_DOMAIN, PAY_CHAINS, EVM_CHAINS, CHAIN_KEYS, UPTO_PROXY, MAX_METERED_SECONDS, UPTO_TYPES, EIP2612_TYPES, 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";
@@ -542,6 +596,35 @@ var init_x402client = __esm({
     ];
     EVM_CHAINS = PAY_CHAINS.filter((c) => c.vm === "evm");
     CHAIN_KEYS = PAY_CHAINS.map((c) => c.key);
+    UPTO_PROXY = "0x4020A4f3b7b90ccA423B9fabCc0CE57C6C240002";
+    MAX_METERED_SECONDS = 300;
+    UPTO_TYPES = {
+      PermitWitnessTransferFrom: [
+        { name: "permitted", type: "TokenPermissions" },
+        { name: "spender", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+        { name: "witness", type: "Witness" }
+      ],
+      TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" }
+      ],
+      Witness: [
+        { name: "to", type: "address" },
+        { name: "facilitator", type: "address" },
+        { name: "validAfter", type: "uint256" }
+      ]
+    };
+    EIP2612_TYPES = {
+      Permit: [
+        { name: "owner", type: "address" },
+        { name: "spender", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ]
+    };
     WAFERMAP_TOKEN = "0xfda080f64d84c989cfc50ff18253542cfe502db3";
     PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
     DEAD = "0x000000000000000000000000000000000000dEaD";
@@ -858,7 +941,15 @@ var init_core = __esm({
         this.queue = prev.then(() => held);
         return prev.then(() => release);
       }
-      async paidFetch(kind, what, url, init, network, payIn) {
+      /** Chain reads for a metered payment's EIP-2612 permit: Permit2 allowance and the token's permit nonce. */
+      reader() {
+        const nonces = [{ type: "function", name: "nonces", stateMutability: "view", inputs: [{ name: "owner", type: "address" }], outputs: [{ type: "uint256" }] }];
+        return {
+          allowance: (chain, owner, token) => this.client(chain.key).readContract({ address: token, abi: erc20Abi2, functionName: "allowance", args: [owner, PERMIT2] }),
+          permitNonce: (chain, owner, token) => this.client(chain.key).readContract({ address: token, abi: nonces, functionName: "nonces", args: [owner] })
+        };
+      }
+      async paidFetch(kind, what, url, init, network, payIn, meter) {
         let id = null;
         let release = null;
         const unlock = () => {
@@ -872,10 +963,12 @@ var init_core = __esm({
             prefer: this.prefer(network),
             fetch: this.fetch,
             payIn,
+            meter,
+            reader: meter ? this.reader() : void 0,
             tokenPriceUsd: this.tokenPriceUsd,
             approve: async (req) => {
               release = await this.acquire();
-              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}` });
+              await this.gate({ kind, what, usd: req.usd, network: req.chain.key, detail: req.asset === WAFERMAP_TOKEN ? "in $WAFERMAP at 50% off, burned" : meter ? `at most ${req.chain.symbol} ${req.usd}, charged for the tokens used, to ${req.payTo}` : `${req.chain.symbol} to ${req.payTo}` });
             },
             onSigned: (s) => {
               id = this.booked(kind, what, s);
@@ -963,11 +1056,12 @@ var init_core = __esm({
       }
       async call(id, input = {}, o = {}) {
         const inToken = o.payIn === "wafermap";
+        if (o.metered && inToken) throw new WafermapError("bad_options", "A metered call is paid in USDC; it cannot also be paid in $WAFERMAP.");
         const stream = !!o.onDelta && !inToken;
         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, ...stream ? { accept: "text/event-stream" } : {}, ...pass ? { [PASS_HEADER]: pass } : {} }, body: JSON.stringify(input) }, o.network, inToken ? "wafermap" : void 0);
+        const go = () => this.paidFetch("resource", id, `${this.baseUrl}/v1/${id}`, { method: "POST", headers: { "content-type": "application/json", "x-wafermap-payer": this.address, ...stream ? { accept: "text/event-stream" } : {}, ...pass ? { [PASS_HEADER]: pass } : {} }, body: JSON.stringify(input) }, o.network, inToken ? "wafermap" : void 0, o.metered);
         const settle = (r2, out2) => {
           if (!r2.paid || !r2.id) return;
           const status = r2.res.status === 402 ? "refused" : r2.res.ok && !out2?.streamError ? "ok" : "failed";
@@ -1288,7 +1382,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "0.4.11";
+    VERSION = "0.4.12";
   }
 });
 
@@ -1504,12 +1598,13 @@ async function runMcp() {
         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.")
+        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."),
+        metered: z.boolean().optional().describe("LLM resources only: sign a ceiling and pay only the tokens the model used (USDC on base, arbitrum or polygon; no gas needed). Caps count the ceiling.")
       }
     },
-    async ({ resource, input, network, payIn }) => {
+    async ({ resource, input, network, payIn, metered }) => {
       try {
-        return result(await wm.call(resource, input ?? {}, { network, payIn }));
+        return result(await wm.call(resource, input ?? {}, { network, payIn, metered }));
       } catch (e) {
         return failure(e);
       }
@@ -1965,6 +2060,7 @@ 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 call <llm> ... --metered      pay only the tokens used, up to a ceiling you sign (USDC on base, arbitrum, polygon)
   wafermap call <llm> ... --stream       print the answer as it arrives; you pay only once the model finishes
   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
@@ -1987,7 +2083,7 @@ function parse(argv) {
     if (a.startsWith("--")) {
       const [k, v] = a.slice(2).split("=", 2);
       if (v !== void 0) out.flags[k] = v;
-      else if (argv[i + 1] && !argv[i + 1].startsWith("--") && !["yes", "post", "import", "stream"].includes(k)) out.flags[k] = argv[++i];
+      else if (argv[i + 1] && !argv[i + 1].startsWith("--") && !["yes", "post", "import", "stream", "metered"].includes(k)) out.flags[k] = argv[++i];
       else out.flags[k] = true;
     } else out._.push(a);
   }
@@ -2271,9 +2367,11 @@ ${month}: ${out.totals.calls} paid calls, $${out.totals.usd}.${out.lines.length
       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)");
       let streamed = false;
       const onDelta = a.flags.stream === true ? (t) => (streamed = true, process.stdout.write(t)) : void 0;
-      const out = await wm.call(id, inputOf(a, 1), { network: net(a.flags.network), payIn, onDelta });
+      const metered = a.flags.metered === true;
+      const out = await wm.call(id, inputOf(a, 1), { network: net(a.flags.network), payIn, onDelta, metered });
       if (streamed) process.stdout.write("\n");
       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?.metered) console.error(`\u2713 Paid $${out.receipt.amountUsd} ${out.receipt.asset} for ${out.receipt.metered.inputTokens} in + ${out.receipt.metered.outputTokens} out tokens${out.receipt.metered.estimated ? " (estimated)" : ""}, signed up to $${out.receipt.metered.ceilingUsd} \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);

package/dist/index.js

@@ -364,6 +364,65 @@ var PAY_CHAINS = [
 ];
 var EVM_CHAINS = PAY_CHAINS.filter((c) => c.vm === "evm");
 var CHAIN_KEYS = PAY_CHAINS.map((c) => c.key);
+var UPTO_PROXY = "0x4020A4f3b7b90ccA423B9fabCc0CE57C6C240002";
+var MAX_METERED_SECONDS = 300;
+var UPTO_TYPES = {
+  PermitWitnessTransferFrom: [
+    { name: "permitted", type: "TokenPermissions" },
+    { name: "spender", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "witness", type: "Witness" }
+  ],
+  TokenPermissions: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint256" }
+  ],
+  Witness: [
+    { name: "to", type: "address" },
+    { name: "facilitator", type: "address" },
+    { name: "validAfter", type: "uint256" }
+  ]
+};
+var EIP2612_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+async function signUptoPayment(signer, req, resource, opts = {}) {
+  const fac = String(req.raw?.extra?.facilitatorAddress ?? "");
+  if (!/^0x[0-9a-fA-F]{40}$/.test(fac)) throw new X402Error("bad_quote", "The metered quote names no facilitator. Nothing was signed.");
+  const nonce = BigInt(randomNonce()) >> 8n;
+  const deadline = BigInt(Math.floor(Date.now() / 1e3) + Math.min(req.maxTimeoutSeconds, MAX_METERED_SECONDS));
+  const max = BigInt(req.amount);
+  const witness = { to: req.payTo, facilitator: fac, validAfter: 0n };
+  let signature;
+  try {
+    signature = await signer.signTypedData({ domain: { name: "Permit2", chainId: req.chain.id, verifyingContract: PERMIT2 }, types: UPTO_TYPES, primaryType: "PermitWitnessTransferFrom", message: { permitted: { token: req.asset, amount: max }, spender: UPTO_PROXY, nonce, deadline, witness } });
+  } catch (e) {
+    throw new X402Error("sign_rejected", e?.shortMessage ?? e?.message ?? "Signature rejected.");
+  }
+  let extensions;
+  if (opts.gasless && opts.reader) {
+    const allowance = await opts.reader.allowance(req.chain, signer.address, req.asset).catch(() => 0n);
+    if (allowance < max) {
+      const pn = await opts.reader.permitNonce(req.chain, signer.address, req.asset);
+      let ps;
+      try {
+        ps = await signer.signTypedData({ domain: { name: req.extra.name, version: req.extra.version, chainId: req.chain.id, verifyingContract: req.asset }, types: EIP2612_TYPES, primaryType: "Permit", message: { owner: signer.address, spender: PERMIT2, value: max, nonce: pn, deadline } });
+      } catch (e) {
+        throw new X402Error("sign_rejected", e?.shortMessage ?? e?.message ?? "Signature rejected.");
+      }
+      extensions = { eip2612GasSponsoring: { info: { from: signer.address, asset: req.asset, spender: PERMIT2, amount: max.toString(), nonce: pn.toString(), deadline: deadline.toString(), signature: ps, version: "1" } } };
+    }
+  }
+  const permit2Authorization = { from: signer.address, permitted: { token: req.asset, amount: req.amount }, spender: UPTO_PROXY, nonce: nonce.toString(), deadline: deadline.toString(), witness: { to: req.payTo, facilitator: fac, validAfter: "0" } };
+  return { name: "PAYMENT-SIGNATURE", value: b64encode(JSON.stringify({ x402Version: 2, resource, accepted: req.raw, payload: { signature, permit2Authorization }, ...extensions ? { extensions } : {} })), deadline: Number(deadline) };
+}
 var WAFERMAP_TOKEN = "0xfda080f64d84c989cfc50ff18253542cfe502db3";
 var PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
 var DEAD = "0x000000000000000000000000000000000000dEaD";
@@ -443,12 +502,19 @@ async function readQuote(res) {
   const accepts = [];
   const offered = [];
   let token;
+  const metered = [];
   for (const r of body.accepts) {
     offered.push(`${r.scheme ?? "?"}/${r.network ?? "?"}`);
     if (r?.scheme === TOKEN_SCHEME) {
       token ??= tokenOption(r);
       continue;
     }
+    if (r?.scheme === "upto" && version === 2) {
+      const ch = chainOf(r.network);
+      if (ch && ch.vm === "evm" && String(r.asset ?? "").toLowerCase() === ch.stable.toLowerCase() && /^\d+$/.test(String(r.amount)) && /^0x[0-9a-fA-F]{40}$/.test(String(r.extra?.facilitatorAddress ?? "")) && /^0x[0-9a-fA-F]{40}$/.test(String(r.payTo ?? "")))
+        metered.push({ version, chain: ch, amount: String(r.amount), usd: Number(r.amount) / 1e6, payTo: r.payTo, asset: r.asset, maxTimeoutSeconds: Number(r.maxTimeoutSeconds) || 120, extra: r.extra?.name && r.extra?.version ? { name: String(r.extra.name), version: String(r.extra.version) } : ch.domain, raw: 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;
@@ -462,7 +528,10 @@ 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, ...token ? { token } : {} };
+  const m = body.metered;
+  const meterInfo = m && Number.isFinite(Number(m.ceilingUsd)) ? { inputPer1kTokensUsd: Number(m.inputPer1kTokensUsd), outputPer1kTokensUsd: Number(m.outputPer1kTokensUsd), ceilingUsd: Number(m.ceilingUsd), minimumUsd: Number(m.minimumUsd) } : void 0;
+  const gasless = !!body.extensions?.eip2612GasSponsoring;
+  return { version, resource: body.resource ?? null, accepts, offered, inputError, ...token ? { token } : {}, ...metered.length ? { metered: metered.map((q) => ({ ...q, gasless })) } : {}, ...meterInfo ? { meterInfo } : {} };
 }
 function choose(q, prefer = CHAIN_KEYS) {
   for (const k of prefer) {
@@ -546,6 +615,20 @@ async function x402fetch(url, init, opts) {
     const res2 = await f(url, { ...init, headers: headers2 });
     return { res: res2, paid: { ...signed2, tx: readSettlement(res2)?.tx ?? null } };
   }
+  if (opts.meter) {
+    const pref = (opts.prefer ?? CHAIN_KEYS).filter((k) => k !== "solana");
+    const req2 = pref.map((k) => quote.metered?.find((q) => q.chain.key === k)).find(Boolean);
+    if (!req2) throw new X402Error("metered_not_offered", quote.metered?.length ? `Metered calls are offered on ${quote.metered.map((q) => q.chain.name).join(", ")}; pick one of those networks.` : "This call is not offered as a metered (pay per token) call. Pay the flat price instead.");
+    if (opts.approve) await opts.approve(req2);
+    const signer2 = typeof opts.signer === "function" ? await opts.signer() : opts.signer;
+    const header2 = await signUptoPayment(signer2, req2, quote.resource, { reader: opts.reader, gasless: !!req2.gasless });
+    const signed2 = { req: req2, from: signer2.address, metered: { ceiling: req2.amount, deadline: header2.deadline } };
+    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";
@@ -797,7 +880,15 @@ var Wafermap = class {
     this.queue = prev.then(() => held);
     return prev.then(() => release);
   }
-  async paidFetch(kind, what, url, init, network, payIn) {
+  /** Chain reads for a metered payment's EIP-2612 permit: Permit2 allowance and the token's permit nonce. */
+  reader() {
+    const nonces = [{ type: "function", name: "nonces", stateMutability: "view", inputs: [{ name: "owner", type: "address" }], outputs: [{ type: "uint256" }] }];
+    return {
+      allowance: (chain, owner, token) => this.client(chain.key).readContract({ address: token, abi: erc20Abi2, functionName: "allowance", args: [owner, PERMIT2] }),
+      permitNonce: (chain, owner, token) => this.client(chain.key).readContract({ address: token, abi: nonces, functionName: "nonces", args: [owner] })
+    };
+  }
+  async paidFetch(kind, what, url, init, network, payIn, meter) {
     let id = null;
     let release = null;
     const unlock = () => {
@@ -811,10 +902,12 @@ var Wafermap = class {
         prefer: this.prefer(network),
         fetch: this.fetch,
         payIn,
+        meter,
+        reader: meter ? this.reader() : void 0,
         tokenPriceUsd: this.tokenPriceUsd,
         approve: async (req) => {
           release = await this.acquire();
-          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}` });
+          await this.gate({ kind, what, usd: req.usd, network: req.chain.key, detail: req.asset === WAFERMAP_TOKEN ? "in $WAFERMAP at 50% off, burned" : meter ? `at most ${req.chain.symbol} ${req.usd}, charged for the tokens used, to ${req.payTo}` : `${req.chain.symbol} to ${req.payTo}` });
         },
         onSigned: (s) => {
           id = this.booked(kind, what, s);
@@ -902,11 +995,12 @@ var Wafermap = class {
   }
   async call(id, input = {}, o = {}) {
     const inToken = o.payIn === "wafermap";
+    if (o.metered && inToken) throw new WafermapError("bad_options", "A metered call is paid in USDC; it cannot also be paid in $WAFERMAP.");
     const stream = !!o.onDelta && !inToken;
     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, ...stream ? { accept: "text/event-stream" } : {}, ...pass ? { [PASS_HEADER]: pass } : {} }, body: JSON.stringify(input) }, o.network, inToken ? "wafermap" : void 0);
+    const go = () => this.paidFetch("resource", id, `${this.baseUrl}/v1/${id}`, { method: "POST", headers: { "content-type": "application/json", "x-wafermap-payer": this.address, ...stream ? { accept: "text/event-stream" } : {}, ...pass ? { [PASS_HEADER]: pass } : {} }, body: JSON.stringify(input) }, o.network, inToken ? "wafermap" : void 0, o.metered);
     const settle = (r2, out2) => {
       if (!r2.paid || !r2.id) return;
       const status = r2.res.status === 402 ? "refused" : r2.res.ok && !out2?.streamError ? "ok" : "failed";

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

@@ -46,6 +46,8 @@ export type Requirement = {
     };
     /** The requirement exactly as the server sent it (echoed back in the payment). */
     raw: any;
+    /** Metered quotes only: the server announced eip2612GasSponsoring, so a missing Permit2 approval can be signed. */
+    gasless?: boolean;
 };
 export type Quote = {
     version: 1 | 2;
@@ -57,7 +59,33 @@ export type Quote = {
         message: string;
     };
     token?: TokenRequirement;
+    metered?: Requirement[];
+    meterInfo?: MeterInfo;
 };
+export declare const UPTO_PROXY = "0x4020A4f3b7b90ccA423B9fabCc0CE57C6C240002";
+/** The longest a metered authorization stays valid: long answers settle after the model finishes. */
+export declare const MAX_METERED_SECONDS = 300;
+export type MeterInfo = {
+    inputPer1kTokensUsd: number;
+    outputPer1kTokensUsd: number;
+    ceilingUsd: number;
+    minimumUsd: number;
+};
+/** Reads the client needs for an EIP-2612 permit: the owner's Permit2 allowance and its permit nonce on the token. */
+export type ChainReader = {
+    allowance: (chain: Chain, owner: Hex, token: Hex) => Promise<bigint>;
+    permitNonce: (chain: Chain, owner: Hex, token: Hex) => Promise<bigint>;
+};
+/** Signs a metered payment for at most `req.amount` (the ceiling). Adds an EIP-2612 permit when the Permit2
+ *  allowance is short and the server announced eip2612GasSponsoring. */
+export declare function signUptoPayment(signer: Signer, req: Requirement, resource: any, opts?: {
+    reader?: ChainReader;
+    gasless?: boolean;
+}): Promise<{
+    name: string;
+    value: string;
+    deadline: number;
+}>;
 export declare const WAFERMAP_TOKEN = "0xfda080f64d84c989cfc50ff18253542cfe502db3";
 export declare const PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
 export declare const DEAD = "0x000000000000000000000000000000000000dEaD";
@@ -123,6 +151,10 @@ export type SignedSol = {
 export type Signed = {
     req: Requirement;
     from: string;
+    metered?: {
+        ceiling: string;
+        deadline: number;
+    };
     auth?: SignedAuth;
     sol?: SignedSol;
     token?: {
@@ -151,4 +183,6 @@ export declare function x402fetch(url: string, init: RequestInit, opts: {
     fetch?: typeof fetch;
     payIn?: "stablecoin" | "wafermap";
     tokenPriceUsd?: () => Promise<number>;
+    meter?: boolean;
+    reader?: ChainReader;
 }): Promise<PaidCall>;

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

@@ -142,6 +142,8 @@ export declare class Wafermap {
     private body;
     private queue;
     private acquire;
+    /** Chain reads for a metered payment's EIP-2612 permit: Permit2 allowance and the token's permit nonce. */
+    private reader;
     private paidFetch;
     resources(): Promise<any[]>;
     private passCache;
@@ -161,6 +163,7 @@ export declare class Wafermap {
         network?: Net;
         payIn?: "stablecoin" | "wafermap";
         onDelta?: (text: string) => void;
+        metered?: boolean;
     }): Promise<{
         resource: string;
         result: any;
@@ -173,6 +176,13 @@ export declare class Wafermap {
             payer: string;
             tx: string;
             ms: number;
+            metered?: {
+                inputTokens: number;
+                outputTokens: number;
+                estimated: boolean;
+                ceilingUsd: number;
+                chargedUsd: number;
+            };
         } | null;
         free?: {
             wallet: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wafermapxyz/cli",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "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, Arc, Soneium), and swaps on Robinhood Chain and Base. CLI, SDK and MCP server.",
   "type": "module",
   "bin": {