shinjuku-shielded 0.3.59 → 0.3.61

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "a18f4dcc8553e48c173aa610e7b3632d8edb25dbe317dd1f820e44673dd0fa39",
-  "bytes": 12158087,
-  "sourceCommit": "4274f17fee017d2010ae9d1ca94c5c03d200effc",
+  "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-22T04:38:17.814Z"
+  "publishedAt": "2026-10-22T06:27:33.519Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.59",
+  "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": "a18f4dcc",
-  "shinjukuSha256": "a18f4dcc8553e48c173aa610e7b3632d8edb25dbe317dd1f820e44673dd0fa39",
+  "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

@@ -42630,7 +42630,15 @@ function warmOnions({ onions = routedOnions(), fetchImpl = globalThis.fetch, tim
   }
   return () => controller.abort();
 }
-function raceOnions(onions, { fetchImpl = globalThis.fetch, timeoutMs = RACE_TIMEOUT_MS, path = "/api/health", onNone } = {}) {
+function raceOnions(onions, {
+  fetchImpl = globalThis.fetch,
+  timeoutMs = RACE_TIMEOUT_MS,
+  path = "/api/health",
+  onNone,
+  spares = [],
+  spareAfterMs = SPARE_AFTER_MS,
+  onSpares
+} = {}) {
   const controller = new AbortController();
   const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(timeoutMs)]);
   const probe = (onion) => Promise.resolve().then(() => fetchImpl(`${onion}${path}`, onionInit({ redirect: "error", signal, headers: { accept: "application/json" } }))).then((response) => {
@@ -42639,11 +42647,46 @@ function raceOnions(onions, { fetchImpl = globalThis.fetch, timeoutMs = RACE_TIM
     if (!response?.ok) throw new Error(`onion answered ${response?.status}`);
     return onion;
   });
-  const winner = Promise.any(onions.map(probe)).catch(() => {
-    if (!controller.signal.aborted) onNone?.();
-    return onions[0];
-  }).finally(() => controller.abort());
-  return { winner, abort: () => controller.abort() };
+  let startSpares = () => {
+  };
+  let spareTimer;
+  const winner = new Promise((resolve38) => {
+    let open3 = 0;
+    let done = false;
+    let sparesStarted = spares.length === 0;
+    const settle = (onion) => {
+      if (done) return;
+      done = true;
+      resolve38(onion);
+    };
+    const failed = () => {
+      open3 -= 1;
+      if (open3 > 0 || done) return;
+      if (!sparesStarted && !signal.aborted) return startSpares();
+      if (!controller.signal.aborted) onNone?.();
+      settle(onions[0]);
+    };
+    const start = (onion) => {
+      open3 += 1;
+      probe(onion).then(settle, failed);
+    };
+    startSpares = () => {
+      if (sparesStarted || done || signal.aborted) return;
+      sparesStarted = true;
+      clearTimeout(spareTimer);
+      onSpares?.();
+      for (const onion of spares) start(onion);
+    };
+    if (!sparesStarted) {
+      spareTimer = setTimeout(() => startSpares(), spareAfterMs);
+      spareTimer.unref?.();
+    }
+    for (const onion of onions) start(onion);
+  }).finally(() => {
+    clearTimeout(spareTimer);
+    controller.abort();
+  });
+  return { winner, abort: () => controller.abort(), startSpares: () => startSpares() };
 }
 function facilitatorOrigins(argv2) {
   const origins = /* @__PURE__ */ new Set();
@@ -42692,7 +42735,8 @@ async function routeFacilitatorsOverOnion(argv2, {
   fetchImpl = globalThis.fetch,
   err = (text3) => process.stderr.write(text3),
   raceTimeoutMs = RACE_TIMEOUT_MS,
-  routeWaitMs = ROUTE_WAIT_MS
+  routeWaitMs = ROUTE_WAIT_MS,
+  spareAfterMs = SPARE_AFTER_MS
 } = {}) {
   const routes = /* @__PURE__ */ new Map();
   const groups = /* @__PURE__ */ new Map();
@@ -42700,17 +42744,29 @@ async function routeFacilitatorsOverOnion(argv2, {
   for (const origin of named.length > 0 ? named : [DEFAULT_FACILITATOR_ORIGIN]) {
     const pinned = PINNED_FACILITATOR_ONIONS[origin];
     const onions = (pinned ?? [await publishedOnion(origin, fetchImpl)]).filter((onion) => onion && V3_ONION.test(onion));
+    const spares = pinned ? (PINNED_SPARE_ONIONS[origin] ?? []).filter((onion) => V3_ONION.test(onion)) : [];
     if (onions.length > 0) {
       const key = onions.join(" ");
       if (!groups.has(key)) {
-        groups.set(key, { onions, waitMs: routeWaitMs, onNone: () => err(`tor: no onion of ${origin} answered its start probe (${onions.length} tried); its requests go to its onions in turn and wait for them (Tor may still be building circuits)
-`) });
+        const spareHosts = spares.map((onion) => `${new URL(onion).host.slice(0, 8)}...`).join(", ");
+        const group = {
+          onions: [...onions, ...spares],
+          live: onions.length,
+          spares,
+          waitMs: routeWaitMs,
+          onSpares: () => err(`tor: no onion of ${origin} has answered yet; its ${spares.length} spare onions ${spareHosts} join (Tor may still be fetching the onion addresses)
+`),
+          onNone: () => err(`tor: no onion of ${origin} answered its start probe (${liveOnions(group).length} tried); its requests go to its onions in turn and wait for them (Tor may still be building circuits)
+`)
+        };
+        groups.set(key, group);
       }
       routes.set(origin, groups.get(key));
       routes.set(payHostOf(origin), groups.get(key));
       const hosts = onions.map((onion) => `${new URL(onion).host.slice(0, 8)}...`).join(", ");
       const source = pinned ? "pinned in this wallet" : `published by ${origin}`;
-      err(`tor: ${origin} is reached over its onion service ${hosts} (${onions.length > 1 ? `${source}; the first to answer serves this run` : source}), so no Tor exit and no front such as Cloudflare sees these requests
+      const spareNote = spares.length > 0 ? `; ${spares.length} spares join if none answers in ${Math.round(spareAfterMs / 1e3)} s` : "";
+      err(`tor: ${origin} is reached over its onion service ${hosts} (${onions.length > 1 ? `${source}; the first to answer serves this run` : source}${spareNote}), so no Tor exit and no front such as Cloudflare sees these requests
 `);
     } else {
       err(`tor: ${origin} publishes no onion service; its requests go through a Tor exit, which sees the host name (TLS hides the content)
@@ -42734,12 +42790,18 @@ async function routeFacilitatorsOverOnion(argv2, {
       aborts.push(warmOnions({ onions: group.onions, fetchImpl }));
       continue;
     }
-    const race = raceOnions(group.onions, {
+    const spares = group.spares ?? [];
+    const race = raceOnions(liveOnions(group), {
       fetchImpl,
       timeoutMs: raceTimeoutMs,
       ...group.path ? { path: group.path } : {},
-      ...group.onNone ? { onNone: group.onNone } : {}
+      ...group.onNone ? { onNone: group.onNone } : {},
+      ...spares.length > 0 ? { spares, spareAfterMs, onSpares: () => {
+        group.live = group.onions.length;
+        group.onSpares?.();
+      } } : {}
     });
+    group.startSpares = race.startSpares;
     group.pending = race.winner.then((onion) => {
       group.winner = onion;
       group.pending = void 0;
@@ -42760,7 +42822,11 @@ async function routeFacilitatorsOverOnion(argv2, {
     const group = url && routes.get(url.origin);
     if (!group) return original(input, init);
     const send3 = (onion) => {
-      if (onion === void 0) onion = group.onions[(group.sent = (group.sent ?? 0) + 1) % group.onions.length];
+      if (onion === void 0) {
+        group.startSpares?.();
+        const live = liveOnions(group);
+        onion = live[(group.sent = (group.sent ?? 0) + 1) % live.length];
+      }
       const target = `${onion}${url.pathname}${url.search}`;
       return original(input instanceof Request ? new Request(target, input) : target, onionInit(init));
     };
@@ -42782,7 +42848,7 @@ async function routeFacilitatorsOverOnion(argv2, {
     }
   };
 }
-var SITE_ONIONS, PINNED_FACILITATOR_ONIONS, HISTORY_ONIONS, PINNED_HISTORY_ONIONS, HISTORY_PROBE_PATH, FACILITATOR_FLAGS, V3_ONION, DISCOVERY_TIMEOUT_MS, WARM_TIMEOUT_MS, RACE_TIMEOUT_MS, ROUTE_WAIT_MS, routedGroups, routedOnions, routedOrigins, onionsOfOrigin, routesOverOnion, GLOBAL_DISPATCHER, onionDispatchers;
+var SITE_ONIONS, SITE_SPARE_ONIONS, PINNED_FACILITATOR_ONIONS, PINNED_SPARE_ONIONS, HISTORY_ONIONS, PINNED_HISTORY_ONIONS, HISTORY_PROBE_PATH, FACILITATOR_FLAGS, V3_ONION, DISCOVERY_TIMEOUT_MS, WARM_TIMEOUT_MS, RACE_TIMEOUT_MS, ROUTE_WAIT_MS, SPARE_AFTER_MS, routedGroups, liveOnions, routedOnions, routedOrigins, onionsOfOrigin, routesOverOnion, GLOBAL_DISPATCHER, onionDispatchers;
 var init_facilitatorOnion = __esm({
   "wallet/src/net/facilitatorOnion.mjs"() {
     "use strict";
@@ -42791,11 +42857,20 @@ var init_facilitatorOnion = __esm({
       "http://2kfhlfuyuwvhmibjrpxqsg4nrbcxasjgjq7kmnfzgfwzptkhhznz3dad.onion",
       "http://chhgw7nfggqhhjawz54bpsiihdow66s2yvkh6ccnugpcdmhhww6xkkqd.onion"
     ]);
+    SITE_SPARE_ONIONS = Object.freeze([
+      "http://ntr5qkdfgff4gspwderjnqtkzekyhb5a4j76ov4dqncxmcb53gdsmmid.onion",
+      "http://vofhhl336r4bnwn7hid2uvqaa72wx66xkdu2yt4n54xljsxwn2yds6qd.onion"
+    ]);
     PINNED_FACILITATOR_ONIONS = Object.freeze({
       "https://shinjukustaition.com": SITE_ONIONS,
       "https://www.shinjukustaition.com": SITE_ONIONS,
       "https://pay.shinjukustaition.com": SITE_ONIONS
     });
+    PINNED_SPARE_ONIONS = Object.freeze({
+      "https://shinjukustaition.com": SITE_SPARE_ONIONS,
+      "https://www.shinjukustaition.com": SITE_SPARE_ONIONS,
+      "https://pay.shinjukustaition.com": SITE_SPARE_ONIONS
+    });
     HISTORY_ONIONS = Object.freeze([
       "http://d6xg3phhurxhzqcsgh2mh52yf744labhrnd7mducwynlertfsjzyslqd.onion",
       "http://3yccoinnouxbjx3emvdxwhbu56cq4de7sfwgvcp4xb7hveccnpurcrid.onion",
@@ -42810,8 +42885,10 @@ var init_facilitatorOnion = __esm({
     WARM_TIMEOUT_MS = 3e4;
     RACE_TIMEOUT_MS = 9e4;
     ROUTE_WAIT_MS = 15e3;
+    SPARE_AFTER_MS = ROUTE_WAIT_MS;
     routedGroups = [];
-    routedOnions = () => [...new Set(routedGroups.flatMap((group) => group.winner ? [group.winner] : group.onions))];
+    liveOnions = (group) => group.onions.slice(0, group.live ?? group.onions.length);
+    routedOnions = () => [...new Set(routedGroups.flatMap((group) => group.winner ? [group.winner] : liveOnions(group)))];
     routedOrigins = /* @__PURE__ */ new Map();
     onionsOfOrigin = (origin) => routedOrigins.get(origin) ?? PINNED_FACILITATOR_ONIONS[origin] ?? [];
     routesOverOnion = (origin) => routedOrigins.has(origin);
@@ -47584,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";
@@ -47695,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
@@ -47712,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() {
@@ -47841,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;
         }
       }
@@ -54587,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 {
     }
@@ -55451,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";
@@ -55740,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 };
   }
 });
 
@@ -56660,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];
@@ -57630,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,
@@ -57656,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,
@@ -118627,8 +118809,12 @@ ${canonical5}`;
       const linkReads = readOpenLinkHeld(store);
       const finishing = finishSentDeposits(store);
       const finishDeadline = finishing.length ? balanceStartedAt + balanceRefreshWaitMs : void 0;
+      let finishedHere = [];
       if (finishing.length) {
-        const finished = Promise.all(finishing).then((outcomes) => outcomes.some((outcome2) => outcome2?.stage === "done" || outcome2?.stage === "partly_shielded") ? refreshShared().then(() => "done") : "passed").catch(() => "failed");
+        const finished = Promise.all(finishing).then((outcomes) => {
+          finishedHere = outcomes.filter((outcome2) => outcome2?.stage === "done" || outcome2?.stage === "partly_shielded");
+          return finishedHere.length ? refreshShared().then(() => "done") : "passed";
+        }).catch(() => "failed");
         const outcome = await Promise.race([
           finished,
           new Promise((resolve38) => {
@@ -118780,6 +118966,22 @@ ${canonical5}`;
       } catch {
         landingAtomic = 0n;
       }
+      if (landingAtomic === 0n && shieldedAtomic === null && !refresh.refreshError && finishedHere.length) {
+        for (const outcome of finishedHere) {
+          const id = outcome.record?.id;
+          const round = outcome.record?.round ?? 1;
+          let amount = payMeAmounts.get(`${id}:${round}`);
+          if (amount === void 0) {
+            try {
+              const deposit = store.readWal(`deposit-${outcome.record?.depositId ?? payMeRoundDepositId(id, round)}`);
+              if (/^[1-9][0-9]*$/.test(String(deposit?.amountAtomic ?? ""))) amount = BigInt(deposit.amountAtomic);
+            } catch {
+              amount = void 0;
+            }
+          }
+          if (typeof amount === "bigint" && amount > 0n) landingAtomic += amount;
+        }
+      }
       const landedNext = landingAtomic > 0n && !refresh.refreshError ? `${usdcText2(landingAtomic)} USDC you added landed on chain and is being counted (landingAtomic, not in balanceAtomic yet): call wallet_balance again in ${POLL_SECONDS3} s; that call waits up to ${waitSeconds} s for it. Tell the user it needs no step from them` : void 0;
       if (landedNext) next = landedNext;
       const stalled = [...resumeRefusals].map(([requestId, error2]) => `"${requestId}" (${error2})`);