@tempoxyz/patron 0.0.18 → 0.0.20

package/dist/bin.js

@@ -4,14 +4,14 @@ const require = __patronCreateRequire(import.meta.url)
 
 // src/bin.ts
 if (process.argv[2] === "hook") {
-  const { runHookProcess } = await import("./chunks/hook-process-YHSATQFR.js");
+  const { runHookProcess } = await import("./chunks/hook-process-Y2W56T2X.js");
   await runHookProcess().catch(() => void 0);
   process.exit(0);
 } else if (process.argv[2] === "pay") {
-  const { runPayProcess } = await import("./chunks/hook-process-YHSATQFR.js");
+  const { runPayProcess } = await import("./chunks/hook-process-Y2W56T2X.js");
   await runPayProcess().catch(() => void 0);
   process.exit(0);
 } else {
-  const { run } = await import("./chunks/-643GYNS6.js");
+  const { run } = await import("./chunks/-RNUFDXSV.js");
   process.exitCode = await run(process.argv.slice(2));
 }

package/dist/chunks/{-643GYNS6.js → -RNUFDXSV.js}

@@ -28,7 +28,7 @@ import {
   withPatronStatus,
   withoutPatronHandlers,
   writeJsonObject
-} from "./chunk-XJOIDBXC.js";
+} from "./chunk-UFBFF3R6.js";
 import {
   startRefill
 } from "./chunk-CV2WYKM7.js";

package/dist/chunks/{chunk-XJOIDBXC.js → chunk-UFBFF3R6.js}

@@ -27583,7 +27583,17 @@ var LeaderboardResponse = external_exports.object({
       claimed: external_exports.boolean().default(true)
     })
   ).default([]),
-  totals: external_exports.object({ tokens: external_exports.number().int(), sites: external_exports.number().int(), usd })
+  /**
+   * tokens and usd are seals bought; spent and spentUsd are seals redeemed, which is what
+   * sites have been paid.
+   */
+  totals: external_exports.object({
+    tokens: external_exports.number().int(),
+    sites: external_exports.number().int(),
+    usd,
+    spent: external_exports.number().int().default(0),
+    spentUsd: usd.default("0")
+  })
 });
 var ClaimRequest = external_exports.object({
   /** A registrable domain, or an X profile as "x.com/<handle>". */
@@ -34205,9 +34215,9 @@ var PARTIALLY_BLIND_RSA_TOKEN_TYPE = {
 
 // ../../node_modules/.pnpm/@cloudflare+privacypass-ts@0.9.0/node_modules/@cloudflare/privacypass-ts/lib/src/pub_verif_token.js
 var BlindRSAMode;
-(function(BlindRSAMode3) {
-  BlindRSAMode3[BlindRSAMode3["PSSZero"] = 0] = "PSSZero";
-  BlindRSAMode3[BlindRSAMode3["PSS"] = 48] = "PSS";
+(function(BlindRSAMode2) {
+  BlindRSAMode2[BlindRSAMode2["PSSZero"] = 0] = "PSSZero";
+  BlindRSAMode2[BlindRSAMode2["PSS"] = 48] = "PSS";
 })(BlindRSAMode || (BlindRSAMode = {}));
 var PartiallyBlindRSAMode = BlindRSAMode;
 var BLINDRSA_EXTRA_PARAMS = {
@@ -34528,29 +34538,259 @@ var MediaType2;
   MediaType3["GENERIC_BATCHED_TOKEN_RESPONSE"] = "application/private-token-generic-batch-response";
 })(MediaType2 || (MediaType2 = {}));
 
+// ../client/src/blind-rsa.ts
+var HASH = "SHA-384";
+var HASH_LENGTH = 48;
+var SALT_LENGTH = 48;
+var MAX_BLIND_ATTEMPTS = 128;
+async function importBlindRsaKey(cryptoKey) {
+  const algorithm = cryptoKey.algorithm;
+  if (cryptoKey.type !== "public" || algorithm.name !== "RSA-PSS")
+    throw new Error("key is not an RSA-PSS public key");
+  if (algorithm.hash.name !== HASH) throw new Error(`key hash is not ${HASH}`);
+  const jwk = await crypto.subtle.exportKey("jwk", cryptoKey);
+  if (!jwk.n || !jwk.e) throw new Error("key has invalid parameters");
+  const n = bytesToInt(fromBase64UrlBytes(jwk.n));
+  const e = bytesToInt(fromBase64UrlBytes(jwk.e));
+  const modulusBits = n.toString(2).length;
+  if (modulusBits !== algorithm.modulusLength)
+    throw new Error("key has invalid parameters");
+  return { cryptoKey, n, e, modulusBits, modulusBytes: Math.ceil(modulusBits / 8) };
+}
+async function blind(key, messages) {
+  const encoded = await Promise.all(
+    messages.map(
+      (msg) => emsaPssEncode(
+        msg,
+        key.modulusBits - 1,
+        crypto.getRandomValues(new Uint8Array(SALT_LENGTH))
+      )
+    )
+  );
+  return blindEncoded(key, encoded, randomBlindingFactors(key, messages.length));
+}
+function blindEncoded(key, encoded, factors) {
+  const { n } = key;
+  if (encoded.length !== factors.length)
+    throw new Error("one blinding factor per message");
+  const messages = encoded.map(bytesToInt);
+  let product = 1n;
+  for (const m of messages) {
+    if (m >= n) throw new Error("invalid input");
+    product = product * m % n;
+  }
+  if (gcd(product, n) !== 1n) throw new Error("invalid input");
+  return messages.map((m, index) => {
+    const factor = factors[index];
+    const z2 = m * modPow(factor.r, key.e, n) % n;
+    return { blindedMsg: intToBytes(z2, key.modulusBytes), inv: factor.inv };
+  });
+}
+async function finalize2(key, msg, blindSig, inv) {
+  if (blindSig.length !== key.modulusBytes) throw new Error("unexpected input size");
+  const z2 = bytesToInt(blindSig);
+  if (z2 >= key.n) throw new Error("invalid signature");
+  const sig = intToBytes(z2 * inv % key.n, key.modulusBytes);
+  const valid = await crypto.subtle.verify(
+    { name: "RSA-PSS", saltLength: SALT_LENGTH },
+    key.cryptoKey,
+    sig,
+    msg.slice()
+  );
+  if (!valid) throw new Error("invalid signature");
+  return sig;
+}
+async function emsaPssEncode(msg, emBits, salt) {
+  const emLength = Math.ceil(emBits / 8);
+  if (emLength < HASH_LENGTH + salt.length + 2) throw new Error("encoding error");
+  const mHash = await digest(msg);
+  const mPrime = new Uint8Array(8 + HASH_LENGTH + salt.length);
+  mPrime.set(mHash, 8);
+  mPrime.set(salt, 8 + HASH_LENGTH);
+  const h = await digest(mPrime);
+  const dbLength = emLength - HASH_LENGTH - 1;
+  const mask = await mgf12(h, dbLength);
+  const em = new Uint8Array(emLength);
+  em[dbLength - salt.length - 1] = 1;
+  em.set(salt, dbLength - salt.length);
+  for (let index = 0; index < dbLength; index++)
+    em[index] = (em[index] ?? 0) ^ (mask[index] ?? 0);
+  em[0] = (em[0] ?? 0) & 255 >> 8 * emLength - emBits;
+  em.set(h, dbLength);
+  em[emLength - 1] = 188;
+  return em;
+}
+function inverseMod2(a, n) {
+  let oldR = a % n;
+  let r = n;
+  let oldS = 1n;
+  let s = 0n;
+  while (r !== 0n) {
+    const quotient = oldR / r;
+    const nextR = oldR - quotient * r;
+    oldR = r;
+    r = nextR;
+    const nextS = oldS - quotient * s;
+    oldS = s;
+    s = nextS;
+  }
+  if (oldR !== 1n) return void 0;
+  return oldS < 0n ? oldS + n : oldS;
+}
+function randomBlindingFactors(key, count) {
+  const { n } = key;
+  for (let attempt = 0; attempt < MAX_BLIND_ATTEMPTS; attempt++) {
+    const factors = Array.from({ length: count }, () => randomBelow(key));
+    const prefixes = [];
+    let product = 1n;
+    for (const r of factors) {
+      product = product * r % n;
+      prefixes.push(product);
+    }
+    let inverse = inverseMod2(product, n);
+    if (inverse === void 0) continue;
+    const inverses = new Array(count);
+    for (let index = count - 1; index >= 0; index--) {
+      const r = factors[index];
+      inverses[index] = index === 0 ? inverse : inverse * prefixes[index - 1] % n;
+      inverse = inverse * r % n;
+    }
+    return factors.map((r, index) => ({ r, inv: inverses[index] }));
+  }
+  throw new Error("blinding error: no invertible blinding factor found");
+}
+function randomBelow(key) {
+  const bytes = new Uint8Array(key.modulusBytes);
+  const topMask = 255 >> 8 * key.modulusBytes - key.modulusBits;
+  try {
+    for (let attempt = 0; attempt < MAX_BLIND_ATTEMPTS; attempt++) {
+      crypto.getRandomValues(bytes);
+      bytes[0] = (bytes[0] ?? 0) & topMask;
+      const r = bytesToInt(bytes);
+      if (r !== 0n && r < key.n) return r;
+    }
+  } finally {
+    bytes.fill(0);
+  }
+  throw new Error("blinding error: no blinding factor below n found");
+}
+function modPow(base, exponent, modulus) {
+  let result = 1n;
+  let square = base % modulus;
+  let remaining = exponent;
+  while (remaining > 0n) {
+    if (remaining & 1n) result = result * square % modulus;
+    remaining >>= 1n;
+    if (remaining > 0n) square = square * square % modulus;
+  }
+  return result;
+}
+function gcd(a, b) {
+  let x = a;
+  let y = b;
+  while (y !== 0n) {
+    const next = x % y;
+    x = y;
+    y = next;
+  }
+  return x;
+}
+async function mgf12(seed, length2) {
+  const blocks = Math.ceil(length2 / HASH_LENGTH);
+  const hashes = await Promise.all(
+    Array.from({ length: blocks }, (_, counter) => {
+      const input2 = new Uint8Array(seed.length + 4);
+      input2.set(seed);
+      new DataView(input2.buffer).setUint32(seed.length, counter);
+      return digest(input2);
+    })
+  );
+  const mask = new Uint8Array(blocks * HASH_LENGTH);
+  hashes.forEach((hash2, index) => {
+    mask.set(hash2, index * HASH_LENGTH);
+  });
+  return mask.subarray(0, length2);
+}
+async function digest(data) {
+  return new Uint8Array(await crypto.subtle.digest(HASH, data.slice()));
+}
+var HEX = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, "0"));
+function bytesToInt(bytes) {
+  if (bytes.length === 0) return 0n;
+  let hex3 = "";
+  for (const byte of bytes) hex3 += HEX[byte];
+  return BigInt(`0x${hex3}`);
+}
+function intToBytes(value, length2) {
+  const hex3 = value.toString(16);
+  if (value < 0n || hex3.length > length2 * 2) throw new Error("integer too large");
+  const padded = hex3.padStart(length2 * 2, "0");
+  const bytes = new Uint8Array(length2);
+  for (let index = 0; index < length2; index++)
+    bytes[index] = Number.parseInt(padded.slice(index * 2, index * 2 + 2), 16);
+  return bytes;
+}
+function fromBase64UrlBytes(value) {
+  const base643 = value.replaceAll("-", "+").replaceAll("_", "/");
+  const binary = atob(base643 + "=".repeat((4 - base643.length % 4) % 4));
+  return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+}
+
 // ../client/src/privacy-pass.ts
-var { BlindRSAMode: BlindRSAMode2, Client: Client3 } = pub_verif_token_exports;
+var { BLIND_RSA: BLIND_RSA2, TokenRequest: TokenRequest3, TokenResponse: TokenResponse3, convertRSASSAPSSToEnc: convertRSASSAPSSToEnc2 } = pub_verif_token_exports;
 function tokenChallenge() {
   return new TokenChallenge(TOKEN_TYPE, ISSUER_NAME, new Uint8Array(0));
 }
 async function createTokenRequests(publicKey, count) {
+  if (!(count > 0)) return [];
   const issuerKey = fromBase64Url(publicKey);
-  const challenge = tokenChallenge();
-  const pending = [];
-  for (let index = 0; index < count; index++) {
-    const client = new Client3(BlindRSAMode2.PSS);
-    const request = await client.createTokenRequest(challenge, issuerKey);
-    pending.push({
+  const cryptoKey = await crypto.subtle.importKey(
+    "spki",
+    convertRSASSAPSSToEnc2(issuerKey).slice(),
+    BLIND_RSA2.rsaParams,
+    true,
+    ["verify"]
+  );
+  const key = await importBlindRsaKey(cryptoKey);
+  if (key.modulusBytes !== BLIND_RSA2.Nk) throw new Error("issuer key is not RSA-2048");
+  const [tokenKeyId, challengeDigest] = await Promise.all([
+    sha256(issuerKey),
+    sha256(tokenChallenge().serialize())
+  ]);
+  const truncatedTokenKeyId = tokenKeyId[tokenKeyId.length - 1] ?? 0;
+  const inputs = Array.from({ length: Math.ceil(count) }, () => {
+    const nonce = crypto.getRandomValues(new Uint8Array(32));
+    return new AuthenticatorInput(
+      BLIND_RSA2,
+      BLIND_RSA2.value,
+      nonce,
+      challengeDigest,
+      tokenKeyId
+    );
+  });
+  const tokenInputs = inputs.map((input2) => input2.serialize());
+  const blinded = await blind(key, tokenInputs);
+  const pending = inputs.map((authInput, index) => {
+    const tokenInput = tokenInputs[index];
+    const { blindedMsg, inv: blindInv } = blinded[index];
+    let inv = blindInv;
+    const request = new TokenRequest3(truncatedTokenKeyId, blindedMsg, BLIND_RSA2);
+    return {
       request: toBase64Url(request.serialize()),
       async finalize(signature) {
-        const response = client.deserializeTokenResponse(fromBase64Url(signature));
-        const token = await client.finalize(response);
-        return toBase64Url(token.serialize());
+        if (inv === void 0) throw new Error("token was already finalized");
+        const response = TokenResponse3.deserialize(fromBase64Url(signature));
+        const authenticator = await finalize2(key, tokenInput, response.blindSig, inv);
+        inv = void 0;
+        return toBase64Url(new Token(BLIND_RSA2, authInput, authenticator).serialize());
       }
-    });
-  }
+    };
+  });
   return pending;
 }
+async function sha256(data) {
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", data.slice()));
+}
 
 // ../client/src/index.ts
 async function getIssuer(gatewayUrl, fetchFn = fetch) {

package/dist/chunks/{hook-CCXQ4T4L.js → hook-IWRRBFKG.js}

@@ -15,7 +15,7 @@ import {
   needsRefill,
   redeem,
   refillSize
-} from "./chunk-XJOIDBXC.js";
+} from "./chunk-UFBFF3R6.js";
 import {
   clampTokensPerPage,
   settingsFor

package/dist/chunks/{hook-process-YHSATQFR.js → hook-process-Y2W56T2X.js}

@@ -25,7 +25,7 @@ async function runHookProcess(argument = process.argv[3]) {
   if (isCursorPayload(payload)) process.stdout.write("{}\n");
   if (!turnEnd(payload) && hookDomains(payload).length === 0) return;
   if (await startPayment(raw)) return;
-  const { runHook } = await import("./hook-CCXQ4T4L.js");
+  const { runHook } = await import("./hook-IWRRBFKG.js");
   await runHook({
     readInput: async () => raw,
     settings: resolveSettings(),
@@ -33,7 +33,7 @@ async function runHookProcess(argument = process.argv[3]) {
   });
 }
 async function runPayProcess() {
-  const { PAY_TIMEOUT_MS, runHook } = await import("./hook-CCXQ4T4L.js");
+  const { PAY_TIMEOUT_MS, runHook } = await import("./hook-IWRRBFKG.js");
   setTimeout(() => process.exit(0), PAY_TIMEOUT_MS + 1e3).unref();
   const raw = await readStdin(HOOK_TIMEOUT_MS);
   await runHook(

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tempoxyz/patron",
-	"version": "0.0.18",
+	"version": "0.0.20",
 	"description": "Pay the websites your AI agents read, privately",
 	"type": "module",
 	"bin": {