mtok-relay 0.1.2 → 0.1.3

package/dist/mtok-relay.mjs

@@ -1,32 +1,6 @@
 #!/usr/bin/env node
 // GENERATED from mtok-relay.mjs — do not edit by hand.
 
-// mtok-relay.mjs
-import http from "node:http";
-
-// lib.mjs
-function enforceModelEcho(upstreamModel, offerModel) {
-  if (String(upstreamModel) !== String(offerModel))
-    throw new Error(`model mismatch: upstream ${upstreamModel} != offer ${offerModel}`);
-}
-var buildFundReport = ({ offerId: offerId2, buyerId, bookingId, n, priceUsd, sellerTxHash, feeTxHash }) => ({
-  offerId: offerId2,
-  buyerId,
-  ...bookingId ? { bookingId } : {},
-  n,
-  priceUsd,
-  sellerTxHash,
-  feeTxHash
-});
-var buildDrawReport = ({ offerId: offerId2, buyerId, bookingId, n, usage }) => ({
-  offerId: offerId2,
-  buyerId,
-  bookingId,
-  n,
-  inputTokens: usage?.prompt_tokens ?? 0,
-  outputTokens: usage?.completion_tokens ?? 0
-});
-
 // node_modules/@noble/hashes/esm/cryptoNode.js
 import * as nc from "node:crypto";
 var crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
@@ -346,11 +320,11 @@ function validateObject(object, validators, optValidators = {}) {
 }
 function memoized(fn) {
   const map = /* @__PURE__ */ new WeakMap();
-  return (arg, ...args2) => {
+  return (arg, ...args) => {
     const val = map.get(arg);
     if (val !== void 0)
       return val;
-    const computed = fn(arg, ...args2);
+    const computed = fn(arg, ...args);
     map.set(arg, computed);
     return computed;
   };
@@ -2183,7 +2157,7 @@ var secp256k1 = createCurve({
 }, sha256);
 
 // node_modules/viem/_esm/errors/version.js
-var version = "2.53.1";
+var version = "2.54.3";
 
 // node_modules/viem/_esm/errors/base.js
 var errorConfig = {
@@ -2191,29 +2165,29 @@ var errorConfig = {
   version: `viem@${version}`
 };
 var BaseError = class _BaseError extends Error {
-  constructor(shortMessage, args2 = {}) {
+  constructor(shortMessage, args = {}) {
     const details = (() => {
-      if (args2.cause instanceof _BaseError)
-        return args2.cause.details;
-      if (args2.cause?.message)
-        return args2.cause.message;
-      return args2.details;
+      if (args.cause instanceof _BaseError)
+        return args.cause.details;
+      if (args.cause?.message)
+        return args.cause.message;
+      return args.details;
     })();
     const docsPath = (() => {
-      if (args2.cause instanceof _BaseError)
-        return args2.cause.docsPath || args2.docsPath;
-      return args2.docsPath;
+      if (args.cause instanceof _BaseError)
+        return args.cause.docsPath || args.docsPath;
+      return args.docsPath;
     })();
-    const docsUrl = errorConfig.getDocsUrl?.({ ...args2, docsPath });
+    const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath });
     const message = [
       shortMessage || "An error occurred.",
       "",
-      ...args2.metaMessages ? [...args2.metaMessages, ""] : [],
+      ...args.metaMessages ? [...args.metaMessages, ""] : [],
       ...docsUrl ? [`Docs: ${docsUrl}`] : [],
       ...details ? [`Details: ${details}`] : [],
       ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
     ].join("\n");
-    super(message, args2.cause ? { cause: args2.cause } : void 0);
+    super(message, args.cause ? { cause: args.cause } : void 0);
     Object.defineProperty(this, "details", {
       enumerable: true,
       configurable: true,
@@ -2252,8 +2226,8 @@ var BaseError = class _BaseError extends Error {
     });
     this.details = details;
     this.docsPath = docsPath;
-    this.metaMessages = args2.metaMessages;
-    this.name = args2.name ?? this.name;
+    this.metaMessages = args.metaMessages;
+    this.name = args.name ?? this.name;
     this.shortMessage = shortMessage;
     this.version = version;
   }
@@ -3268,8 +3242,8 @@ function formatGwei(wei, unit = "wei") {
 }
 
 // node_modules/viem/_esm/errors/transaction.js
-function prettyPrint(args2) {
-  const entries = Object.entries(args2).map(([key, value]) => {
+function prettyPrint(args) {
+  const entries = Object.entries(args).map(([key, value]) => {
     if (value === void 0 || value === false)
       return null;
     return [key, value];
@@ -4193,10 +4167,7 @@ function encodeAbiParameters(params, values) {
     params,
     values
   });
-  const data = encodeParams(preparedParams);
-  if (data.length === 0)
-    return "0x";
-  return data;
+  return encodeParams(preparedParams);
 }
 function prepareParams({ params, values }) {
   const preparedParams = [];
@@ -4262,7 +4233,7 @@ function encodeParams(preparedParams) {
       staticParams.push(encoded);
     }
   }
-  return concat([...staticParams, ...dynamicParams]);
+  return concatHex([...staticParams, ...dynamicParams]);
 }
 function encodeAddress(value) {
   if (!isAddress(value))
@@ -4279,7 +4250,7 @@ function encodeArray(value, { length, param }) {
       givenLength: value.length,
       type: `${param.type}[${length}]`
     });
-  let dynamicChild = false;
+  let dynamicChild = value.length === 0 && isDynamicType(param);
   const preparedParams = [];
   for (let i = 0; i < value.length; i++) {
     const preparedParam = prepareParam({ param, value: value[i] });
@@ -4293,7 +4264,7 @@ function encodeArray(value, { length, param }) {
       const length2 = numberToHex(preparedParams.length, { size: 32 });
       return {
         dynamic: true,
-        encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
+        encoded: concatHex([length2, data])
       };
     }
     if (dynamicChild)
@@ -4301,7 +4272,7 @@ function encodeArray(value, { length, param }) {
   }
   return {
     dynamic: false,
-    encoded: concat(preparedParams.map(({ encoded }) => encoded))
+    encoded: concatHex(preparedParams.map(({ encoded }) => encoded))
   };
 }
 function encodeBytes(value, { param }) {
@@ -4316,7 +4287,10 @@ function encodeBytes(value, { param }) {
       });
     return {
       dynamic: true,
-      encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
+      encoded: concatHex([
+        padHex(numberToHex(bytesSize, { size: 32 })),
+        value_
+      ])
     };
   }
   if (bytesSize !== Number.parseInt(paramSize, 10))
@@ -4363,7 +4337,7 @@ function encodeString(value) {
   }
   return {
     dynamic: true,
-    encoded: concat([
+    encoded: concatHex([
       padHex(numberToHex(size(hexValue), { size: 32 })),
       ...parts
     ])
@@ -4385,7 +4359,7 @@ function encodeTuple(value, { param }) {
   }
   return {
     dynamic,
-    encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
+    encoded: dynamic ? encodeParams(preparedParams) : concatHex(preparedParams.map(({ encoded }) => encoded))
   };
 }
 function getArrayComponents(type) {
@@ -4395,6 +4369,21 @@ function getArrayComponents(type) {
     [matches[2] ? Number(matches[2]) : null, matches[1]]
   ) : void 0;
 }
+function isDynamicType(param) {
+  const { type } = param;
+  if (type === "string")
+    return true;
+  if (type === "bytes")
+    return true;
+  if (type.endsWith("[]"))
+    return true;
+  if (type === "tuple")
+    return param.components.some(isDynamicType);
+  const arrayComponents = getArrayComponents(type);
+  if (arrayComponents)
+    return isDynamicType({ ...param, type: arrayComponents[1] });
+  return false;
+}
 
 // node_modules/viem/_esm/utils/stringify.js
 var stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
@@ -4643,6 +4632,223 @@ function privateKeyToAccount(privateKey, options = {}) {
   };
 }
 
+// src/config.mjs
+var flag = (args, name) => {
+  const i = args.indexOf(name);
+  return i !== -1 ? args[i + 1] : null;
+};
+function readRelayConfig({ argv = process.argv.slice(2), env = process.env } = {}) {
+  const offerId = flag(argv, "--offer");
+  const model = flag(argv, "--model");
+  const upstream = (flag(argv, "--upstream") ?? "").replace(/\/$/, "");
+  const apiBase = (flag(argv, "--api") ?? "https://mtok.market").replace(/\/$/, "");
+  const port = Number(flag(argv, "--port") ?? 8788);
+  const rpcFlag = flag(argv, "--rpc");
+  const settlementPubkeyFlag = flag(argv, "--settlement-pubkey");
+  const outPrice = Number(flag(argv, "--out-price") ?? 0);
+  const inPrice = Number(flag(argv, "--in-price") ?? outPrice);
+  const redemptionFile = flag(argv, "--redemption-file") ?? env.RELAY_REDEMPTION_FILE ?? null;
+  const denylistRaw = flag(argv, "--payer-denylist") ?? env.RELAY_PAYER_DENYLIST ?? "";
+  const payerDenylist = String(denylistRaw).split(",").map((a) => a.trim().toLowerCase()).filter(Boolean);
+  if (!offerId) throw new Error("--offer <id> is required");
+  if (!model) throw new Error("--model <id> is required (the offer model you serve)");
+  if (!upstream) throw new Error("--upstream <url> is required");
+  const mtokApiKey = env.MTOK_API_KEY;
+  const upstreamKey = env.UPSTREAM_KEY;
+  const relayWalletKey = env.RELAY_WALLET_KEY;
+  if (!upstreamKey) throw new Error("UPSTREAM_KEY env var is required");
+  if (!relayWalletKey && !settlementPubkeyFlag) {
+    throw new Error("RELAY_WALLET_KEY env var (or --settlement-pubkey) is required");
+  }
+  let settlementAddr = settlementPubkeyFlag;
+  if (!settlementAddr) {
+    try {
+      settlementAddr = privateKeyToAccount(relayWalletKey.startsWith("0x") ? relayWalletKey : "0x" + relayWalletKey).address;
+    } catch (e) {
+      throw new Error(`invalid RELAY_WALLET_KEY: ${e.message}`);
+    }
+  }
+  return {
+    offerId,
+    model,
+    upstream,
+    apiBase,
+    port,
+    rpcFlag,
+    outPrice,
+    inPrice,
+    redemptionFile,
+    mtokApiKey,
+    upstreamKey,
+    settlementAddr,
+    payerDenylist
+  };
+}
+
+// src/http.mjs
+import http from "node:http";
+var MAX_BODY_BYTES = 256e3;
+function readBody(req, { maxBytes = MAX_BODY_BYTES } = {}) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    let settled = false;
+    req.on("data", (d) => {
+      bytes += d.length;
+      if (bytes > maxBytes && !settled) {
+        settled = true;
+        reject(Object.assign(new Error("body_too_large"), { code: "body_too_large" }));
+        req.resume();
+        return;
+      }
+      if (settled) return;
+      chunks.push(d);
+    });
+    req.on("end", () => {
+      if (settled) return;
+      settled = true;
+      const raw = Buffer.concat(chunks).toString("utf8");
+      try {
+        resolve(JSON.parse(raw || "{}"));
+      } catch {
+        resolve({});
+      }
+    });
+    req.on("error", (e) => {
+      if (settled) return;
+      settled = true;
+      reject(e);
+    });
+  });
+}
+function send(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, { "content-type": "application/json", "content-length": Buffer.byteLength(payload) });
+  res.end(payload);
+}
+function startRelayServer({ config, handleDraw }) {
+  const windows = /* @__PURE__ */ new Map();
+  const windowMs = 6e4;
+  const maxPerMinute = Number(config.maxRequestsPerMinute ?? 120);
+  const checkRate = (req) => {
+    if (!Number.isFinite(maxPerMinute)) return true;
+    const key = req.socket.remoteAddress || "unknown";
+    const now = Date.now();
+    let w = windows.get(key);
+    if (!w || now - w.start >= windowMs) {
+      w = { start: now, count: 0 };
+      windows.set(key, w);
+      if (windows.size > 1e4) {
+        for (const [k, v] of windows) if (now - v.start >= windowMs) windows.delete(k);
+      }
+    }
+    w.count += 1;
+    return w.count <= maxPerMinute;
+  };
+  const server = http.createServer(async (req, res) => {
+    if (req.method !== "POST" || req.url !== "/chunk") {
+      return send(res, 404, { error: "not found" });
+    }
+    if (!checkRate(req)) return send(res, 429, { error: "rate_limited" });
+    let body;
+    try {
+      body = await readBody(req);
+    } catch (e) {
+      if (e?.code === "body_too_large") return send(res, 413, { error: "body_too_large" });
+      return send(res, 400, { error: "bad body" });
+    }
+    if (body.request == null) {
+      return send(res, 400, { error: "bad_request", detail: "need a DRAW (request); the legacy FUND lane is retired, pay per draw on-chain" });
+    }
+    return handleDraw(body, res);
+  });
+  server.listen(config.port, () => {
+    console.log(`mtok-relay: listening on port ${config.port}  offer=${config.offerId}  model=${config.model}  upstream=${config.upstream}  api=${config.apiBase}  settlement=${config.settlementAddr}`);
+  });
+  return server;
+}
+
+// lib.mjs
+function enforceModelEcho(upstreamModel, offerModel) {
+  if (String(upstreamModel) !== String(offerModel))
+    throw new Error(`model mismatch: upstream ${upstreamModel} != offer ${offerModel}`);
+}
+function configuredFeeAtomic({ sellerUsdAtomic, feeAddress, feeBps }) {
+  const bps = BigInt(Math.trunc(Math.max(0, Number(feeBps) || 0)));
+  if (!feeAddress || bps === 0n) return 0n;
+  return (BigInt(sellerUsdAtomic || 0) * bps + 5000n) / 10000n;
+}
+var CHARS_PER_TOKEN_EST = 3.2;
+function estimateInputTokens(messages) {
+  let chars = 0;
+  for (const m of messages ?? []) {
+    const c = m?.content;
+    if (typeof c === "string") chars += c.length;
+    else if (Array.isArray(c)) for (const part of c) chars += String(part?.text ?? "").length;
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN_EST);
+}
+function boundServe({ messages, budgetUsd, inPrice, outPrice, reqMax, contextCeil = 4096 }) {
+  const estIn = estimateInputTokens(messages);
+  const estInCostUsd = estIn * (Number(inPrice) > 0 ? Number(inPrice) : 0) / 1e6;
+  if (estInCostUsd >= budgetUsd) return { refuse: true, estIn, estInCostUsd };
+  const outBudgetUsd = budgetUsd - estInCostUsd;
+  let maxTok = contextCeil;
+  if (Number(reqMax) > 0) maxTok = Math.min(maxTok, Math.floor(Number(reqMax)));
+  if (Number(outPrice) > 0) maxTok = Math.min(maxTok, Math.floor(outBudgetUsd / Number(outPrice) * 1e6));
+  return { refuse: false, maxTok: Math.max(1, maxTok), estIn, estInCostUsd };
+}
+
+// src/redemption.mjs
+import fs from "node:fs";
+var DEFAULT_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+function createRedemptionStore({ file = null, retentionMs = DEFAULT_RETENTION_MS, now = () => Date.now(), log = console } = {}) {
+  const map = /* @__PURE__ */ new Map();
+  let durable = false;
+  if (file) {
+    try {
+      if (fs.existsSync(file)) {
+        const cutoff = now() - retentionMs;
+        for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const { k, at, payload } = JSON.parse(line);
+            if (k && Number(at) >= cutoff) map.set(k, { payload, at: Number(at) });
+          } catch {
+          }
+        }
+      }
+      fs.writeFileSync(file, [...map].map(([k, e]) => JSON.stringify({ k, at: e.at, payload: e.payload })).join("\n") + (map.size ? "\n" : ""));
+      durable = true;
+      log.log?.(`mtok-relay: durable redemption at ${file} (${map.size} entries loaded)`);
+    } catch (e) {
+      log.warn?.(`mtok-relay: redemption file ${file} not writable (${e.message}); redemption is IN-MEMORY ONLY, a restart can re-serve a paid draw (#495). Point --redemption-file at a durable path.`);
+      durable = false;
+    }
+  } else {
+    log.warn?.("mtok-relay: no --redemption-file, redemption is IN-MEMORY ONLY, a restart or long idle can re-serve one payment for a fresh inference (#495). Set --redemption-file to a durable path.");
+  }
+  return {
+    durable,
+    has(key) {
+      return map.has(key);
+    },
+    get(key) {
+      return map.get(key)?.payload;
+    },
+    set(key, payload) {
+      const at = now();
+      map.set(key, { payload, at });
+      if (durable) {
+        try {
+          fs.appendFileSync(file, JSON.stringify({ k: key, at, payload }) + "\n");
+        } catch {
+        }
+      }
+    }
+  };
+}
+
 // core/errors.js
 function apiError(status, code, message, details) {
   const err = new Error(message);
@@ -4654,12 +4860,66 @@ function apiError(status, code, message, details) {
 
 // core/onchain.js
 var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+var DRAW_PAID_TOPIC = "0xb0243f80521d0dccd159389597aba96047e60ba5d7a9df12b67e5cb75230ac41";
+var DRAW_PAID_TOPIC_V2 = "0x94f9e7578a5c019f78ad332dcb2dc5563bcf257d777009ff5cef4118f084a70b";
+var DRAW_PAID_TOPICS = [DRAW_PAID_TOPIC, DRAW_PAID_TOPIC_V2];
+var isDrawPaidTopic = (topic) => DRAW_PAID_TOPICS.includes(String(topic || "").toLowerCase());
 var topicToAddress = (topic) => "0x" + String(topic).slice(-40).toLowerCase();
 var lc = (a) => String(a || "").toLowerCase();
+var strip0x = (v) => String(v || "").replace(/^0x/i, "");
+var wordAt = (hex, i) => strip0x(hex).slice(i * 64, i * 64 + 64);
+var uintWord = (hex, i) => BigInt("0x" + (wordAt(hex, i) || "0"));
+var asciiFromHex = (hex) => {
+  const bytes = strip0x(hex);
+  const out = [];
+  for (let i = 0; i < bytes.length; i += 2) {
+    const b = parseInt(bytes.slice(i, i + 2), 16);
+    if (!Number.isFinite(b)) break;
+    out.push(b);
+  }
+  return new TextDecoder().decode(new Uint8Array(out));
+};
+function decodeAbiString(dataHex, offsetBytes) {
+  const body = strip0x(dataHex);
+  const start = Number(offsetBytes) * 2;
+  if (!Number.isFinite(start) || start < 0 || start + 64 > body.length) throw new Error("bad_string_offset");
+  const len = Number(BigInt("0x" + body.slice(start, start + 64)));
+  const textStart = start + 64;
+  const textEnd = textStart + len * 2;
+  if (!Number.isFinite(len) || len < 0 || textEnd > body.length) throw new Error("bad_string_length");
+  return asciiFromHex(body.slice(textStart, textEnd));
+}
+function decodeDrawPaidLog(log) {
+  const data = log?.data || "0x";
+  const isV2 = String(log?.topics?.[0] || "").toLowerCase() === DRAW_PAID_TOPIC_V2;
+  if (strip0x(data).length < (isV2 ? 13 : 11) * 64) throw new Error("short_draw_paid_data");
+  const out = {
+    drawId: log?.topics?.[1],
+    sellerAgentKey: log?.topics?.[2],
+    buyerAgentKey: log?.topics?.[3],
+    sellerAgentId: decodeAbiString(data, uintWord(data, 0)),
+    buyerAgentId: decodeAbiString(data, uintWord(data, 1)),
+    bookingId: decodeAbiString(data, uintWord(data, 2)),
+    offerId: decodeAbiString(data, uintWord(data, 3)),
+    model: decodeAbiString(data, uintWord(data, 4)),
+    n: Number(uintWord(data, 5)),
+    sellerUsdAtomic: uintWord(data, 6).toString(),
+    feeUsdAtomic: uintWord(data, 7).toString(),
+    inputPricePerMTokAtomic: uintWord(data, 8).toString(),
+    outputPricePerMTokAtomic: uintWord(data, 9).toString(),
+    requestHash: "0x" + wordAt(data, 10)
+  };
+  if (isV2) {
+    out.seller = topicToAddress(wordAt(data, 11));
+    out.buyer = topicToAddress(wordAt(data, 12));
+  }
+  return out;
+}
 function createOnchainVerifier({
   rpcUrl,
   rpcUrls,
   usdcAddress,
+  expectedChainId,
   fetchImpl = globalThis.fetch,
   // A just-submitted payment can be mined on the payer's RPC yet not YET indexed by
   // ours (cross-RPC propagation lag), so a single receipt lookup returns null and the
@@ -4672,251 +4932,294 @@ function createOnchainVerifier({
   const urls = (rpcUrls?.length ? rpcUrls : String(rpcUrl || "").split(",")).map((s) => String(s).trim()).filter(Boolean);
   const configured = Boolean(urls.length && usdcAddress);
   const usdc = lc(usdcAddress);
+  async function rpcOn(url, method, params) {
+    const res = await fetchImpl(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+    });
+    if (!res.ok) throw apiError(502, "rpc_error", `chain RPC returned ${res.status}`);
+    const body = await res.json();
+    if (body.error) throw apiError(502, "rpc_error", `chain RPC: ${body.error.message ?? "unknown"}`);
+    return body.result;
+  }
   async function rpc(method, params) {
     let lastErr;
-    for (const url of urls) {
+    const pool = chainPinned && chainOkUrls.size ? urls.filter((u) => chainOkUrls.has(u)) : urls;
+    for (const url of pool) {
       try {
-        const res = await fetchImpl(url, {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
-        });
-        if (!res.ok) {
-          lastErr = apiError(502, "rpc_error", `chain RPC returned ${res.status}`);
-          continue;
-        }
-        const body = await res.json();
-        if (body.error) {
-          lastErr = apiError(502, "rpc_error", `chain RPC: ${body.error.message ?? "unknown"}`);
-          continue;
-        }
-        return body.result;
+        return await rpcOn(url, method, params);
       } catch (e) {
         lastErr = e;
       }
     }
     throw lastErr ?? apiError(502, "rpc_error", "no chain RPC configured");
   }
+  const chainOkUrls = /* @__PURE__ */ new Set();
+  const expChain = Number(expectedChainId);
+  const chainPinned = Number.isFinite(expChain) && expChain > 0;
+  async function assertChain() {
+    if (!chainPinned) return true;
+    if (chainOkUrls.size) return true;
+    for (const url of urls) {
+      try {
+        const hex = await rpcOn(url, "eth_chainId", []);
+        if (typeof hex === "string" && parseInt(hex, 16) === expChain) chainOkUrls.add(url);
+      } catch {
+      }
+    }
+    return chainOkUrls.size > 0;
+  }
+  async function fetchReceipt(txHash) {
+    let receipt = await rpc("eth_getTransactionReceipt", [txHash]);
+    for (let i = 0; !receipt && i < receiptRetries; i++) {
+      await sleepImpl(receiptRetryMs);
+      receipt = await rpc("eth_getTransactionReceipt", [txHash]);
+    }
+    if (!receipt) return { error: "tx_not_found_or_pending" };
+    if (lc(receipt.transactionHash) !== lc(txHash)) return { error: "receipt_tx_mismatch" };
+    if (receipt.status !== "0x1") return { error: "tx_failed" };
+    return { receipt };
+  }
+  function findUsdcTransfer(receipt, { to, minAtomic, from, consumed } = {}) {
+    const want = lc(to);
+    const wantFrom = from ? lc(from) : null;
+    const logs = receipt.logs || [];
+    let sawRecipient = false;
+    for (let i = 0; i < logs.length; i++) {
+      if (consumed && consumed.has(i)) continue;
+      const l = logs[i];
+      if (lc(l.address) !== usdc || l.topics?.[0] !== TRANSFER_TOPIC || l.topics.length !== 3) continue;
+      if (topicToAddress(l.topics[2]) !== want) continue;
+      if (wantFrom && topicToAddress(l.topics[1]) !== wantFrom) continue;
+      sawRecipient = true;
+      let amount;
+      try {
+        amount = BigInt(l.data);
+      } catch {
+        continue;
+      }
+      if (amount < BigInt(minAtomic)) continue;
+      return { ok: true, from: topicToAddress(l.topics[1]), amount: amount.toString(), index: i };
+    }
+    return { ok: false, reason: sawRecipient ? "amount_too_low" : "no_matching_usdc_transfer" };
+  }
   return {
     configured,
     // Confirm txHash is a successful USDC transfer of >= minAtomic to `to`.
     // Returns { ok, reason?, from?, amount? }; never throws on a bad payment
     // (only on an RPC transport failure).
     async verifyTransfer(txHash, { to, minAtomic }) {
-      let receipt = await rpc("eth_getTransactionReceipt", [txHash]);
-      for (let i = 0; !receipt && i < receiptRetries; i++) {
-        await sleepImpl(receiptRetryMs);
-        receipt = await rpc("eth_getTransactionReceipt", [txHash]);
-      }
-      if (!receipt) return { ok: false, reason: "tx_not_found_or_pending" };
-      if (receipt.status !== "0x1") return { ok: false, reason: "tx_failed" };
-      const want = lc(to);
-      const log = (receipt.logs || []).find(
-        (l) => lc(l.address) === usdc && l.topics?.[0] === TRANSFER_TOPIC && topicToAddress(l.topics[2]) === want
+      if (!await assertChain()) return { ok: false, reason: "wrong_chain" };
+      const got = await fetchReceipt(txHash);
+      if (got.error) return { ok: false, reason: got.error };
+      return findUsdcTransfer(got.receipt, { to, minAtomic });
+    },
+    async verifyDrawPaid(txHash, {
+      contractAddress,
+      buyerAgentId,
+      sellerAgentId,
+      bookingId,
+      offerId,
+      model,
+      n,
+      requestHash,
+      sellerWallet,
+      feeRecipient,
+      minSellerAtomic = 0n
+    } = {}) {
+      if (!await assertChain()) return { ok: false, reason: "wrong_chain" };
+      const contract = lc(contractAddress);
+      if (!contract) return { ok: false, reason: "contract_not_configured" };
+      const got = await fetchReceipt(txHash);
+      if (got.error) return { ok: false, reason: got.error };
+      const log = (got.receipt.logs || []).find(
+        (l) => lc(l.address) === contract && isDrawPaidTopic(l.topics?.[0])
       );
-      if (!log) return { ok: false, reason: "no_matching_usdc_transfer" };
-      const amount = BigInt(log.data);
-      if (amount < BigInt(minAtomic)) return { ok: false, reason: "amount_too_low" };
-      return { ok: true, from: topicToAddress(log.topics[1]), amount: amount.toString() };
+      if (!log) return { ok: false, reason: "no_draw_paid_event" };
+      let event;
+      try {
+        event = decodeDrawPaidLog(log);
+      } catch {
+        return { ok: false, reason: "malformed_draw_paid_event" };
+      }
+      if (buyerAgentId != null && event.buyerAgentId !== String(buyerAgentId)) return { ok: false, reason: "buyer_agent_mismatch" };
+      if (sellerAgentId != null && event.sellerAgentId !== String(sellerAgentId)) return { ok: false, reason: "seller_agent_mismatch" };
+      if (bookingId != null && event.bookingId !== String(bookingId)) return { ok: false, reason: "booking_mismatch" };
+      if (offerId != null && event.offerId !== String(offerId)) return { ok: false, reason: "offer_mismatch" };
+      if (model != null && event.model !== String(model)) return { ok: false, reason: "model_mismatch" };
+      if (n != null && event.n !== Number(n)) return { ok: false, reason: "draw_n_mismatch" };
+      if (requestHash != null && lc(event.requestHash) !== lc(requestHash)) return { ok: false, reason: "request_hash_mismatch" };
+      if (BigInt(event.sellerUsdAtomic) < BigInt(minSellerAtomic)) return { ok: false, reason: "amount_too_low" };
+      const consumed = /* @__PURE__ */ new Set();
+      let sellerTransfer = null;
+      if (sellerWallet) {
+        sellerTransfer = findUsdcTransfer(got.receipt, { to: sellerWallet, minAtomic: BigInt(event.sellerUsdAtomic), from: event.buyer });
+        if (!sellerTransfer.ok) return { ok: false, reason: "seller_transfer_" + sellerTransfer.reason };
+        if (sellerTransfer.index != null) consumed.add(sellerTransfer.index);
+      }
+      let feeTransfer = null;
+      if (feeRecipient && BigInt(event.feeUsdAtomic) > 0n) {
+        feeTransfer = findUsdcTransfer(got.receipt, { to: feeRecipient, minAtomic: BigInt(event.feeUsdAtomic), from: event.buyer, consumed });
+        if (!feeTransfer.ok) return { ok: false, reason: "fee_transfer_" + feeTransfer.reason };
+      }
+      return { ok: true, event, from: sellerTransfer?.from ?? feeTransfer?.from ?? null };
     }
   };
 }
-function usdToAtomic(usd) {
-  return BigInt(Math.round(Number(usd) * 1e6));
-}
 
-// mtok-relay.mjs
-var CONTEXT_CEIL = 4096;
+// src/rpc.mjs
+var BASE_MAINNET_RPCS = [
+  "https://mainnet.base.org",
+  "https://base.llamarpc.com",
+  "https://base-rpc.publicnode.com",
+  "https://base.drpc.org"
+];
+var BASE_SEPOLIA_RPCS = [
+  "https://sepolia.base.org",
+  "https://base-sepolia-rpc.publicnode.com"
+];
+var rpcUrlsFor = (chainId, override) => override ? [override] : Number(chainId) === 8453 ? BASE_MAINNET_RPCS : BASE_SEPOLIA_RPCS;
+
+// src/runtime.mjs
+import crypto2 from "node:crypto";
 var BALANCE_EPSILON = 1e-6;
-var args = process.argv.slice(2);
-var flag = (name) => {
-  const i = args.indexOf(name);
-  return i !== -1 ? args[i + 1] : null;
-};
-var offerId = flag("--offer");
-var MODEL = flag("--model");
-var upstream = (flag("--upstream") ?? "").replace(/\/$/, "");
-var apiBase = (flag("--api") ?? "https://mtok.market").replace(/\/$/, "");
-var port = Number(flag("--port") ?? 8788);
-var rpcFlag = flag("--rpc");
-var settlementPubkeyFlag = flag("--settlement-pubkey");
-var outPrice = Number(flag("--out-price") ?? 0);
-if (!offerId) {
-  console.error("mtok-relay: --offer <id> is required");
-  process.exit(1);
-}
-if (!MODEL) {
-  console.error("mtok-relay: --model <id> is required (the offer model you serve)");
-  process.exit(1);
-}
-if (!upstream) {
-  console.error("mtok-relay: --upstream <url> is required");
-  process.exit(1);
-}
-var MTOK_API_KEY = process.env.MTOK_API_KEY;
-var UPSTREAM_KEY = process.env.UPSTREAM_KEY;
-var RELAY_WALLET_KEY = process.env.RELAY_WALLET_KEY;
-if (!MTOK_API_KEY) {
-  console.error("mtok-relay: MTOK_API_KEY env var is required");
-  process.exit(1);
-}
-if (!UPSTREAM_KEY) {
-  console.error("mtok-relay: UPSTREAM_KEY env var is required");
-  process.exit(1);
-}
-if (!RELAY_WALLET_KEY && !settlementPubkeyFlag) {
-  console.error("mtok-relay: RELAY_WALLET_KEY env var (or --settlement-pubkey) is required");
-  process.exit(1);
-}
-var SETTLEMENT_ADDR;
-if (settlementPubkeyFlag) {
-  SETTLEMENT_ADDR = settlementPubkeyFlag;
-} else {
-  try {
-    SETTLEMENT_ADDR = privateKeyToAccount(RELAY_WALLET_KEY.startsWith("0x") ? RELAY_WALLET_KEY : "0x" + RELAY_WALLET_KEY).address;
-  } catch (e) {
-    console.error("mtok-relay: invalid RELAY_WALLET_KEY \u2014", e.message);
-    process.exit(1);
-  }
-}
-function readBody(req) {
-  return new Promise((resolve, reject) => {
-    let raw = "";
-    req.on("data", (d) => {
-      raw += d;
+var hash32 = (v) => "0x" + crypto2.createHash("sha256").update(typeof v === "string" ? v : JSON.stringify(v ?? null)).digest("hex");
+async function createRelayRuntime(config) {
+  const served = createRedemptionStore({ file: config.redemptionFile });
+  const drawLocks = /* @__PURE__ */ new Map();
+  const platform = await fetchPlatformConfig(config);
+  const verifier = createOnchainVerifier({ rpcUrls: rpcUrlsFor(platform.chainId, config.rpcFlag), usdcAddress: platform.usdcAddress });
+  if (!verifier.configured) throw new Error("onchain verifier not configured (missing usdcAddress in /api/config)");
+  const payerDenylist = new Set((config.payerDenylist ?? []).map((a) => String(a).trim().toLowerCase()).filter(Boolean));
+  const screenPayer = typeof config.screenPayer === "function" ? config.screenPayer : null;
+  const payerDenied = async (payer) => {
+    if (!payer) return false;
+    if (payerDenylist.has(payer)) return true;
+    if (screenPayer && await screenPayer(payer)) return true;
+    return false;
+  };
+  const withBookingLock = async (bookingId, fn) => {
+    const previous = drawLocks.get(bookingId) || Promise.resolve();
+    let release;
+    const gate = new Promise((resolve) => {
+      release = resolve;
     });
-    req.on("end", () => {
+    const tail = previous.catch(() => {
+    }).then(() => gate);
+    drawLocks.set(bookingId, tail);
+    await previous.catch(() => {
+    });
+    try {
+      return await fn();
+    } finally {
+      release();
+      if (drawLocks.get(bookingId) === tail) drawLocks.delete(bookingId);
+    }
+  };
+  const handleDraw = async (body, res) => {
+    const { bookingId, n, buyerId, request, drawPaidTxHash } = body;
+    if (!bookingId) return send(res, 400, { error: "bad_request", detail: "DRAW needs bookingId" });
+    if (n == null) return send(res, 400, { error: "bad_request", detail: "DRAW needs a delivery index n (per-booking idempotency key)" });
+    return withBookingLock(bookingId, async () => {
+      const requestHash = hash32(request);
+      const cacheKey = `${bookingId}:${n}:${requestHash}`;
+      if (served.has(cacheKey)) return send(res, 200, served.get(cacheKey));
+      if (!platform.dripContractAddress) {
+        return send(res, 402, { error: "contract_mode_required", detail: "this relay only serves contract-mode draws; the platform is not reporting a dripContractAddress" });
+      }
+      if (!drawPaidTxHash) return send(res, 402, { error: "draw_payment_required", detail: "contract mode requires drawPaidTxHash before upstream delivery" });
+      let paid;
       try {
-        resolve(JSON.parse(raw || "{}"));
-      } catch {
-        resolve({});
+        paid = await verifier.verifyDrawPaid(drawPaidTxHash, {
+          contractAddress: platform.dripContractAddress,
+          buyerAgentId: buyerId,
+          bookingId,
+          offerId: config.offerId,
+          model: config.model,
+          n,
+          requestHash,
+          sellerWallet: config.settlementAddr,
+          feeRecipient: platform.feeAddress
+        });
+      } catch (e) {
+        return send(res, 402, { error: "payment_unverified", detail: e.message });
+      }
+      if (!paid?.ok) return send(res, 402, { error: "payment_unverified", detail: paid?.reason || "unknown" });
+      const expectedFee = configuredFeeAtomic({
+        sellerUsdAtomic: paid.event.sellerUsdAtomic,
+        feeAddress: platform.feeAddress,
+        feeBps: platform.feeBps
+      });
+      if (BigInt(paid.event.feeUsdAtomic || 0) < expectedFee) {
+        return send(res, 402, { error: "payment_unverified", detail: "fee_amount_too_low" });
+      }
+      try {
+        if (await payerDenied(String(paid.from || "").toLowerCase())) {
+          return send(res, 403, { error: "payer_denied", detail: "the verified payer wallet is denylisted by this relay" });
+        }
+      } catch (e) {
+        return send(res, 403, { error: "payer_denied", detail: "payer screening failed: " + e.message });
+      }
+      const paidEvent = paid.event;
+      const remainingUsd = Number(paid.event.sellerUsdAtomic || 0) / 1e6;
+      if (remainingUsd <= BALANCE_EPSILON) {
+        return send(res, 402, { error: "balance_exhausted", detail: `remainingUsd=${remainingUsd}`, _bookingId: bookingId, remainingUsd });
+      }
+      const eventInPriceUsd = Number(paidEvent.inputPricePerMTokAtomic || 0) / 1e6;
+      const inPrice = Math.max(Number(config.inPrice) || 0, eventInPriceUsd);
+      const bound = boundServe({ messages: request?.messages, budgetUsd: remainingUsd, inPrice, outPrice: config.outPrice, reqMax: Number(request?.max_tokens) });
+      if (bound.refuse) {
+        return send(res, 402, { error: "input_too_large", detail: `estimated input (~${bound.estIn} tokens, $${bound.estInCostUsd.toFixed(6)}) meets or exceeds the paid amount ($${remainingUsd}); send a shorter prompt or pay for more`, _bookingId: bookingId, remainingUsd });
+      }
+      const safeRequest = { ...request, max_tokens: bound.maxTok };
+      let completion;
+      try {
+        const upstreamRes = await fetch(config.upstream + "/v1/chat/completions", {
+          method: "POST",
+          headers: { "content-type": "application/json", authorization: "Bearer " + config.upstreamKey },
+          body: JSON.stringify(safeRequest)
+        });
+        completion = await upstreamRes.json();
+      } catch (e) {
+        return send(res, 502, { error: "upstream_error", detail: e.message });
+      }
+      try {
+        enforceModelEcho(completion.model, config.model);
+      } catch (e) {
+        return send(res, 502, { error: "model_mismatch", detail: e.message });
       }
+      const usage = completion.usage ?? {};
+      const inTok = Number(usage.prompt_tokens ?? usage.input_tokens ?? 0) || 0;
+      const outTok = Number(usage.completion_tokens ?? usage.output_tokens ?? 0) || 0;
+      const usedUsd = (inTok * Number(paidEvent.inputPricePerMTokAtomic || 0) + outTok * Number(paidEvent.outputPricePerMTokAtomic || 0)) / 1e12;
+      const payload = { ...completion, _bookingId: bookingId, remainingUsd: Math.max(0, Math.round((remainingUsd - usedUsd) * 1e6) / 1e6) };
+      served.set(cacheKey, payload);
+      return send(res, 200, payload);
     });
-    req.on("error", reject);
-  });
-}
-function send(res, status, body) {
-  const payload = JSON.stringify(body);
-  res.writeHead(status, { "content-type": "application/json", "content-length": Buffer.byteLength(payload) });
-  res.end(payload);
+  };
+  return { handleDraw };
 }
-var feeAddress;
-var feeBps;
-var verifier;
-async function boot() {
-  const r = await fetch(apiBase + "/api/config");
+async function fetchPlatformConfig(config) {
+  const r = await fetch(config.apiBase + "/api/config");
   if (!r.ok) throw new Error("config fetch failed: " + r.status);
-  const config = await r.json();
-  feeAddress = config.feeAddress;
-  feeBps = config.feeBps;
-  const chainId = Number(config.chainId ?? 8453);
-  const rpcUrls = rpcFlag ? [rpcFlag] : chainId === 8453 ? ["https://mainnet.base.org", "https://base.llamarpc.com", "https://base-rpc.publicnode.com", "https://base.drpc.org"] : ["https://sepolia.base.org", "https://base-sepolia-rpc.publicnode.com"];
-  verifier = createOnchainVerifier({ rpcUrls, usdcAddress: config.usdcAddress });
-  if (!verifier.configured) throw new Error("onchain verifier not configured (missing usdcAddress in /api/config)");
+  const body = await r.json();
+  return {
+    feeAddress: body.feeAddress,
+    feeBps: body.feeBps,
+    dustThresholdUsd: Number(body.dustThresholdUsd) || 1e-3,
+    chainId: Number(body.chainId ?? 8453),
+    usdcAddress: body.usdcAddress,
+    dripContractAddress: body.dripContractAddress
+  };
 }
-async function reportToPlatform(reportBody) {
-  const rr = await fetch(apiBase + "/api/chunks/report", {
-    method: "POST",
-    headers: { "content-type": "application/json", "x-api-key": MTOK_API_KEY },
-    body: JSON.stringify(reportBody)
-  });
-  const body = await rr.json().catch(() => ({}));
-  return { ok: rr.status === 201, status: rr.status, body, booking: body?.booking ?? null };
-}
-async function handleFund(body, res) {
-  const { bookingId, n, sellerTxHash, feeTxHash, priceUsd, buyerId } = body;
-  try {
-    const sellerOk = (await verifier.verifyTransfer(sellerTxHash, { to: SETTLEMENT_ADDR, minAtomic: usdToAtomic(priceUsd) })).ok;
-    const feeAtomic = usdToAtomic((Number(priceUsd) || 0) * (Number(feeBps) || 0) / 1e4);
-    const feeOk = (await verifier.verifyTransfer(feeTxHash, { to: feeAddress, minAtomic: feeAtomic })).ok;
-    if (!sellerOk || !feeOk) return send(res, 402, { error: "payment_unverified", detail: `seller=${sellerOk} fee=${feeOk}` });
-  } catch (e) {
-    return send(res, 402, { error: "payment_unverified", detail: e.message });
-  }
-  let rep;
-  try {
-    rep = await reportToPlatform(buildFundReport({ offerId, buyerId, bookingId, n, priceUsd, sellerTxHash, feeTxHash }));
-  } catch (e) {
-    return send(res, 502, { error: "report_failed", detail: e.message });
-  }
-  if (!rep.ok || !rep.booking) {
-    console.error("mtok-relay: FUND report rejected (%d) for n=%d offerId=%s: %s", rep.status, n, offerId, JSON.stringify(rep.body));
-    return send(res, 502, { error: "report_failed", detail: rep.body?.error || rep.status });
-  }
-  return send(res, 200, { ...rep.booking, _bookingId: rep.booking.id, remainingUsd: rep.booking.remainingUsd });
-}
-async function handleDraw(body, res) {
-  const { bookingId, n, buyerId, request } = body;
-  if (!bookingId) return send(res, 400, { error: "bad_request", detail: "DRAW needs bookingId" });
-  let booking;
-  try {
-    const r = await fetch(apiBase + `/api/bookings/${encodeURIComponent(bookingId)}`, { headers: { "x-api-key": MTOK_API_KEY } });
-    const rb = await r.json().catch(() => ({}));
-    if (r.status !== 200 || !rb?.booking) return send(res, 502, { error: "booking_read_failed", detail: rb?.error || r.status });
-    booking = rb.booking;
-  } catch (e) {
-    return send(res, 502, { error: "booking_read_failed", detail: e.message });
-  }
-  const remainingUsd = Number(booking.remainingUsd) || 0;
-  if (remainingUsd <= BALANCE_EPSILON) {
-    return send(res, 402, { error: "balance_exhausted", detail: `remainingUsd=${remainingUsd}`, _bookingId: bookingId, remainingUsd });
-  }
-  let maxTok = CONTEXT_CEIL;
-  const reqMax = Number(request?.max_tokens);
-  if (reqMax > 0) maxTok = Math.min(maxTok, Math.floor(reqMax));
-  if (outPrice > 0) maxTok = Math.min(maxTok, Math.floor(remainingUsd / outPrice * 1e6));
-  const safeRequest = { ...request, max_tokens: Math.max(1, maxTok) };
-  let completion;
-  try {
-    const upstreamRes = await fetch(upstream + "/v1/chat/completions", {
-      method: "POST",
-      headers: { "content-type": "application/json", authorization: "Bearer " + UPSTREAM_KEY },
-      body: JSON.stringify(safeRequest)
-    });
-    completion = await upstreamRes.json();
-  } catch (e) {
-    return send(res, 502, { error: "upstream_error", detail: e.message });
-  }
-  try {
-    enforceModelEcho(completion.model, MODEL);
-  } catch (e) {
-    return send(res, 502, { error: "model_mismatch", detail: e.message });
-  }
-  let rep;
-  try {
-    rep = await reportToPlatform(buildDrawReport({ offerId, buyerId, bookingId, n, usage: completion.usage }));
-  } catch (e) {
-    console.error("mtok-relay: DRAW report failed (network) for n=%d offerId=%s: %s", n, offerId, e.message);
-    return send(res, 502, { error: "report_failed", detail: e.message, completion });
-  }
-  if (!rep.ok || !rep.booking) {
-    console.error("mtok-relay: DRAW report rejected (%d) for n=%d offerId=%s: %s", rep.status, n, offerId, JSON.stringify(rep.body));
-    return send(res, rep.status === 402 ? 402 : 502, { error: rep.body?.error?.code || rep.body?.error || "report_failed", detail: rep.body?.error?.message || rep.status, completion, _bookingId: bookingId });
-  }
-  return send(res, 200, { ...completion, _bookingId: rep.booking.id, remainingUsd: rep.booking.remainingUsd });
-}
-var server = http.createServer(async (req, res) => {
-  if (req.method !== "POST" || req.url !== "/chunk") {
-    return send(res, 404, { error: "not found" });
-  }
-  let body;
-  try {
-    body = await readBody(req);
-  } catch {
-    return send(res, 400, { error: "bad body" });
-  }
-  const hasFund = body.sellerTxHash != null && body.sellerTxHash !== "";
-  const hasDraw = body.request != null;
-  if (hasFund && hasDraw) return send(res, 400, { error: "bad_request", detail: "send a FUND (sellerTxHash) or a DRAW (request), not both" });
-  if (hasFund) return handleFund(body, res);
-  if (hasDraw) return handleDraw(body, res);
-  return send(res, 400, { error: "bad_request", detail: "need a FUND (sellerTxHash) or a DRAW (request)" });
-});
-boot().then(() => {
-  server.listen(port, () => {
-    console.log(`mtok-relay: listening on port ${port}  offer=${offerId}  model=${MODEL}  upstream=${upstream}  api=${apiBase}  settlement=${SETTLEMENT_ADDR}`);
-  });
-}).catch((e) => {
-  console.error("mtok-relay: boot failed \u2014", e.message);
+
+// mtok-relay.mjs
+try {
+  const config = readRelayConfig();
+  const runtime = await createRelayRuntime(config);
+  startRelayServer({ config, ...runtime });
+} catch (e) {
+  console.error("mtok-relay: boot failed -", e.message);
   process.exit(1);
-});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtok-relay",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Reference seller relay for mtok.market — accepts on-chain-prepaid chunk draws and serves inference from an upstream you control. Run with: npx mtok-relay --offer <id> --model <id> --upstream <url>.",
   "type": "module",
   "bin": {
@@ -33,8 +33,8 @@
     "prepublishOnly": "node build-relay-bundle.mjs"
   },
   "devDependencies": {
-    "viem": "^2.0.0",
-    "esbuild": "^0.28.1"
+    "esbuild": "^0.28.1",
+    "viem": "^2.0.0"
   },
   "overrides": {
     "ws": "^8.21.0"