shinjuku-shielded 0.3.43 → 0.3.44

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "0ff1dea585d7a2ca69e0a37f43684dcb411f5a28eafa84a3f7fee65f5cd13904",
-  "bytes": 11235804,
-  "sourceCommit": "20e5a0c5b4faa27b1309e57816901b0ba77c78ce",
+  "sha256": "99e5ce600a930373051d72e16b2fe75bec451cfbdd509439e58546d0e77058d2",
+  "bytes": 11247206,
+  "sourceCommit": "5a8c47eba8d07d89334e63f6467f17692e009d30",
   "sourceDirty": false,
   "installRecordMatchesLockfile": true,
   "releaseRule": "valid only when two fresh npm ci --ignore-scripts builds on different OSes give the same sha256; installRecordMatchesLockfile true means every entry npm installed equals its package-lock.json entry and every entry not marked optional, devOptional included, is installed: an optional entry (a package for another platform) may be absent",

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.43",
+  "version": "0.3.44",
   "mcpName": "io.github.ShinjukuStaition/shinjuku-mcp",
   "description": "Shinjuku Shielded, the private x402 facilitator on Solana: the self-custody wallet CLI and its MCP server. Shield, pay, and unshield USDC from any MCP agent, under caps you set.",
-  "shinjukuRelease": "0ff1dea5",
-  "shinjukuSha256": "0ff1dea585d7a2ca69e0a37f43684dcb411f5a28eafa84a3f7fee65f5cd13904",
+  "shinjukuRelease": "99e5ce60",
+  "shinjukuSha256": "99e5ce600a930373051d72e16b2fe75bec451cfbdd509439e58546d0e77058d2",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -96641,6 +96641,312 @@ var init_config = __esm({
   }
 });
 
+// wallet/src/seller/memoEcdhWorker.mjs
+import { Worker as Worker3 } from "node:worker_threads";
+function createMemoEcdhWorker(options) {
+  const threads = Array.from({ length: WORKER_THREADS }, () => createThread(options));
+  const compute = (memoBundle) => {
+    const records = Math.floor(memoBundle.length / MEMO_RECORD_BYTES2);
+    const share = Math.ceil(records / threads.length);
+    const jobs = [];
+    for (let index = 0; index < threads.length; index += 1) {
+      const from = index * share;
+      const to = Math.min(records, from + share);
+      if (from >= to) continue;
+      const job = threads[index].compute(memoBundle.subarray(from * MEMO_RECORD_BYTES2, to * MEMO_RECORD_BYTES2));
+      if (job !== void 0) jobs.push(job);
+    }
+    if (jobs.length === 0) return void 0;
+    const result = Promise.all(jobs.map((job) => job.result)).then((parts) => parts.flatMap((part) => part ?? [])).catch(() => void 0);
+    return { result, cancel: () => {
+      for (const job of jobs) job.cancel();
+    } };
+  };
+  return {
+    warm: () => {
+      for (const thread of threads) thread.warm();
+    },
+    compute: (memoBundle) => {
+      try {
+        return compute(memoBundle);
+      } catch {
+        return void 0;
+      }
+    },
+    close: () => {
+      for (const thread of threads) thread.close();
+    }
+  };
+}
+function createThread({ scalar, curvePointFromX, sharedXOf, log }) {
+  let worker;
+  let verified = false;
+  let disabled = false;
+  let closed = false;
+  let lastStartAt = -Infinity;
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const say6 = (line) => {
+    try {
+      log(line);
+    } catch {
+    }
+  };
+  const settleAll = () => {
+    for (const resolve38 of pending.values()) resolve38(void 0);
+    pending.clear();
+  };
+  const drop = (current) => {
+    if (worker !== current) return;
+    worker = void 0;
+    verified = false;
+    settleAll();
+    current.terminate().catch(() => void 0);
+  };
+  const post = (current, message) => {
+    try {
+      current.postMessage(message);
+      return true;
+    } catch {
+      drop(current);
+      return false;
+    }
+  };
+  const start = () => {
+    if (worker !== void 0 || disabled || closed || performance.now() - lastStartAt < WORKER_RESTART_MS) return;
+    lastStartAt = performance.now();
+    let current;
+    let expected;
+    try {
+      const point = curvePointFromX(CHECK_X);
+      expected = [point.x.toString(16), point.y.toString(16), sharedXOf(point).toString(16)].join(":");
+      current = new Worker3(WORKER_SOURCE2, { eval: true, execArgv: [], workerData: { scalar: scalar.toString() } });
+    } catch (error) {
+      say6(`SELLER_MEMO_ECDH_WORKER_START_FAILED ${error?.name ?? "Error"}`);
+      return;
+    }
+    worker = current;
+    const checkId = nextId++;
+    pending.set(checkId, (out) => {
+      if (worker !== current) return;
+      if (Array.isArray(out) && out.length === 1 && Array.isArray(out[0]) && out[0].join(":") === expected) {
+        verified = true;
+        return;
+      }
+      disabled = true;
+      say6("SELLER_MEMO_ECDH_WORKER_CHECK_FAILED the intake computes in the scan for this process");
+      drop(current);
+    });
+    current.on("message", (message) => {
+      try {
+        const resolve38 = pending.get(message?.id);
+        if (resolve38 === void 0) return;
+        pending.delete(message.id);
+        resolve38(message.failed === true || !Array.isArray(message.out) ? void 0 : message.out);
+      } catch {
+        drop(current);
+      }
+    });
+    current.on("error", (error) => {
+      if (worker === current) say6(`SELLER_MEMO_ECDH_WORKER_FAILED ${error?.name ?? "Error"}`);
+      drop(current);
+    });
+    current.on("messageerror", () => {
+      drop(current);
+    });
+    current.on("exit", (code) => {
+      if (worker === current && !closed) say6(`SELLER_MEMO_ECDH_WORKER_EXIT ${Number.isInteger(code) ? code : "?"}`);
+      drop(current);
+    });
+    current.unref();
+    post(current, { id: checkId, check: CHECK_X.toString() });
+  };
+  const compute = (memoBundle) => {
+    start();
+    const current = worker;
+    if (current === void 0) return void 0;
+    const id = nextId++;
+    const result = new Promise((resolve38) => {
+      pending.set(id, (out) => {
+        if (!verified || worker !== current || !Array.isArray(out)) {
+          resolve38(void 0);
+          return;
+        }
+        try {
+          resolve38(out.map((row) => {
+            if (!Array.isArray(row) || row.length !== 3 || !row.every((part) => /^[0-9a-f]{1,64}$/.test(part))) throw new Error("row");
+            return [`${BigInt(`0x${row[0]}`)}:${BigInt(`0x${row[1]}`)}`, BigInt(`0x${row[2]}`)];
+          }));
+        } catch {
+          resolve38(void 0);
+        }
+      });
+    }).catch(() => void 0);
+    if (!post(current, { id, bundle: Uint8Array.from(memoBundle) })) return void 0;
+    const cancel = () => {
+      const resolve38 = pending.get(id);
+      if (resolve38 === void 0) return;
+      pending.delete(id);
+      resolve38(void 0);
+      if (worker === current) post(current, { cancel: id });
+    };
+    return { result, cancel };
+  };
+  return {
+    warm: () => {
+      try {
+        start();
+      } catch {
+      }
+    },
+    compute: (memoBundle) => {
+      try {
+        return compute(memoBundle);
+      } catch {
+        return void 0;
+      }
+    },
+    close: () => {
+      closed = true;
+      const current = worker;
+      worker = void 0;
+      settleAll();
+      current?.terminate().catch(() => void 0);
+    }
+  };
+}
+var MEMO_RECORD_BYTES2, WORKER_RESTART_MS, WORKER_THREADS, CHECK_X, WORKER_SOURCE2;
+var init_memoEcdhWorker = __esm({
+  "wallet/src/seller/memoEcdhWorker.mjs"() {
+    "use strict";
+    MEMO_RECORD_BYTES2 = 200;
+    WORKER_RESTART_MS = 6e4;
+    WORKER_THREADS = 2;
+    CHECK_X = 5n;
+    WORKER_SOURCE2 = `"use strict";
+const { parentPort, workerData } = require("node:worker_threads");
+const P = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+const RECORD_BYTES = ${MEMO_RECORD_BYTES2};
+const SLICE_MS = 8;
+const mod = (value) => { const result = value % P; return result >= 0n ? result : result + P; };
+function powMod(baseInput, exponentInput) {
+  let base = mod(baseInput); let exponent = exponentInput; let result = 1n;
+  while (exponent > 0n) { if ((exponent & 1n) === 1n) result = mod(result * base); base = mod(base * base); exponent >>= 1n; }
+  return result;
+}
+function inverse(value) {
+  const normalized = mod(value);
+  if (normalized === 0n) throw new Error();
+  return powMod(normalized, P - 2n);
+}
+function inversePublic(value) {
+  let x = mod(value);
+  if (x === 0n) throw new Error();
+  let y = P; let u = 1n; let v = 0n;
+  while (x !== 0n) { const q = y / x; const r = y - q * x; y = x; x = r; const next = v - q * u; v = u; u = next; }
+  return mod(v);
+}
+const D = mod(-168696n * inverse(168700n));
+const LEGENDRE = (P - 1n) / 2n;
+let SQ = P - 1n; let SS = 0n;
+while ((SQ & 1n) === 0n) { SQ >>= 1n; SS += 1n; }
+const NON_RESIDUE_POWER = (() => { let z = 2n; while (powMod(z, LEGENDRE) !== P - 1n) z += 1n; return powMod(z, SQ); })();
+function sqrt(value) {
+  const normalized = mod(value);
+  if (normalized === 0n) return 0n;
+  const w = powMod(normalized, (SQ - 1n) / 2n);
+  let t = mod(w * w * normalized);
+  let legendre = t;
+  for (let square = 1n; square < SS; square += 1n) legendre = mod(legendre * legendre);
+  if (legendre !== 1n) return undefined;
+  let m = SS; let c = NON_RESIDUE_POWER; let root = mod(w * normalized);
+  while (t !== 1n) {
+    let i = 1n; let squared = mod(t * t);
+    while (squared !== 1n) { squared = mod(squared * squared); i += 1n; if (i >= m) throw new Error(); }
+    const b = powMod(c, 1n << (m - i - 1n));
+    root = mod(root * b); c = mod(b * b); t = mod(t * c); m = i;
+  }
+  return root;
+}
+function pointFromX(x) {
+  if (x >= P) throw new Error();
+  const x2 = mod(x * x);
+  const denominator = mod(1n - D * x2);
+  if (denominator === 0n) throw new Error();
+  const y = sqrt(mod((x2 + 1n) * inversePublic(denominator)));
+  if (y === undefined) throw new Error();
+  return { x, y };
+}
+const toExtended = (point) => ({ x: point.x, y: point.y, t: mod(point.x * point.y), z: 1n });
+const toTable = (point) => ({ x: point.x, y: point.y, t: point.t, z: point.z, dt: mod(D * point.t) });
+function addTable(left, right) {
+  const a = mod(left.x * right.x); const b = mod(left.y * right.y);
+  const c = mod(left.t * right.dt); const d = mod(left.z * right.z);
+  const h = b + a; const e = mod((left.x + left.y) * (right.x + right.y) - h);
+  const f = d - c; const g = d + c;
+  return { x: mod(e * f), y: mod(g * h), t: mod(e * h), z: mod(f * g) };
+}
+function double(point, withT) {
+  const a = mod(point.x * point.x); const b = mod(point.y * point.y);
+  const c = mod(2n * point.z * point.z); const sum = point.x + point.y;
+  const e = mod(sum * sum - a - b); const g = b - a; const f = g - c; const h = -a - b;
+  return { x: mod(e * f), y: mod(g * h), t: withT ? mod(e * h) : 0n, z: mod(f * g) };
+}
+function sharedX(point, scalar) {
+  const table = [toTable(toExtended({ x: 0n, y: 1n })), toTable(toExtended(point))];
+  for (let index = 2; index < 16; index += 1) table.push(toTable(addTable(table[index - 1], table[1])));
+  const windows = scalar === 0n ? 1 : Math.ceil(scalar.toString(2).length / 4);
+  let result = table[Number((scalar >> BigInt((windows - 1) * 4)) & 15n)];
+  for (let window = windows - 2; window >= 0; window -= 1) {
+    for (let bit = 0; bit < 4; bit += 1) result = double(result, bit === 3);
+    result = addTable(result, table[Number((scalar >> BigInt(window * 4)) & 15n)]);
+  }
+  return mod(result.x * inverse(result.z));
+}
+const scalar = BigInt(workerData.scalar);
+const cancelled = new Set();
+const queue = [];
+let running = false;
+function entry(x) { const point = pointFromX(x); return [point.x.toString(16), point.y.toString(16), sharedX(point, scalar).toString(16)]; }
+async function run() {
+  running = true;
+  while (queue.length > 0) {
+    const job = queue.shift();
+    for (const id of cancelled) if (id < job.id) cancelled.delete(id);
+    // A job cancelled while it waited in the queue is not started.
+    if (cancelled.has(job.id)) { cancelled.delete(job.id); parentPort.postMessage({ id: job.id, out: [] }); continue; }
+    const out = [];
+    try {
+      if (job.check !== undefined) out.push(entry(BigInt(job.check)));
+      else {
+        const bundle = job.bundle;
+        let sliceStart = performance.now();
+        for (let offset = 0; offset + RECORD_BYTES <= bundle.length; offset += RECORD_BYTES) {
+          if (performance.now() - sliceStart >= SLICE_MS) {
+            await new Promise((resolveTurn) => { setImmediate(resolveTurn); });
+            sliceStart = performance.now();
+            if (cancelled.has(job.id)) break;
+          }
+          try { out.push(entry(BigInt("0x" + Buffer.from(bundle.subarray(offset, offset + 32)).toString("hex")))); }
+          catch { /* no point: the scan refuses or skips it as before */ }
+        }
+      }
+      parentPort.postMessage({ id: job.id, out: cancelled.delete(job.id) ? [] : out });
+    } catch {
+      parentPort.postMessage({ id: job.id, failed: true });
+    }
+  }
+  running = false;
+}
+parentPort.on("message", (message) => {
+  if (message.cancel !== undefined) { cancelled.add(message.cancel); return; }
+  queue.push(message);
+  if (!running) run();
+});
+`;
+  }
+});
+
 // wallet/src/seller/service.mjs
 import { createServer } from "node:http";
 import { randomBytes as randomBytes17 } from "node:crypto";
@@ -96777,26 +97083,12 @@ async function createSellerAdapter({
   const scanner = new ShieldedSolanaP03MemoScanner({ ecdh: {
     deriveSharedX: (point) => sharedXByPoint.get(`${point.x}:${point.y}`) ?? sharedXOf(point)
   } });
-  async function precomputeMemoSharedX(memoBundle, owned) {
-    let sliceStart = performance.now();
-    for (let offset = 0; offset + MEMO_RECORD_BYTES2 <= memoBundle.length; offset += MEMO_RECORD_BYTES2) {
-      if (performance.now() - sliceStart >= MEMO_PRECOMPUTE_SLICE_MS) {
-        await new Promise((resolveTurn) => {
-          setImmediate(resolveTurn);
-        });
-        sliceStart = performance.now();
-      }
-      if (owned.done) return;
-      try {
-        const point = shieldedSolanaP03CurvePointFromX(BigInt(`0x${Buffer.from(memoBundle.subarray(offset, offset + 32)).toString("hex")}`));
-        const key = `${point.x}:${point.y}`;
-        if (sharedXByPoint.has(key)) continue;
-        sharedXByPoint.set(key, sharedXOf(point));
-        owned.keys.push(key);
-      } catch {
-      }
-    }
-  }
+  const memoEcdh = createMemoEcdhWorker({
+    scalar: ecdhScalar,
+    curvePointFromX: shieldedSolanaP03CurvePointFromX,
+    sharedXOf,
+    log: (line) => console.error(line)
+  });
   const readChainAnchor = createAnchorReader({ connection: memoizeFinalizedReads(connection), profile });
   let anchorRequest;
   const requestFacilitatorAnchor = () => anchorRequest ??= (async () => {
@@ -97204,11 +97496,20 @@ async function createSellerAdapter({
         await quoteIssuer.authenticateForClaim(authInput);
         const authenticated = quoteIssuer.authenticate(authInput);
         authenticated.catch(() => void 0);
-        const owned = { keys: [], done: false };
+        const owned = { keys: [], done: false, cancel: void 0 };
         let precomputed;
-        if (precomputesRunning < MEMO_PRECOMPUTES_MAX) {
+        const job = precomputesRunning < MEMO_PRECOMPUTES_MAX ? memoEcdh.compute(parsed.memoBundle) : void 0;
+        if (job !== void 0) {
           precomputesRunning += 1;
-          precomputed = precomputeMemoSharedX(parsed.memoBundle, owned).catch(() => void 0).finally(() => {
+          owned.cancel = job.cancel;
+          precomputed = job.result.then((entries) => {
+            if (entries === void 0 || owned.done) return;
+            for (const [key, sharedX] of entries) {
+              if (sharedXByPoint.has(key)) continue;
+              sharedXByPoint.set(key, sharedX);
+              owned.keys.push(key);
+            }
+          }).catch(() => void 0).finally(() => {
             precomputesRunning -= 1;
           });
         }
@@ -97219,10 +97520,17 @@ async function createSellerAdapter({
           mark("intake-authenticated");
           intakeRead = readAnchor();
           intakeRead.catch(() => void 0);
-          await precomputed;
+          if (precomputed !== void 0) {
+            let timer;
+            await Promise.race([precomputed, new Promise((resolveWait) => {
+              timer = setTimeout(resolveWait, MEMO_PRECOMPUTE_WAIT_MS);
+            })]);
+            clearTimeout(timer);
+          }
           recoveredNote = await scanner.recoverMerchantNoteYielding({ parsed, authenticatedQuote: auth });
         } finally {
           owned.done = true;
+          owned.cancel?.();
           for (const key of owned.keys) sharedXByPoint.delete(key);
         }
         mark("intake-note-recovered");
@@ -97382,6 +97690,7 @@ async function createSellerAdapter({
     };
     await put(nonce, offer);
     mark("challenge");
+    memoEcdh.warm();
     return { status: 402, paymentRequired: issued.paymentRequired };
   }
   const server = createServer({ maxHeaderSize: 192 * 1024 }, async (request, response) => {
@@ -97436,6 +97745,7 @@ async function createSellerAdapter({
       }
     }
     closed = true;
+    memoEcdh.close();
     for (const timer of followUps.values()) clearTimeout(timer);
     followUps.clear();
   };
@@ -97453,7 +97763,7 @@ async function createSellerAdapter({
   }));
   return { server, handle, close, signerPublicKey, settledTransactions, offerSummaries };
 }
-var import_web3120, BINDING, SCHEMA2, OFFERS_LAYOUT, SNAPSHOT_EVERY_MS, LOADER2, canonical4, storeProfileIdentity, jsonSafe, bigint, encodeHeader, PAYMENT_REFUSED, FACILITATOR_UNDERFUNDED, DEFINITE_VERIFY_REFUSALS, definiteVerifyRefusal, refusedBeforeSettlement, ANCHOR_REQUEST_TIMEOUT_MS2, ANCHOR_POLL_ATTEMPTS, ANCHOR_POLL_MS, MEMO_RECORD_BYTES2, MEMO_PRECOMPUTE_SLICE_MS, MEMO_PRECOMPUTES_MAX, PRE_SETTLE_REUSE_MARGIN_S, PRE_SETTLE_REUSE_MAX_AGE_MS, FINALIZED_MEMO_MAX_AGE_MS, pause, FOLLOW_UP_DELAYS_MS, FOLLOW_UP_RESETTLE_FROM, CONFIRMED_TRANSACTION_READ;
+var import_web3120, BINDING, SCHEMA2, OFFERS_LAYOUT, SNAPSHOT_EVERY_MS, LOADER2, canonical4, storeProfileIdentity, jsonSafe, bigint, encodeHeader, PAYMENT_REFUSED, FACILITATOR_UNDERFUNDED, DEFINITE_VERIFY_REFUSALS, definiteVerifyRefusal, refusedBeforeSettlement, ANCHOR_REQUEST_TIMEOUT_MS2, ANCHOR_POLL_ATTEMPTS, ANCHOR_POLL_MS, MEMO_PRECOMPUTES_MAX, MEMO_PRECOMPUTE_WAIT_MS, PRE_SETTLE_REUSE_MARGIN_S, PRE_SETTLE_REUSE_MAX_AGE_MS, FINALIZED_MEMO_MAX_AGE_MS, pause, FOLLOW_UP_DELAYS_MS, FOLLOW_UP_RESETTLE_FROM, CONFIRMED_TRANSACTION_READ;
 var init_service = __esm({
   "wallet/src/seller/service.mjs"() {
     "use strict";
@@ -97470,6 +97780,7 @@ var init_service = __esm({
     init_config();
     init_receiptTransaction();
     init_timing();
+    init_memoEcdhWorker();
     BINDING = "carbon-shielded-exact/svm-v3";
     SCHEMA2 = "carbon-independent-seller-offers/v1";
     OFFERS_LAYOUT = "per-offer-v1";
@@ -97504,9 +97815,8 @@ var init_service = __esm({
     ANCHOR_REQUEST_TIMEOUT_MS2 = 9e4;
     ANCHOR_POLL_ATTEMPTS = 15;
     ANCHOR_POLL_MS = 2e3;
-    MEMO_RECORD_BYTES2 = 200;
-    MEMO_PRECOMPUTE_SLICE_MS = 8;
     MEMO_PRECOMPUTES_MAX = 2;
+    MEMO_PRECOMPUTE_WAIT_MS = 1e3;
     PRE_SETTLE_REUSE_MARGIN_S = 60;
     PRE_SETTLE_REUSE_MAX_AGE_MS = 2e4;
     FINALIZED_MEMO_MAX_AGE_MS = 1e3;