shinjuku-shielded 0.3.55 → 0.3.56

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "70ff655b113c19d39c8594566c77d38fe7d459ea415f66cda1c09919841ad1a9",
-  "bytes": 12128720,
-  "sourceCommit": "d13f57d40a91eecbd9b06acd4f8c587d34bc256a",
+  "sha256": "e18d1d9537ea063f2a28f88b4db41a1b93067c5d5aa4f300daaddf80d8544074",
+  "bytes": 12133623,
+  "sourceCommit": "15d669c631b6ceb1237b994a9ce152d257c85a0c",
   "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",
@@ -1282,5 +1282,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-10-21T23:25:11.303Z"
+  "publishedAt": "2026-10-21T23:43:38.976Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.55",
+  "version": "0.3.56",
   "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": "70ff655b",
-  "shinjukuSha256": "70ff655b113c19d39c8594566c77d38fe7d459ea415f66cda1c09919841ad1a9",
+  "shinjukuRelease": "e18d1d95",
+  "shinjukuSha256": "e18d1d9537ea063f2a28f88b4db41a1b93067c5d5aa4f300daaddf80d8544074",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -56468,21 +56468,38 @@ function zeroRoots() {
   zeroRootsMemo = Object.freeze(roots);
   return zeroRootsMemo;
 }
-function foldCompactLeaves(leaves, counts, frontier) {
+function foldCompactLeavesFrom(leaves, counts, frontier, resume) {
   const zero = zeroRoots();
-  const filled = new Array(OUTER_DEPTH2);
+  let filled = new Array(OUTER_DEPTH2);
   const roots = /* @__PURE__ */ new Map();
   if (counts.has(0)) roots.set(0, zero[OUTER_DEPTH2]);
-  leaves.forEach((leaf, position3) => {
-    appendCompactLeaf(filled, leaf, position3);
-    if (counts.has(position3 + 1)) roots.set(position3 + 1, compactRootAt(filled, position3 + 1));
-  });
+  let position3 = 0;
+  let appended = 0;
+  const step = () => {
+    appendCompactLeaf(filled, leaves[position3], position3);
+    appended += 1;
+    position3 += 1;
+    if (counts.has(position3)) roots.set(position3, compactRootAt(filled, position3));
+  };
+  if (resume !== void 0) {
+    let below = 0;
+    for (const at of counts) {
+      if (at <= 0 || at > resume.at) continue;
+      const checkpoint = at === resume.at ? resume.filled : resume.checkpoints?.[at];
+      if (checkpoint !== void 0) roots.set(at, compactRootAt(checkpoint, at));
+      else if (at > below) below = at;
+    }
+    while (position3 < below) step();
+    filled = resume.filled.slice();
+    position3 = resume.at;
+  }
+  while (position3 < leaves.length) step();
   if (Array.isArray(frontier)) {
     for (let level = 0; level < OUTER_DEPTH2; level += 1) {
       frontier[level] = bitAt(leaves.length, level) === 1 ? filled[level] : zero[level];
     }
   }
-  return roots;
+  return { roots, filled, appended };
 }
 function appendCompactLeaf(filled, leaf, position3) {
   let node3 = leaf;
@@ -56509,7 +56526,9 @@ function foldCompactLeavesReusing(pool2, leaves, counts, { frontier, fresh = /*
     while (common < most && prior.leaves[common] === leaves[common]) common += 1;
   }
   const known = (at) => prior !== void 0 && at <= common && prior.roots.has(at) && !fresh.has(at);
-  const roots = foldCompactLeaves(leaves, new Set([...counts].filter((at) => !known(at))), frontier);
+  const resume = prior !== void 0 && Array.isArray(prior.filled) && prior.filled.length === OUTER_DEPTH2 && common > 0 && common === prior.leaves.length ? { at: common, filled: prior.filled, checkpoints: prior.checkpoints } : void 0;
+  const folded = foldCompactLeavesFrom(leaves, new Set([...counts].filter((at) => !known(at))), frontier, resume);
+  const { roots } = folded;
   if (prior !== void 0 && [...fresh].some((at) => at <= common && prior.roots.has(at) && roots.has(at) && prior.roots.get(at) !== roots.get(at))) {
     lastFolds.delete(pool2);
     if (stats) stats.refolded = true;
@@ -56524,7 +56543,7 @@ function foldCompactLeavesReusing(pool2, leaves, counts, { frontier, fresh = /*
       if (prior.tainted?.has(at)) cachedRoots.set(at, prior.roots.get(at));
     }
   }
-  if (stats) Object.assign(stats, { reused, cachedRoots });
+  if (stats) Object.assign(stats, { reused, cachedRoots, resumedFrom: resume?.at, appended: folded.appended });
   const kept = new Map(roots);
   const tainted = new Set(cachedRoots.keys());
   if (prior !== void 0) {
@@ -56534,9 +56553,75 @@ function foldCompactLeavesReusing(pool2, leaves, counts, { frontier, fresh = /*
       if (prior.tainted?.has(at)) tainted.add(at);
     }
   }
-  lastFolds.set(pool2, { leaves: leaves.slice(), roots: kept, ...tainted.size > 0 ? { tainted } : {} });
+  lastFolds.set(pool2, {
+    leaves: leaves.slice(),
+    roots: kept,
+    filled: folded.filled,
+    ...resume?.checkpoints !== void 0 ? { checkpoints: resume.checkpoints } : {},
+    ...tainted.size > 0 ? { tainted } : {}
+  });
   return roots;
 }
+function startCompactPreFold(pool2, cached) {
+  const running = preFolds.get(pool2);
+  if (running !== void 0) return running;
+  const records = cached?.served?.records;
+  if (lastFolds.has(pool2) || droppedPools.has(pool2) || !Array.isArray(records) || records.length === 0) return void 0;
+  let hurry = false;
+  const stats = { longestSliceMs: 0 };
+  const done = (async () => {
+    await new Promise((resolve38) => setImmediate(resolve38));
+    markPhase("compact-prefold-start");
+    const count2 = records.length;
+    let cachedCount;
+    let cachedRoot;
+    try {
+      cachedCount = BigInt(cached.snapshot.currentIndex) / SUBTREE_LEAVES3;
+      cachedRoot = BigInt(cached.snapshot.currentRoot);
+    } catch {
+      cachedCount = void 0;
+    }
+    if (cachedCount !== BigInt(count2)) return markPhase("compact-prefold-skipped-count");
+    const counts = /* @__PURE__ */ new Set([count2]);
+    const anchorCounts = cached.snapshot.anchorCounts;
+    if (Array.isArray(anchorCounts)) {
+      for (const at of anchorCounts) if (Number.isSafeInteger(at) && at > 0 && at <= count2) counts.add(at);
+    }
+    const leaves = [];
+    const filled = new Array(OUTER_DEPTH2);
+    const checkpoints = new Array(count2 + 1);
+    const roots = /* @__PURE__ */ new Map();
+    let sliceStart = performance.now();
+    for (let position3 = 0; position3 < count2; position3 += 1) {
+      const hex4 = records[position3]?.outCommitment;
+      if (typeof hex4 !== "string" || !HEX64.test(hex4)) return markPhase("compact-prefold-skipped-leaf");
+      const leaf = BigInt(`0x${hex4}`);
+      if (leaf >= FIELD_MODULUS5) return markPhase("compact-prefold-skipped-leaf");
+      leaves.push(leaf);
+      appendCompactLeaf(filled, leaf, position3);
+      checkpoints[position3 + 1] = filled.slice();
+      if (counts.has(position3 + 1)) roots.set(position3 + 1, compactRootAt(filled, position3 + 1));
+      const sliceMs = performance.now() - sliceStart;
+      if (!hurry && sliceMs >= PRE_FOLD_SLICE_MS) {
+        if (sliceMs > stats.longestSliceMs) stats.longestSliceMs = sliceMs;
+        await new Promise((resolve38) => setImmediate(resolve38));
+        if (lastFolds.has(pool2)) return markPhase("compact-prefold-skipped-folded");
+        sliceStart = performance.now();
+      }
+    }
+    if (!hurry) stats.longestSliceMs = Math.max(stats.longestSliceMs, performance.now() - sliceStart);
+    if (roots.get(count2) !== cachedRoot) return markPhase("compact-prefold-skipped-root");
+    if (lastFolds.has(pool2) || droppedPools.has(pool2)) return markPhase("compact-prefold-skipped-folded");
+    lastFolds.set(pool2, { leaves, roots, filled, checkpoints });
+    return markPhase("compact-prefold-done");
+  })().catch(() => {
+  }).finally(() => preFolds.delete(pool2));
+  const preFold = { done, hurry: () => {
+    hurry = true;
+  }, stats };
+  preFolds.set(pool2, preFold);
+  return preFold;
+}
 function sparseRoots(roots, count2) {
   const array = new Array(count2 + 1);
   array[0] = zeroRoots()[OUTER_DEPTH2];
@@ -57196,6 +57281,9 @@ async function readCompactP03HistoryNow({
   // compactP03HistoryReport: the compact cache's records and append roots ({ records, foldRoots }),
   // a hint for the fold when this process has not folded the pool yet (hintCompactFold).
   foldHint,
+  // compactP03HistoryReport: the pre-fold of the cached leaves started while this read waits for
+  // the pool account (startCompactPreFold, 2026-10-21). The fold below waits for its end first.
+  preFold,
   // Called once with the served contexts in chain order, before the fold and every own-RPC
   // check: they are NOT verified yet. A payment asks the memo service for their memos here
   // (payAndFetch.mjs), and uses an answer only for a context the verified report names. Its
@@ -57315,6 +57403,10 @@ async function readCompactP03HistoryNow({
   reads.catch(() => {
   });
   await new Promise((resolve38) => setImmediate(resolve38));
+  if (preFold !== void 0) {
+    preFold.hurry();
+    await preFold.done;
+  }
   let frontier;
   let stats;
   try {
@@ -57332,7 +57424,9 @@ async function readCompactP03HistoryNow({
     }
     stats = {};
     roots = foldCompactLeavesReusing(poolString, leaves, counts, { frontier, fresh, stats });
-    if (stats.reused > 0 && anchors.some((anchor) => roots.get(Number(anchor.index / SUBTREE_LEAVES3)) !== anchor.root)) {
+    const resumed = stats.resumedFrom !== void 0;
+    if (resumed) markPhase("compact-fold-resumed");
+    if ((stats.reused > 0 || resumed) && (roots.get(count2) !== snapshot.currentRoot || anchors.some((anchor) => roots.get(Number(anchor.index / SUBTREE_LEAVES3)) !== anchor.root))) {
       lastFolds.delete(poolString);
       stats.refolded = true;
       roots = foldCompactLeavesReusing(poolString, leaves, counts, { frontier, fresh });
@@ -57497,12 +57591,14 @@ async function compactP03HistoryReportRun({
       throw Object.assign(refuse3("p03_compact_history_deployment_unattested"), { cause: error, detail: own ?? failureCause(error) });
     }
   };
+  const preFold = cached ? startCompactPreFold(poolKey.toBase58(), cached) : void 0;
   const compact = await readCompactP03History({
     history,
     own: connection,
     programId,
     pool: pool2,
     alongside: attest,
+    ...preFold !== void 0 ? { preFold } : {},
     ...knownIndex !== void 0 ? { knownIndex } : {},
     ...knownSnapshot !== void 0 ? { knownSnapshot } : {},
     ...knownFirst !== void 0 ? { knownFirst } : {},
@@ -57578,7 +57674,10 @@ async function compactP03HistoryReportRun({
           slot: Number(snapshot.slot),
           terminal: snapshot.terminal,
           currentIndex: snapshot.currentIndex.toString(),
-          currentRoot: snapshot.currentRoot.toString()
+          currentRoot: snapshot.currentRoot.toString(),
+          // The anchor counts of this pool account (public; 2026-10-21, B): the next process's
+          // pre-fold hashes their roots ahead. Counts only: every root is checked live again.
+          anchorCounts: [...new Set(compact.finalizedPoolSnapshot.anchors.map((anchor) => Number(anchor.index / SUBTREE_LEAVES3)))]
         },
         served: compact.served,
         initialization,
@@ -57604,7 +57703,7 @@ async function tryCompactP03HistoryReport(options) {
     return { ok: false, reason, ...detail ? { detail } : {}, error };
   }
 }
-var import_web397, P03_COMPACT_HISTORY_SOURCE_MODEL, P03_COMPACT_PAGE, P03_COMPACT_SPOT_CHECKS, FIELD_MODULUS5, SUBTREE_LEAVES3, LOCAL_DEPTH2, OUTER_DEPTH2, PRIMARY_PROOF_BYTES2, FIELD_BYTES3, ED25519_SPKI_PREFIX2, VERSION_1_PREFIX2, HEX64, BASE58, REPLAY_STORE_INDEXED2, PROFILES2, MOVE_HEAD_BYTES2, MOVE_INSERTED_VALUES2, refuse3, hash4, bitAt, zeroRootsMemo, lastFolds, hex64, droppedPools, verifyQuietMs, VERIFY_SLICE_MS, VERIFY_POLL_MS, verifying, unrefTurn, isSignature, isIndex, IMPORT_KEYS, IMPORT_MAX_VALUES, LIST_ATTEMPTS, OWN_READ_TIMEOUT_MS, BOUNDED_OWN_METHODS, compactReportsRunning, compactHistoryReadsRunning;
+var import_web397, P03_COMPACT_HISTORY_SOURCE_MODEL, P03_COMPACT_PAGE, P03_COMPACT_SPOT_CHECKS, FIELD_MODULUS5, SUBTREE_LEAVES3, LOCAL_DEPTH2, OUTER_DEPTH2, PRIMARY_PROOF_BYTES2, FIELD_BYTES3, ED25519_SPKI_PREFIX2, VERSION_1_PREFIX2, HEX64, BASE58, REPLAY_STORE_INDEXED2, PROFILES2, MOVE_HEAD_BYTES2, MOVE_INSERTED_VALUES2, refuse3, hash4, bitAt, zeroRootsMemo, lastFolds, PRE_FOLD_SLICE_MS, preFolds, hex64, droppedPools, verifyQuietMs, VERIFY_SLICE_MS, VERIFY_POLL_MS, verifying, unrefTurn, isSignature, isIndex, IMPORT_KEYS, IMPORT_MAX_VALUES, LIST_ATTEMPTS, OWN_READ_TIMEOUT_MS, BOUNDED_OWN_METHODS, compactReportsRunning, compactHistoryReadsRunning;
 var init_compact = __esm({
   "wallet/src/history/compact.mjs"() {
     "use strict";
@@ -57717,6 +57816,8 @@ var init_compact = __esm({
     hash4 = (left, right) => poseidon2([left, right], 3);
     bitAt = (value, level) => Math.floor(value / 2 ** level) % 2;
     lastFolds = /* @__PURE__ */ new Map();
+    PRE_FOLD_SLICE_MS = 8;
+    preFolds = /* @__PURE__ */ new Map();
     hex64 = (value) => value.toString(16).padStart(64, "0");
     droppedPools = /* @__PURE__ */ new Set();
     verifyQuietMs = 3e3;