shinjuku-shielded 0.3.60 → 0.3.61

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "ad143a47257fa8b5e147ba3f6b662576794b06184abbedce42fd4f74993d9b7e",
-  "bytes": 12161659,
-  "sourceCommit": "187538a77af6d819ea08912f6406834a8e144e22",
+  "sha256": "fd8f40cfc0110953e30d8479bfe751545e04952df8faf03b634073d7fd308c78",
+  "bytes": 12166389,
+  "sourceCommit": "c40abda927c59b08675a7e8c6067ace24cf24e78",
   "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-22T05:12:25.176Z"
+  "publishedAt": "2026-10-22T06:27:33.519Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.60",
+  "version": "0.3.61",
   "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": "ad143a47",
-  "shinjukuSha256": "ad143a47257fa8b5e147ba3f6b662576794b06184abbedce42fd4f74993d9b7e",
+  "shinjukuRelease": "fd8f40cf",
+  "shinjukuSha256": "fd8f40cfc0110953e30d8479bfe751545e04952df8faf03b634073d7fd308c78",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -47661,7 +47661,7 @@ function readE1TreeAccount(bytes2) {
     leaves: v.getUint32(RIGHTMOST_OFFSET + 32 * D + 32, true)
   };
 }
-var E1, E1_VALUES_PER_TAG, E1_INPUTS_PER_TAG, E1_REPLAY_INPUT_INDICES, E1_ERROR_CODES, D, B, C, LOWER, TREE_MAGIC, CHANGELOG_BYTES, CHANGELOGS_OFFSET, RIGHTMOST_OFFSET, CANOPY_OFFSET, CANOPY_NODES, ZERO, MAX2, fail, eq32, isZero, u32le, asValue, node, EMPTY_NODES, hashToParent, B58, R_FIELD, CPROOF, bigOf, isCanonical, E1_LOADED_ACCOUNT_SIZES, ACCOUNT_OVERHEAD, sizeOk, hexOf, E1TreeMirror;
+var E1, E1_VALUES_PER_TAG, E1_INPUTS_PER_TAG, E1_REPLAY_INPUT_INDICES, E1_ERROR_CODES, D, B, C, LOWER, TREE_MAGIC, CHANGELOG_BYTES, CHANGELOGS_OFFSET, RIGHTMOST_OFFSET, CANOPY_OFFSET, CANOPY_NODES, ZERO, MAX2, fail, eq32, isZero, u32le, asValue, node, EMPTY_NODES, hashToParent, B58, R_FIELD, CPROOF, bigOf, isCanonical, E1_LOADED_ACCOUNT_SIZES, ACCOUNT_OVERHEAD, sizeOk, hexOf, BUILD_STEP_NODES, E1TreeMirror;
 var init_p03E1Tree = __esm({
   "wallet/vendor/shared/p03E1Tree.mjs"() {
     "use strict";
@@ -47772,6 +47772,7 @@ var init_p03E1Tree = __esm({
       for (const x of b) s4 += x.toString(16).padStart(2, "0");
       return s4;
     };
+    BUILD_STEP_NODES = 64;
     E1TreeMirror = class _E1TreeMirror {
       #levels;
       // #levels[l][i] = node at level l (0 = leaves), undefined = empty subtree
@@ -47789,14 +47790,28 @@ var init_p03E1Tree = __esm({
       }
       /** Sentinel, then every value in the given order (chain order, each settle already sorted). */
       static fromOrderedValues(values) {
+        const build2 = _E1TreeMirror.fromOrderedValuesSteps(values);
+        for (; ; ) {
+          const step = build2.next();
+          if (step.done) return step.value;
+        }
+      }
+      /**
+       * fromOrderedValues in steps, for a caller that keeps its thread free between them (the wallet
+       * builds the tree of its cached settles at start, in slices): one step per value inserted and per
+       * BUILD_STEP_NODES hashes. The generator returns the mirror fromOrderedValues returns, and throws
+       * where it throws.
+       */
+      static *fromOrderedValuesSteps(values) {
         const m = new _E1TreeMirror();
         m.#sorted.push(m.#pushLeaf({ value: ZERO, nextValue: MAX2, nextIndex: 0 }));
         for (const v of values) {
           asValue(v);
           if (isZero(v)) fail("p03_e1_value_zero");
           m.#linkInsert(v);
+          yield;
         }
-        m.#rebuildNodes();
+        yield* m.#rebuildNodes();
         return m;
       }
       clone() {
@@ -47918,11 +47933,20 @@ var init_p03E1Tree = __esm({
           this.#levels[l + 1][i >>> 1] = n;
         }
       }
-      #rebuildNodes() {
-        this.#levels[0] = this.#leaves.map((l) => e1LeafHash(l));
+      // Every node from the leaves up, a step per BUILD_STEP_NODES hashes (fromOrderedValuesSteps).
+      *#rebuildNodes() {
+        const hashed = new Array(this.#leaves.length);
+        for (let i = 0; i < hashed.length; i++) {
+          hashed[i] = e1LeafHash(this.#leaves[i]);
+          if ((i + 1) % BUILD_STEP_NODES === 0) yield;
+        }
+        this.#levels[0] = hashed;
         for (let l = 0; l < D; l++) {
           const below = this.#levels[l], up = new Array(Math.ceil(below.length / 2));
-          for (let i = 0; i < up.length; i++) up[i] = node(below[2 * i], below[2 * i + 1] ?? EMPTY_NODES[l]);
+          for (let i = 0; i < up.length; i++) {
+            up[i] = node(below[2 * i], below[2 * i + 1] ?? EMPTY_NODES[l]);
+            if ((i + 1) % BUILD_STEP_NODES === 0) yield;
+          }
           this.#levels[l + 1] = up;
         }
       }
@@ -54664,19 +54688,70 @@ function initializationReplayStore(instruction) {
   if (data.length === 123 && data[122] === REPLAY_STORE_INDEXED) return REPLAY_STORE_INDEXED;
   return void 0;
 }
-function replayedE1Mirror(key, settles, matchesChain) {
+function e1SettleCopies(settles) {
   const wellFormed2 = settles.every((values) => Array.isArray(values) && values.every((value) => value instanceof Uint8Array && value.length === 32));
-  const copies = wellFormed2 ? settles.map((values) => values.map((value) => Uint8Array.from(value))) : settles;
-  const settleKeys = wellFormed2 ? copies.map((values) => values.map((value) => Buffer.from(value).toString("hex")).join("")) : void 0;
+  if (!wellFormed2) return { copies: settles, keys: void 0 };
+  const copies = settles.map((values) => values.map((value) => Uint8Array.from(value)));
+  return { copies, keys: copies.map((values) => values.map((value) => Buffer.from(value).toString("hex")).join("")) };
+}
+function runE1TreeCandidate(candidate, untilMs = Infinity) {
+  try {
+    while (candidate.mirror === void 0 && !candidate.failed) {
+      const step = candidate.build.next();
+      if (step.done) candidate.mirror = step.value;
+      else if (performance.now() >= untilMs) break;
+    }
+  } catch {
+    candidate.failed = true;
+  }
+  return candidate.failed ? void 0 : candidate.mirror;
+}
+function startE1TreeCandidate({ key, settles, sliceMs = 8 }) {
+  try {
+    if (lastVerifiedE1Tree?.key === key || e1TreeCandidate?.key === key) return void 0;
+    const { copies, keys: keys3 } = e1SettleCopies(settles);
+    if (keys3 === void 0) return void 0;
+    const candidate = {
+      key,
+      settles: keys3,
+      build: E1TreeMirror.fromOrderedValuesSteps(copies.flatMap((values) => e1SortValues(values))),
+      mirror: void 0,
+      failed: false
+    };
+    e1TreeCandidate = candidate;
+    let hurry = false;
+    const done = (async () => {
+      while (e1TreeCandidate === candidate && candidate.mirror === void 0 && !candidate.failed) {
+        runE1TreeCandidate(candidate, hurry ? Infinity : performance.now() + sliceMs);
+        if (candidate.mirror === void 0 && !candidate.failed) await new Promise((resolve38) => setImmediate(resolve38));
+      }
+      return candidate.mirror !== void 0 && !candidate.failed;
+    })();
+    return { done, hurry: () => {
+      hurry = true;
+    } };
+  } catch {
+    return void 0;
+  }
+}
+function replayedE1Mirror(key, settles, matchesChain) {
+  const { copies, keys: settleKeys } = e1SettleCopies(settles);
+  const wellFormed2 = settleKeys !== void 0;
+  const startsThis = (kept) => kept.length <= settleKeys.length && kept.every((value, index) => value === settleKeys[index]);
+  const candidate = e1TreeCandidate?.key === key ? e1TreeCandidate : void 0;
+  if (candidate !== void 0) e1TreeCandidate = void 0;
   const last = lastVerifiedE1Tree;
-  if (wellFormed2 && last?.key === key && last.settles.length <= settleKeys.length && last.settles.every((value, index) => value === settleKeys[index])) {
+  const base = !wellFormed2 ? void 0 : last?.key === key && startsThis(last.settles) ? { settles: last.settles, mirror: () => last.mirror.clone(), count: "extended" } : candidate !== void 0 && startsThis(candidate.settles) ? { settles: candidate.settles, mirror: () => runE1TreeCandidate(candidate), count: "candidate" } : void 0;
+  if (base !== void 0) {
     try {
-      const mirror2 = last.mirror.clone();
-      for (const values of copies.slice(last.settles.length)) mirror2.insertSettle(values);
-      if (matchesChain(mirror2)) {
-        lastVerifiedE1Tree = { key, settles: settleKeys, mirror: mirror2 };
-        e1ReplayCounts.extended += 1;
-        return mirror2;
+      const mirror2 = base.mirror();
+      if (mirror2 !== void 0) {
+        for (const values of copies.slice(base.settles.length)) mirror2.insertSettle(values);
+        if (matchesChain(mirror2)) {
+          lastVerifiedE1Tree = { key, settles: settleKeys, mirror: mirror2 };
+          e1ReplayCounts[base.count] += 1;
+          return mirror2;
+        }
       }
     } catch {
     }
@@ -55528,7 +55603,7 @@ function base58Decode(value) {
   while (zeros < value.length && value[zeros] === "1") zeros += 1;
   return Uint8Array.from(Buffer.concat([Buffer.alloc(zeros), body]));
 }
-var import_web396, b58Cache, b58, REPLAY_STORE_INDEXED, CLOSE_REPLAY_TREE_TAG, EXTEND_ANCHOR_RING_TAG, WIDEN_ANCHOR_RING_TAG, WIDE_ANCHOR_RING_POOL_BYTES, LINK_SUCCESSOR_TAG, IMPORT_REPLAY_LEAVES_TAG, SETTLE_MOVE_TAG, SWEEP_PREDECESSOR_VAULT_TAG, RELINK_SUCCESSOR_TAG, ROTATE_PAYMENT_SETTLER_TAG, IMPORT_A_LEAF_BYTES, IMPORT_MEMBERSHIP_BYTES, IMPORT_PRESENT_SHIFT, IMPORT_MAX_ENTRIES, MOVE_HEAD_BYTES, MOVE_INSERTED_VALUES, DEFAULT_KEY, FIELD_BYTES2, PRIMARY_PROOF_BYTES, SUBTREE_LEAVES, PAGE_SIZE, FIELD_MODULUS3, BPF_LOADER_UPGRADEABLE_PROGRAM_ID, SYSTEM_PROGRAM, TEST_EXECUTABLES, derivationMemo, memo, reviewedExecutables, isProgramDataIdentityError, ASSUMED_ORIGINAL_EXECUTABLE, AUTHENTICATED_HISTORY_REPORTS, HISTORY_ATTESTATIONS, SNAPSHOT_POOL_STATES, REPORT_POOL_STATES, hasExecutableEvidence, P03_FINALIZED_HISTORY_SOURCE_MODEL, P03_PROGRAMDATA_COVERAGE_SOURCE_MODEL, P03_RUN_RECOVER_UNAVAILABLE_FROM_CHAIN, PROFILES, P03_SETTLEMENT_TAGS, P03_INLINE_SETTLEMENT_TAGS, P03_PAYMENT_REPLAY_INDICES, NO_CONTEXTS, REFRESH_READ_BYTES, E1_TREE_HEADER_BYTES, E1_TREE_MAGIC, E1_CHANGELOG_BYTES, E1_CHANGELOGS_OFFSET, E1_RIGHTMOST_OFFSET, E1_LEAF_COUNT_OFFSET, E1_CANOPY_OFFSET, E1_CANOPY_NODES, P03_POOL_SLICES_METHOD, POOL_SLICES, SLICED_ROOTS_OFFSET, SLICED_LEAVES_OFFSET, SLICES_REFUSED_ENDPOINTS, SLICES_REFUSED_CONNECTIONS, HISTORY_FETCH_CONCURRENCY, HISTORY_BULK_TRANSACTIONS, HISTORY_BULK_ADDRESSES, TRANSIENT_RPC_ATTEMPTS, TRANSIENT_RPC_BASE_DELAY_MS, LAGGING_NODE_STEP_OF_BASE, LAGGING_NODE_MAX_RETRIES, LAGGING_NODE_FAST_RETRIES, LAGGING_NODE_SLOW_STEP_OF_BASE, LAGGING_NODE_RPC_CODES, lastVerifiedE1Tree, e1ReplayCounts;
+var import_web396, b58Cache, b58, REPLAY_STORE_INDEXED, CLOSE_REPLAY_TREE_TAG, EXTEND_ANCHOR_RING_TAG, WIDEN_ANCHOR_RING_TAG, WIDE_ANCHOR_RING_POOL_BYTES, LINK_SUCCESSOR_TAG, IMPORT_REPLAY_LEAVES_TAG, SETTLE_MOVE_TAG, SWEEP_PREDECESSOR_VAULT_TAG, RELINK_SUCCESSOR_TAG, ROTATE_PAYMENT_SETTLER_TAG, IMPORT_A_LEAF_BYTES, IMPORT_MEMBERSHIP_BYTES, IMPORT_PRESENT_SHIFT, IMPORT_MAX_ENTRIES, MOVE_HEAD_BYTES, MOVE_INSERTED_VALUES, DEFAULT_KEY, FIELD_BYTES2, PRIMARY_PROOF_BYTES, SUBTREE_LEAVES, PAGE_SIZE, FIELD_MODULUS3, BPF_LOADER_UPGRADEABLE_PROGRAM_ID, SYSTEM_PROGRAM, TEST_EXECUTABLES, derivationMemo, memo, reviewedExecutables, isProgramDataIdentityError, ASSUMED_ORIGINAL_EXECUTABLE, AUTHENTICATED_HISTORY_REPORTS, HISTORY_ATTESTATIONS, SNAPSHOT_POOL_STATES, REPORT_POOL_STATES, hasExecutableEvidence, P03_FINALIZED_HISTORY_SOURCE_MODEL, P03_PROGRAMDATA_COVERAGE_SOURCE_MODEL, P03_RUN_RECOVER_UNAVAILABLE_FROM_CHAIN, PROFILES, P03_SETTLEMENT_TAGS, P03_INLINE_SETTLEMENT_TAGS, P03_PAYMENT_REPLAY_INDICES, NO_CONTEXTS, REFRESH_READ_BYTES, E1_TREE_HEADER_BYTES, E1_TREE_MAGIC, E1_CHANGELOG_BYTES, E1_CHANGELOGS_OFFSET, E1_RIGHTMOST_OFFSET, E1_LEAF_COUNT_OFFSET, E1_CANOPY_OFFSET, E1_CANOPY_NODES, P03_POOL_SLICES_METHOD, POOL_SLICES, SLICED_ROOTS_OFFSET, SLICED_LEAVES_OFFSET, SLICES_REFUSED_ENDPOINTS, SLICES_REFUSED_CONNECTIONS, HISTORY_FETCH_CONCURRENCY, HISTORY_BULK_TRANSACTIONS, HISTORY_BULK_ADDRESSES, TRANSIENT_RPC_ATTEMPTS, TRANSIENT_RPC_BASE_DELAY_MS, LAGGING_NODE_STEP_OF_BASE, LAGGING_NODE_MAX_RETRIES, LAGGING_NODE_FAST_RETRIES, LAGGING_NODE_SLOW_STEP_OF_BASE, LAGGING_NODE_RPC_CODES, lastVerifiedE1Tree, e1ReplayCounts, e1TreeCandidate;
 var init_walk = __esm({
   "wallet/src/history/walk.mjs"() {
     "use strict";
@@ -55817,7 +55892,7 @@ var init_walk = __esm({
     LAGGING_NODE_FAST_RETRIES = 5;
     LAGGING_NODE_SLOW_STEP_OF_BASE = 4.6;
     LAGGING_NODE_RPC_CODES = /* @__PURE__ */ new Set([-32004, -32016]);
-    e1ReplayCounts = { full: 0, extended: 0 };
+    e1ReplayCounts = { full: 0, extended: 0, candidate: 0 };
   }
 });
 
@@ -56737,6 +56812,31 @@ function startCompactPreFold(pool2, cached) {
   preFolds.set(pool2, preFold);
   return preFold;
 }
+function startCompactE1Candidate(programId, pool2, cached, preFold) {
+  const records = cached?.served?.records;
+  if (!Array.isArray(records) || records.length === 0) return void 0;
+  let hurry = false;
+  let running;
+  const done = (async () => {
+    await (preFold?.done ?? new Promise((resolve38) => setImmediate(resolve38)));
+    if (initializationReplayStore(cached.initialization) !== REPLAY_STORE_INDEXED2) return void 0;
+    const contexts = records.map((record) => ({
+      kind: record.kind,
+      provenance: { slot: record.slot, transactionIndex: record.transactionIndex, instructionIndex: record.instructionIndex },
+      replayValues: record.replayValues.map((value) => fieldOf(value))
+    }));
+    const imports = (Array.isArray(cached.served.imports) ? cached.served.imports : []).map((entry) => validateImport(entry, void 0));
+    running = startE1TreeCandidate({ key: `${programId}:${pool2}`, settles: compactTreeSettles(contexts, imports) });
+    if (running === void 0) return markPhase("compact-e1-ahead-skipped");
+    markPhase("compact-e1-ahead-start");
+    if (hurry) running.hurry();
+    return markPhase(await running.done ? "compact-e1-ahead-done" : "compact-e1-ahead-dropped");
+  })().catch(() => markPhase("compact-e1-ahead-skipped"));
+  return { done, hurry: () => {
+    hurry = true;
+    running?.hurry();
+  } };
+}
 function sparseRoots(roots, count2) {
   const array = new Array(count2 + 1);
   array[0] = zeroRoots()[OUTER_DEPTH2];
@@ -57707,6 +57807,7 @@ async function compactP03HistoryReportRun({
     }
   };
   const preFold = cached ? startCompactPreFold(poolKey.toBase58(), cached) : void 0;
+  const e1Ahead = cached ? startCompactE1Candidate(program.toBase58(), poolKey.toBase58(), cached, preFold) : void 0;
   const compact = await readCompactP03History({
     history,
     own: connection,
@@ -57733,6 +57834,10 @@ async function compactP03HistoryReportRun({
   let e1Tree;
   if (snapshot.replayStore === REPLAY_STORE_INDEXED2) {
     try {
+      if (e1Ahead !== void 0) {
+        e1Ahead.hurry();
+        await e1Ahead.done;
+      }
       e1Tree = assertP03E1TreeComplete({
         program,
         pool: poolKey,