shinjuku-shielded 0.3.44 → 0.3.45

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "99e5ce600a930373051d72e16b2fe75bec451cfbdd509439e58546d0e77058d2",
-  "bytes": 11247206,
-  "sourceCommit": "5a8c47eba8d07d89334e63f6467f17692e009d30",
+  "sha256": "54ae7e6525d0c2a5330f3243891a2cbc5d728a4bcea81a61ba3aaf065bed8b63",
+  "bytes": 11266570,
+  "sourceCommit": "f4f870fa4e4b3f57cc4dfdb472b75e5a3fef8db2",
   "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.44",
+  "version": "0.3.45",
   "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": "99e5ce60",
-  "shinjukuSha256": "99e5ce600a930373051d72e16b2fe75bec451cfbdd509439e58546d0e77058d2",
+  "shinjukuRelease": "54ae7e65",
+  "shinjukuSha256": "54ae7e6525d0c2a5330f3243891a2cbc5d728a4bcea81a61ba3aaf065bed8b63",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -50887,13 +50887,15 @@ function createHistoryCacheStore({
       }
       return { ...deserialize(JSON.parse(envelope.serialized)), savedAt: Number(envelope.savedAt) };
     },
-    async save(state) {
+    // `savedAt`: a rewrite that keeps the time of the refresh it holds (compact.mjs
+    // dropCachedFoldRoots), so the rewrite does not make old records count as fresh.
+    async save(state, { savedAt } = {}) {
       const serialized = JSON.stringify(serialize(state));
       const envelope = JSON.stringify({
         schema,
         tag: tag2(serialized),
         serialized,
-        savedAt: now()
+        savedAt: Number.isFinite(savedAt) ? savedAt : now()
       });
       await mkdir(dirname6(path), { recursive: true });
       const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
@@ -50977,7 +50979,11 @@ function createCompactHistoryCacheStore({ path, hmacKey, now }) {
           newestSignature: state.attestation.newestSignature,
           coverage: encodeTagged(state.attestation.coverage)
         }
-      } : {}
+      } : {},
+      // 2026-10-16: the append root after each served record (hex, count 1..n) and the empty
+      // tree's root, a fold hint for a new process (compact.mjs hintCompactFold). Optional: an
+      // older build reads the file and drops it; a file without it folds as before.
+      ...state.foldRoots ? { foldRoots: { zero: state.foldRoots.zero, roots: [...state.foldRoots.roots] } } : {}
     }),
     deserialize: (value) => {
       const init = value?.initialization;
@@ -50998,7 +51004,9 @@ function createCompactHistoryCacheStore({ path, hmacKey, now }) {
           accounts: Object.freeze([...init.accounts]),
           data: Buffer.from(init.data, "hex")
         }),
-        ...value.attestation === void 0 ? {} : { attestation: deserializeAttestation(value.attestation) }
+        ...value.attestation === void 0 ? {} : { attestation: deserializeAttestation(value.attestation) },
+        // A malformed hint is dropped, never the cache: the fold then runs from the empty tree.
+        ...value.foldRoots && typeof value.foldRoots.zero === "string" && Array.isArray(value.foldRoots.roots) && value.foldRoots.roots.length === value.served.records.length && value.foldRoots.roots.every((root) => typeof root === "string") ? { foldRoots: { zero: value.foldRoots.zero, roots: [...value.foldRoots.roots] } } : {}
       };
     }
   });
@@ -52625,6 +52633,16 @@ function vaultAuthorityAddress3(program, pool2) {
 function depositAuthorityAddress3(program, pool2, outHex) {
   return memo(`da|${b58(program)}|${b58(pool2)}|${outHex}`, () => depositAuthorityAddress2(program, pool2, outHex));
 }
+function keepPoolState(report, snapshot) {
+  const entry = SNAPSHOT_POOL_STATES.get(snapshot);
+  if (entry !== void 0 && entry.programId === report.programId && entry.pool === report.pool) REPORT_POOL_STATES.set(report, entry);
+}
+function finalizedPoolStateOf(report, { programId, pool: pool2 }) {
+  if (!report || !AUTHENTICATED_HISTORY_REPORTS.has(report)) return void 0;
+  const entry = REPORT_POOL_STATES.get(report);
+  if (entry === void 0 || entry.programId !== String(programId) || entry.pool !== String(pool2)) return void 0;
+  return entry.state;
+}
 function p03SettlementConsumesBuffer(tag2) {
   return P03_SETTLEMENT_TAGS.includes(tag2) && !P03_INLINE_SETTLEMENT_TAGS.includes(tag2);
 }
@@ -52790,6 +52808,7 @@ function buildFinalizedP03HistoryReport({
   });
   AUTHENTICATED_HISTORY_REPORTS.add(report);
   if (attestation) HISTORY_ATTESTATIONS.set(report, attestation);
+  keepPoolState(report, poolSnapshot);
   return report;
 }
 function assertAuthenticatedFinalizedP03History(report) {
@@ -52873,12 +52892,13 @@ async function refreshFinalizedP03HistorySnapshot({
   });
   AUTHENTICATED_HISTORY_REPORTS.add(refreshed);
   if (refreshedCoverage.attestation) HISTORY_ATTESTATIONS.set(refreshed, refreshedCoverage.attestation);
+  keepPoolState(refreshed, snapshot);
   return refreshed;
 }
 async function readFinalizedPool(connection, program, pool2) {
   if (typeof connection.getMultipleAccountsInfoAndContext !== "function") {
     const response = await retryTransientRpc(() => connection.getAccountInfoAndContext(pool2, "finalized"));
-    const only = parseFinalizedPool(response, program);
+    const only = parseFinalizedPool(response, program, pool2);
     if (only.replayStore === REPLAY_STORE_INDEXED) throw new Error("p03_history_e1_tree_read_unavailable");
     return only;
   }
@@ -52888,10 +52908,10 @@ async function readFinalizedPool(connection, program, pool2) {
     { commitment: "finalized" }
   ));
   if (!Array.isArray(both?.value) || both.value.length !== 2) throw new Error("p03_history_e1_tree_read_invalid");
-  const snapshot = parseFinalizedPool({ context: both.context, value: both.value[0] }, program);
+  const snapshot = parseFinalizedPool({ context: both.context, value: both.value[0] }, program, pool2);
   if (snapshot.replayStore !== REPLAY_STORE_INDEXED) return snapshot;
   const treeAccount = both.value[1];
-  return Object.freeze({
+  return withPoolStateOf(snapshot, Object.freeze({
     ...snapshot,
     e1TreeAccount: Object.freeze({
       slot: snapshot.slot,
@@ -52899,7 +52919,12 @@ async function readFinalizedPool(connection, program, pool2) {
       ownerProgramId: treeAccount ? canonicalKey(treeAccount.owner, "e1_tree_owner").toBase58() : null,
       data: treeAccount ? Buffer.from(treeAccount.data) : null
     })
-  });
+  }));
+}
+function withPoolStateOf(snapshot, wrapped) {
+  const entry = SNAPSHOT_POOL_STATES.get(snapshot);
+  if (entry !== void 0) SNAPSHOT_POOL_STATES.set(wrapped, entry);
+  return wrapped;
 }
 async function readFinalizedPoolForRefresh(connection, program, pool2) {
   if (typeof connection.getMultipleAccountsInfoAndContext !== "function") return readFinalizedPool(connection, program, pool2);
@@ -52910,24 +52935,25 @@ async function readFinalizedPoolForRefresh(connection, program, pool2) {
   ));
   if (!Array.isArray(both?.value) || both.value.length !== 2) throw new Error("p03_history_e1_tree_read_invalid");
   if (both.value[0]?.data && Buffer.from(both.value[0].data).length >= REFRESH_READ_BYTES) return readFinalizedPool(connection, program, pool2);
-  const snapshot = parseFinalizedPool({ context: both.context, value: both.value[0] }, program);
+  const snapshot = parseFinalizedPool({ context: both.context, value: both.value[0] }, program, pool2);
   if (snapshot.replayStore !== REPLAY_STORE_INDEXED) return snapshot;
   const treeAccount = both.value[1];
-  return Object.freeze({
+  return withPoolStateOf(snapshot, Object.freeze({
     ...snapshot,
     e1TreeHeader: Object.freeze({
       address: tree.toBase58(),
       ownerProgramId: treeAccount ? canonicalKey(treeAccount.owner, "e1_tree_owner").toBase58() : null,
       data: treeAccount ? Buffer.from(treeAccount.data) : null
     })
-  });
+  }));
 }
-function parseFinalizedPool(response, program) {
+function parseFinalizedPool(response, program, pool2) {
   const value = response?.value;
   const slot3 = response?.context?.slot;
   safeSlot(slot3, "snapshot_slot");
   if (!value) throw new Error("p03_history_pool_missing");
-  if (canonicalKey(value.owner, "pool_owner").toBase58() !== b58(program)) {
+  const owner = canonicalKey(value.owner, "pool_owner");
+  if (owner.toBase58() !== b58(program)) {
     throw new Error("p03_history_pool_owner_mismatch");
   }
   const data = Buffer.from(value.data);
@@ -52946,7 +52972,7 @@ function parseFinalizedPool(response, program) {
   field(data.subarray(48, 80), "snapshot_current_root");
   field(data.subarray(96, 128), "snapshot_anchor_0_root");
   field(data.subarray(144, 176), "snapshot_anchor_1_root");
-  return Object.freeze({
+  const snapshot = Object.freeze({
     ...state,
     anchorMode: data[11],
     decimals: data[10],
@@ -52954,6 +52980,14 @@ function parseFinalizedPool(response, program) {
     accountData: data,
     slot: slot3
   });
+  if (pool2 instanceof import_web396.PublicKey) {
+    SNAPSHOT_POOL_STATES.set(snapshot, Object.freeze({
+      programId: b58(program),
+      pool: pool2.toBase58(),
+      state: Object.freeze({ ...state, owner })
+    }));
+  }
+  return snapshot;
 }
 function freezeFinalizedAnchors(snapshot) {
   const candidates = snapshot.anchors.map((anchor, ringSlot) => ({
@@ -54452,7 +54486,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, 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, 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;
+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, 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;
 var init_walk = __esm({
   "wallet/src/history/walk.mjs"() {
     "use strict";
@@ -54517,6 +54551,8 @@ var init_walk = __esm({
     ASSUMED_ORIGINAL_EXECUTABLE = p03ReviewedExecutable(P03_COMPATIBLE_CODE.previous);
     AUTHENTICATED_HISTORY_REPORTS = /* @__PURE__ */ new WeakSet();
     HISTORY_ATTESTATIONS = /* @__PURE__ */ new WeakMap();
+    SNAPSHOT_POOL_STATES = /* @__PURE__ */ new WeakMap();
+    REPORT_POOL_STATES = /* @__PURE__ */ new WeakMap();
     hasExecutableEvidence = (coverage) => Array.isArray(coverage?.executables) && coverage.executables.length > 0;
     P03_FINALIZED_HISTORY_SOURCE_MODEL = "carbon/shielded-x402-wallet/p03-finalized-history/v1";
     P03_PROGRAMDATA_COVERAGE_SOURCE_MODEL = "carbon/shielded-x402-wallet/p03-programdata-finalized-history/v1";
@@ -54730,6 +54766,7 @@ function buildFinalizedP03RecoveryPath({
   circuitSource,
   anchor
 }) {
+  noteHistoryActivity();
   const authenticated = assertAuthenticatedFinalizedP03History(history);
   const coverage = validateDeploymentCoverage(authenticated);
   validatePinnedCircuitSource(circuitSource);
@@ -54800,6 +54837,7 @@ function buildFinalizedP03RecoveryPath({
   });
 }
 function buildFinalizedP03Frontier({ history, circuitSource }) {
+  noteHistoryActivity();
   const authenticated = assertAuthenticatedFinalizedP03History(history);
   validateDeploymentCoverage(authenticated);
   validatePinnedCircuitSource(circuitSource);
@@ -54836,6 +54874,26 @@ function validateDeploymentCoverage(history) {
   }
   return coverage;
 }
+function noteHistoryActivity(delta = 0) {
+  historyBusy = Math.max(0, historyBusy + delta);
+  historyActiveAt = performance.now();
+}
+function historyQuietFor(ms) {
+  return historyBusy === 0 && performance.now() - historyActiveAt >= ms;
+}
+function noteCachedFoldRoots(pool2, roots, onDrop) {
+  const entry = CACHED_FOLD_ROOTS.get(pool2);
+  CACHED_FOLD_ROOTS.set(pool2, { roots: new Map([...entry?.roots ?? [], ...roots]), onDrop });
+}
+function forgetCachedFoldRoots(pool2, roots) {
+  const entry = CACHED_FOLD_ROOTS.get(pool2);
+  if (entry === void 0) return;
+  for (const [count2, root] of roots) if (entry.roots.get(count2) === root) entry.roots.delete(count2);
+  if (entry.roots.size === 0) CACHED_FOLD_ROOTS.delete(pool2);
+}
+function dropRecoveryFold() {
+  lastFold = void 0;
+}
 function rebuildOrderedPrefixes(history) {
   const cached = REBUILT_BY_REPORT.get(history);
   if (cached !== void 0) return cached;
@@ -54845,7 +54903,15 @@ function rebuildOrderedPrefixes(history) {
   REBUILT_BY_REPORT.set(history, next.value);
   return next.value;
 }
-async function prepareFinalizedP03RecoveryFold(history, { sliceMs = 20 } = {}) {
+async function prepareFinalizedP03RecoveryFold(history, options) {
+  noteHistoryActivity(1);
+  try {
+    return await prepareFinalizedP03RecoveryFoldNow(history, options);
+  } finally {
+    noteHistoryActivity(-1);
+  }
+}
+async function prepareFinalizedP03RecoveryFoldNow(history, { sliceMs = 20 } = {}) {
   const authenticated = assertAuthenticatedFinalizedP03History(history);
   if (REBUILT_BY_REPORT.has(authenticated)) return;
   const running = FOLDS_IN_FLIGHT.get(authenticated);
@@ -54899,6 +54965,8 @@ function* rebuildOrderedPrefixSteps(history) {
   let nodes = resumed > 0 ? prior.nodes : zeroRoots2.slice(0, OUTER_DEPTH);
   let root = resumed > 0 ? prior.roots[resumed] : zeroRoots2[OUTER_DEPTH];
   const roots = resumed > 0 ? prior.roots.slice(0, resumed + 1) : [root];
+  const cached = CACHED_FOLD_ROOTS.get(history.pool);
+  let cachedDropped = false;
   for (let ordinal = 0; ordinal < contexts.length; ordinal += 1) {
     const context = contexts[ordinal];
     const expectedIndex = BigInt(ordinal) * SUBTREE_LEAVES2;
@@ -54922,7 +54990,19 @@ function* rebuildOrderedPrefixSteps(history) {
     for (let level = 0; level < OUTER_DEPTH; level += 1) {
       if ((nextCount >> BigInt(level) & 1n) === 0n) nextNodes[level] = zeroRoots2[level];
     }
-    if (node3 !== context.appendRoot) throw new Error("p03_recovery_append_root_mismatch");
+    if (node3 !== context.appendRoot) {
+      if (cached === void 0 || ordinal + 1 >= contexts.length || cached.roots.get(ordinal + 1) !== context.appendRoot) {
+        throw new Error("p03_recovery_append_root_mismatch");
+      }
+      if (!cachedDropped) {
+        cachedDropped = true;
+        markPhase("compact-roots-dropped");
+        try {
+          cached.onDrop();
+        } catch {
+        }
+      }
+    }
     nodes = nextNodes;
     root = node3;
     roots.push(root);
@@ -54950,6 +55030,36 @@ function* rebuildOrderedPrefixSteps(history) {
     nodes: frozenNodes
   });
 }
+function seedFinalizedP03RecoveryFold({ leaves, roots, frontier } = {}) {
+  try {
+    const zeroRoots2 = zeroUpperRoots();
+    const count2 = Array.isArray(leaves) ? leaves.length : 0;
+    if (count2 === 0 || !Array.isArray(roots) || roots.length !== count2 + 1 || !Array.isArray(frontier) || frontier.length !== OUTER_DEPTH || roots[0] !== zeroRoots2[OUTER_DEPTH]) return false;
+    const isField = (value) => typeof value === "bigint" && value >= 0n && value < FIELD_MODULUS4;
+    if (!leaves.every(isField) || !roots.every(isField) || !frontier.every(isField)) return false;
+    let node3 = zeroRoots2[0];
+    let position3 = BigInt(count2);
+    for (let level = 0; level < OUTER_DEPTH; level += 1) {
+      const filled = frontier[level];
+      if ((position3 & 1n) === 0n) {
+        if (filled !== zeroRoots2[level]) return false;
+        node3 = hash3(node3, zeroRoots2[level]);
+      } else {
+        node3 = hash3(filled, node3);
+      }
+      position3 >>= 1n;
+    }
+    if (node3 !== roots[count2]) return false;
+    lastFold = Object.freeze({
+      leaves: Object.freeze([...leaves]),
+      roots: Object.freeze([...roots]),
+      nodes: Object.freeze([...frontier])
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function zeroUpperRoots() {
   ZERO_UPPER_ROOTS ??= Object.freeze(computeZeroUpperRoots());
   return ZERO_UPPER_ROOTS;
@@ -55070,7 +55180,7 @@ function canonicalField(value, label) {
   }
   return value;
 }
-var FIELD_MODULUS4, SUBTREE_LEAVES2, LOCAL_DEPTH, OUTER_DEPTH, TREE_DEPTH, P03_RECOVERY_PATH_SOURCE_MODEL, P03_PINNED_POSEIDON_PARAMETERS_SHA256, P03_PINNED_ZERO_LEAF, hashCalls, hash3, REBUILT_BY_REPORT, lastFold, FOLDS_IN_FLIGHT, foldInFlight, ZERO_UPPER_ROOTS, LOCAL_ZERO_ROOTS, lastOuter;
+var FIELD_MODULUS4, SUBTREE_LEAVES2, LOCAL_DEPTH, OUTER_DEPTH, TREE_DEPTH, P03_RECOVERY_PATH_SOURCE_MODEL, P03_PINNED_POSEIDON_PARAMETERS_SHA256, P03_PINNED_ZERO_LEAF, hashCalls, hash3, REBUILT_BY_REPORT, lastFold, historyBusy, historyActiveAt, CACHED_FOLD_ROOTS, FOLDS_IN_FLIGHT, foldInFlight, ZERO_UPPER_ROOTS, LOCAL_ZERO_ROOTS, lastOuter;
 var init_recoveryPath = __esm({
   "wallet/src/recovery/recoveryPath.mjs"() {
     "use strict";
@@ -55096,6 +55206,9 @@ var init_recoveryPath = __esm({
       ], 3);
     };
     REBUILT_BY_REPORT = /* @__PURE__ */ new WeakMap();
+    historyBusy = 0;
+    historyActiveAt = -Infinity;
+    CACHED_FOLD_ROOTS = /* @__PURE__ */ new Map();
     FOLDS_IN_FLIGHT = /* @__PURE__ */ new WeakMap();
   }
 });
@@ -55126,47 +55239,147 @@ function zeroRoots() {
   zeroRootsMemo = Object.freeze(roots);
   return zeroRootsMemo;
 }
-function foldCompactLeaves(leaves, counts) {
+function foldCompactLeaves(leaves, counts, frontier) {
   const zero = zeroRoots();
   const filled = new Array(OUTER_DEPTH2);
   const roots = /* @__PURE__ */ new Map();
-  const rootAt = (count2) => {
-    let node3 = zero[0];
-    for (let level = 0; level < OUTER_DEPTH2; level += 1) {
-      node3 = bitAt(count2, level) === 1 ? hash4(filled[level], node3) : hash4(node3, zero[level]);
-    }
-    return node3;
-  };
   if (counts.has(0)) roots.set(0, zero[OUTER_DEPTH2]);
   leaves.forEach((leaf, position3) => {
-    let node3 = leaf;
-    let level = 0;
-    while (bitAt(position3, level) === 1) {
-      node3 = hash4(filled[level], node3);
-      level += 1;
-    }
-    filled[level] = node3;
-    if (counts.has(position3 + 1)) roots.set(position3 + 1, rootAt(position3 + 1));
+    appendCompactLeaf(filled, leaf, position3);
+    if (counts.has(position3 + 1)) roots.set(position3 + 1, compactRootAt(filled, position3 + 1));
   });
+  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;
 }
-function foldCompactLeavesReusing(pool2, leaves, counts) {
+function appendCompactLeaf(filled, leaf, position3) {
+  let node3 = leaf;
+  let level = 0;
+  while (bitAt(position3, level) === 1) {
+    node3 = hash4(filled[level], node3);
+    level += 1;
+  }
+  filled[level] = node3;
+}
+function compactRootAt(filled, count2) {
+  const zero = zeroRoots();
+  let node3 = zero[0];
+  for (let level = 0; level < OUTER_DEPTH2; level += 1) {
+    node3 = bitAt(count2, level) === 1 ? hash4(filled[level], node3) : hash4(node3, zero[level]);
+  }
+  return node3;
+}
+function foldCompactLeavesReusing(pool2, leaves, counts, { frontier, fresh = /* @__PURE__ */ new Set(), stats } = {}) {
   const prior = lastFolds.get(pool2);
   let common = 0;
   if (prior !== void 0) {
     const most = Math.min(prior.leaves.length, leaves.length);
     while (common < most && prior.leaves[common] === leaves[common]) common += 1;
   }
-  const known = (at) => prior !== void 0 && at <= common && prior.roots.has(at);
-  const roots = foldCompactLeaves(leaves, new Set([...counts].filter((at) => !known(at))));
-  for (const at of counts) if (known(at)) roots.set(at, prior.roots.get(at));
+  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);
+  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;
+    return foldCompactLeavesReusing(pool2, leaves, counts, { frontier, fresh, stats });
+  }
+  let reused = 0;
+  const cachedRoots = /* @__PURE__ */ new Map();
+  for (const at of counts) {
+    if (known(at)) {
+      roots.set(at, prior.roots.get(at));
+      reused += 1;
+      if (prior.tainted?.has(at)) cachedRoots.set(at, prior.roots.get(at));
+    }
+  }
+  if (stats) Object.assign(stats, { reused, cachedRoots });
   const kept = new Map(roots);
+  const tainted = new Set(cachedRoots.keys());
   if (prior !== void 0) {
-    for (const [at, root] of prior.roots) if (at <= common && !kept.has(at)) kept.set(at, root);
+    for (const [at, root] of prior.roots) {
+      if (at > common || kept.has(at)) continue;
+      kept.set(at, root);
+      if (prior.tainted?.has(at)) tainted.add(at);
+    }
   }
-  lastFolds.set(pool2, { leaves: leaves.slice(), roots: kept });
+  lastFolds.set(pool2, { leaves: leaves.slice(), roots: kept, ...tainted.size > 0 ? { tainted } : {} });
   return roots;
 }
+function hintCompactFold(pool2, hint) {
+  if (lastFolds.has(pool2) || droppedPools.has(pool2) || !hint || !Array.isArray(hint.records) || !hint.foldRoots) return false;
+  const { records, foldRoots } = hint;
+  if (!Array.isArray(foldRoots.roots) || foldRoots.roots.length === 0 || foldRoots.roots.length !== records.length || foldRoots.zero !== hex64(zeroRoots()[OUTER_DEPTH2])) return false;
+  const field4 = (value) => {
+    if (typeof value !== "string" || !HEX64.test(value)) return void 0;
+    const parsed = BigInt(`0x${value}`);
+    return parsed < FIELD_MODULUS5 ? parsed : void 0;
+  };
+  const leaves = [];
+  const roots = /* @__PURE__ */ new Map();
+  for (let at = 0; at < records.length; at += 1) {
+    const leaf = field4(records[at]?.outCommitment);
+    const root = field4(foldRoots.roots[at]);
+    if (leaf === void 0 || root === void 0) return false;
+    leaves.push(leaf);
+    roots.set(at + 1, root);
+  }
+  lastFolds.set(pool2, { leaves, roots, tainted: new Set(roots.keys()) });
+  return true;
+}
+function dropCachedFoldRoots(pool2, cache) {
+  if (droppedPools.has(pool2)) return;
+  droppedPools.add(pool2);
+  lastFolds.delete(pool2);
+  dropRecoveryFold();
+  if (cache === void 0) return;
+  (async () => {
+    const current = await cache.load();
+    if (!current || current.pool !== pool2 || current.foldRoots === void 0) return;
+    const { foldRoots: _dropped, savedAt, ...rest } = current;
+    await cache.save(rest, { savedAt });
+  })().catch(() => {
+  });
+}
+function startCachedRootsVerify({ pool: pool2, leaves, cachedRoots, cache }) {
+  if (verifying.has(pool2) || cachedRoots.size === 0) return;
+  verifying.add(pool2);
+  verifyCachedRoots({ pool: pool2, leaves, cachedRoots, cache }).catch(() => {
+  }).finally(() => verifying.delete(pool2));
+}
+async function verifyCachedRoots({ pool: pool2, leaves, cachedRoots, cache }) {
+  const last = Math.max(...cachedRoots.keys());
+  if (last > leaves.length) return;
+  let sliceStart = 0;
+  const quiet = async () => {
+    while (!historyQuietFor(verifyQuietMs)) await unrefTurn(VERIFY_POLL_MS);
+    sliceStart = performance.now();
+  };
+  await quiet();
+  const filled = new Array(OUTER_DEPTH2);
+  for (let position3 = 0; position3 < last; position3 += 1) {
+    appendCompactLeaf(filled, leaves[position3], position3);
+    const expected = cachedRoots.get(position3 + 1);
+    if (expected !== void 0 && compactRootAt(filled, position3 + 1) !== expected) {
+      markPhase("compact-roots-dropped");
+      dropCachedFoldRoots(pool2, cache);
+      return;
+    }
+    if (performance.now() - sliceStart >= VERIFY_SLICE_MS) {
+      await unrefImmediate();
+      await quiet();
+    }
+  }
+  const entry = lastFolds.get(pool2);
+  if (entry?.tainted) {
+    for (const [at, root] of cachedRoots) if (entry.roots.get(at) === root) entry.tainted.delete(at);
+    if (entry.tainted.size === 0) delete entry.tainted;
+  }
+  forgetCachedFoldRoots(pool2, cachedRoots);
+  markPhase("compact-roots-verified");
+}
 function fieldOf(hex4) {
   if (typeof hex4 !== "string" || !HEX64.test(hex4)) throw refuse3("p03_compact_history_record_invalid");
   const value = BigInt(`0x${hex4}`);
@@ -55630,7 +55843,15 @@ async function ownInitialization(own, served, { program, poolKey, snapshot, know
   }
   return instruction;
 }
-async function readCompactP03History({
+async function readCompactP03History(options) {
+  noteHistoryActivity(1);
+  try {
+    return await readCompactP03HistoryNow(options);
+  } finally {
+    noteHistoryActivity(-1);
+  }
+}
+async function readCompactP03HistoryNow({
   history,
   own,
   programId,
@@ -55655,6 +55876,9 @@ async function readCompactP03History({
   // compactP03HistoryReport: run beside the spot checks once the initialization is verified
   // ({ snapshot, initialization, contexts }); its result comes back as `alongside`.
   alongside,
+  // 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,
   // 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
@@ -55751,7 +55975,21 @@ async function readCompactP03History({
   for (const anchor of anchors) counts.add(Number(anchor.index / SUBTREE_LEAVES3));
   if (appendRoots) for (let at = 1; at <= count2; at += 1) counts.add(at);
   for (const at of counts) if (at > count2) throw refuse3("p03_compact_history_snapshot_invalid");
-  roots = foldCompactLeavesReusing(poolString, contexts.map((context) => context.outCommitment), counts);
+  const frontier = appendRoots ? [] : void 0;
+  const hinted = hintCompactFold(poolString, foldHint);
+  const leaves = contexts.map((context) => context.outCommitment);
+  const fresh = /* @__PURE__ */ new Set([count2, ...picks.map((ordinal) => ordinal + 1)]);
+  if (hinted && count2 > 0) for (let sample = 0; sample < 4; sample += 1) fresh.add(1 + randomInt2(count2));
+  const 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)) {
+    lastFolds.delete(poolString);
+    stats.refolded = true;
+    roots = foldCompactLeavesReusing(poolString, leaves, counts, { frontier, fresh });
+  }
+  const cachedRoots = stats.refolded ? /* @__PURE__ */ new Map() : stats.cachedRoots ?? /* @__PURE__ */ new Map();
+  if (stats.refolded) markPhase("compact-roots-refold");
+  else if (cachedRoots.size > 0) markPhase("compact-roots-cached");
   if (roots.get(count2) !== snapshot.currentRoot) throw refuse3("p03_compact_history_root_mismatch");
   for (const anchor of anchors) {
     if (roots.get(Number(anchor.index / SUBTREE_LEAVES3)) !== anchor.root) throw refuse3("p03_compact_history_root_mismatch");
@@ -55779,6 +56017,11 @@ async function readCompactP03History({
       replayStore: snapshot.replayStore
     }),
     contexts: Object.freeze(finished),
+    // With appendRoots: the fold's frontier after every context (foldCompactLeaves). Bound to
+    // currentRoot only by the recovery fold's seed check (seedFinalizedP03RecoveryFold).
+    outerFrontier: frontier === void 0 ? void 0 : Object.freeze(frontier),
+    // Append roots taken from the compact cache and not hashed in this process (count -> root).
+    cachedRoots,
     // Tag 31 imports up to the snapshot, in chain order (validateImport shape).
     imports: Object.freeze(imports),
     spentReplayValues: Object.freeze([...new Set(finished.flatMap((context) => context.replayValues.map(String)))].sort()),
@@ -55889,7 +56132,8 @@ async function compactP03HistoryReport({
     ...knownSnapshot !== void 0 ? { knownSnapshot } : {},
     ...onList !== void 0 ? { onList } : {},
     ...warm ? { served: cached.served } : {},
-    ...cached ? { initialization: cached.initialization } : {}
+    ...cached ? { initialization: cached.initialization } : {},
+    ...cached?.foldRoots ? { foldHint: { records: cached.served.records, foldRoots: cached.foldRoots } } : {}
   });
   const initialization = compact.verifiedInitialization;
   if (initialization === void 0) throw refuse3("p03_compact_history_pool_empty");
@@ -55932,6 +56176,21 @@ async function compactP03HistoryReport({
     // link or the predecessors finds none and refuses (recover.mjs) or walks in full.
     ...compact.imports.length > 0 ? { succession: Object.freeze({ imports: compactSuccessionImports(compact.imports) }) } : {}
   });
+  if (compact.outerFrontier !== void 0 && seedFinalizedP03RecoveryFold({
+    leaves: report.contexts.map((context) => context.outCommitment),
+    roots: [zeroRoots()[OUTER_DEPTH2], ...report.contexts.map((context) => context.appendRoot)],
+    frontier: compact.outerFrontier
+  })) markPhase("fold-seeded-compact");
+  if (compact.cachedRoots.size > 0) {
+    const poolString = poolKey.toBase58();
+    noteCachedFoldRoots(report.pool, compact.cachedRoots, () => dropCachedFoldRoots(poolString, cache));
+    startCachedRootsVerify({
+      pool: poolString,
+      leaves: report.contexts.map((context) => context.outCommitment),
+      cachedRoots: compact.cachedRoots,
+      cache
+    });
+  }
   if (cache) {
     try {
       await cache.save({
@@ -55945,7 +56204,12 @@ async function compactP03HistoryReport({
         },
         served: compact.served,
         initialization,
-        attestation: attested.attestation
+        attestation: attested.attestation,
+        // The append root after each served record, a hint for a new process's fold (hintCompactFold).
+        ...compact.outerFrontier !== void 0 && !droppedPools.has(poolKey.toBase58()) ? { foldRoots: {
+          zero: hex64(zeroRoots()[OUTER_DEPTH2]),
+          roots: report.contexts.map((context) => hex64(context.appendRoot))
+        } } : {}
       });
     } catch {
     }
@@ -55965,7 +56229,7 @@ async function tryCompactP03HistoryReport(options) {
     return { ok: false, reason: refusalReason(error), ...typeof error?.detail === "string" ? { detail: error.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, isSignature, isIndex, IMPORT_KEYS, IMPORT_MAX_VALUES, LIST_ATTEMPTS, OWN_READ_TIMEOUT_MS, BOUNDED_OWN_METHODS;
+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, unrefImmediate, isSignature, isIndex, IMPORT_KEYS, IMPORT_MAX_VALUES, LIST_ATTEMPTS, OWN_READ_TIMEOUT_MS, BOUNDED_OWN_METHODS;
 var init_compact = __esm({
   "wallet/src/history/compact.mjs"() {
     "use strict";
@@ -56077,6 +56341,20 @@ var init_compact = __esm({
     hash4 = (left, right) => poseidon2([left, right], 3);
     bitAt = (value, level) => Math.floor(value / 2 ** level) % 2;
     lastFolds = /* @__PURE__ */ new Map();
+    hex64 = (value) => value.toString(16).padStart(64, "0");
+    droppedPools = /* @__PURE__ */ new Set();
+    verifyQuietMs = 3e4;
+    VERIFY_SLICE_MS = 20;
+    VERIFY_POLL_MS = 250;
+    verifying = /* @__PURE__ */ new Set();
+    unrefTurn = (ms) => new Promise((resolve38) => {
+      const timer = setTimeout(resolve38, ms);
+      timer.unref?.();
+    });
+    unrefImmediate = () => new Promise((resolve38) => {
+      const turn = setImmediate(resolve38);
+      turn.unref?.();
+    });
     isSignature = (value) => typeof value === "string" && value.length >= 64 && value.length <= 88 && BASE58.test(value);
     isIndex = (value) => Number.isSafeInteger(value) && value >= 0;
     IMPORT_KEYS = ["afterOrdinal", "instructionIndex", "record", "signature", "slot", "transactionIndex", "values"];
@@ -56667,6 +56945,7 @@ async function loadWalletP03History(args) {
         const report2 = await prewarm.promise;
         PREWARMED_REPORTS.add(report2);
         markPhase("walk-prewarmed");
+        if (runKey !== void 0) recentLoads.set(runKey, { startedAt: prewarm.startedAt, report: report2 });
         return report2;
       } catch {
       }
@@ -72585,9 +72864,35 @@ async function readFinalizedClock(connection) {
   const data = info?.data;
   if (!data || data.length < 40) return void 0;
   const timestamp = Buffer.from(data).readBigInt64LE(32);
-  return timestamp >= 0n && timestamp <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(timestamp) : void 0;
+  if (timestamp < 0n || timestamp > BigInt(Number.MAX_SAFE_INTEGER)) return void 0;
+  if (typeof connection === "object" && connection !== null) {
+    lastClockAnswers.set(connection, { time: Number(timestamp), arrivedAt: performance.now() });
+  }
+  return Number(timestamp);
 }
-function startFinalizedChainTime(connection) {
+function startFinalizedChainTime(connection, { reuseRecent = false } = {}) {
+  const recentClock = () => {
+    const last = typeof connection === "object" && connection !== null ? lastClockAnswers.get(connection) : void 0;
+    const age = last === void 0 ? Infinity : performance.now() - last.arrivedAt;
+    return age <= PROOF_CHAIN_TIME_REUSE_MS ? { time: last.time, age } : void 0;
+  };
+  const recent = reuseRecent ? recentClock() : void 0;
+  if (recent !== void 0) {
+    let fallback;
+    const timer = setTimeout(() => {
+      fallback = startFinalizedChainTime(connection);
+    }, PROOF_CHAIN_TIME_REUSE_MS - recent.age);
+    timer.unref?.();
+    return async () => {
+      clearTimeout(timer);
+      const now = recentClock();
+      if (now !== void 0) {
+        markPhase("chain-time-reused");
+        return now.time + Math.floor(now.age / 1e3);
+      }
+      return (fallback ?? startFinalizedChainTime(connection))();
+    };
+  }
   const startedAt = performance.now();
   let arrivedAt;
   const early = readFinalizedClock(connection).then((time) => {
@@ -72605,16 +72910,32 @@ function startFinalizedChainTime(connection) {
     return time + Math.floor(age / 1e3);
   };
 }
+function walkPoolState(history, programId, pool2) {
+  let state;
+  try {
+    state = finalizedPoolStateOf(history, { programId: new import_web3106.PublicKey(programId).toBase58(), pool: new import_web3106.PublicKey(pool2).toBase58() });
+  } catch {
+    return void 0;
+  }
+  if (state !== void 0) markPhase("recover-pool-from-walk");
+  return state;
+}
 async function everyAccountHeld({ store, connection, programId, serviceUrl: serviceUrl2, reservedReplayValues, amountAtomic, deps = {} }) {
   if (typeof deps.walkHistory !== "function") fail15("walk_history_required");
   const viewing = deriveWalletViewingAuthority2({ seedBytes: seedBytes5(store.state), generator: pinnedGenerator4() });
   const history = assertAuthenticatedFinalizedP03History(await withRecentWalletHistory(() => deps.walkHistory()));
+  const poolState2 = walkPoolState(history, programId, store.state.pool);
   const recovery = await (deps.recover ?? runRecover)({
     store,
     connection,
     programId: new import_web3106.PublicKey(programId),
     serviceUrl: serviceUrl2,
-    deps: { fetchImpl: deps.fetchImpl, finalizedHistory: history, transitionContextFor: history.transitionContextFor }
+    deps: {
+      fetchImpl: deps.fetchImpl,
+      finalizedHistory: history,
+      transitionContextFor: history.transitionContextFor,
+      ...poolState2 !== void 0 ? { poolState: poolState2 } : {}
+    }
   });
   const poolDomain = history.contexts[0]?.poolDomain;
   const held = (entry) => {
@@ -72661,10 +72982,7 @@ async function prepareRecoveredPayment({
   const chainProgramId = new import_web3106.PublicKey(programId);
   const generator2 = pinnedGenerator4();
   const viewing = deriveWalletViewingAuthority2({ seedBytes: seedBytes5(state), generator: generator2 });
-  const chainTime2 = deps.chainTime === void 0 ? startFinalizedChainTime(connection) : void 0;
-  const poolState2 = deps.recover === void 0 ? readPoolState2(connection, pool2) : void 0;
-  poolState2?.catch(() => {
-  });
+  const chainTime2 = deps.chainTime === void 0 ? startFinalizedChainTime(connection, { reuseRecent: true }) : void 0;
   if (deps.provePayment === void 0 && proofTools !== void 0) {
     (deps.prewarmProof ?? ((tools) => setImmediate(() => {
       prewarmP03PaymentProofTools(tools).catch(() => {
@@ -72732,6 +73050,7 @@ async function prepareRecoveredPayment({
   if (deps.quoteMarginSeconds !== void 0 && BigInt(witnessQuote.validBefore) - BigInt(timestamp) < BigInt(deps.quoteMarginSeconds)) {
     fail15("quote_life_short_requote");
   }
+  const poolState2 = walkPoolState(history, chainProgramId, pool2) ?? (deps.recover === void 0 ? readPoolState2(connection, pool2) : void 0);
   const recovery = await (deps.recover ?? runRecover)({
     store,
     connection,
@@ -72993,7 +73312,7 @@ function assertProvedPaymentBinding(proved, { poolDomain, inputAccountCommitment
     fail15("proved_request_binding_invalid");
   }
 }
-var import_web3106, MODEL_DIR3, seedBytes5, EARLY_CHAIN_TIME_MAX_AGE_MS, settledNoteExits;
+var import_web3106, MODEL_DIR3, seedBytes5, EARLY_CHAIN_TIME_MAX_AGE_MS, settledNoteExits, PROOF_CHAIN_TIME_REUSE_MS, lastClockAnswers;
 var init_prepareRecoveredPayment = __esm({
   "wallet/src/pay/prepareRecoveredPayment.mjs"() {
     "use strict";
@@ -73015,6 +73334,8 @@ var init_prepareRecoveredPayment = __esm({
     seedBytes5 = (state) => Uint8Array.from(Buffer.from(state.seedHex, "hex"));
     EARLY_CHAIN_TIME_MAX_AGE_MS = 3e4;
     settledNoteExits = /* @__PURE__ */ new Map();
+    PROOF_CHAIN_TIME_REUSE_MS = 5e3;
+    lastClockAnswers = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -92013,21 +92334,60 @@ function floatOffer({ paymentRequired, store, config }) {
   }
   return { requirement, priceAtomic, feeAtomic, paidAtomic: (BigInt(priceAtomic) + BigInt(feeAtomic)).toString(), config };
 }
+function walletEta(seedHex) {
+  const key = hash8(`carbon-road/float-eta/v1|${seedHex}`);
+  if (etaEntry?.key === key) return etaEntry.eta;
+  const { eta } = deriveWalletViewingAuthority2({ seedBytes: Uint8Array.from(Buffer.from(seedHex, "hex")), generator: loadPayerGenerator() });
+  etaEntry = { key, eta };
+  return eta;
+}
+function warmFloatPay({ store, connection } = {}) {
+  return (async () => {
+    try {
+      const { network, pool: pool2, seedHex } = store.state;
+      const poolKey = `${network}:${pool2}`;
+      const failedAt = poolDomainWarmFailedAt.get(poolKey);
+      const backingOff = failedAt !== void 0 && Date.now() - failedAt < WARM_RETRY_MS;
+      let read;
+      if (connection && !backingOff && poolDomains.get(poolKey) === void 0 && !poolDomainReads.has(poolKey)) {
+        read = (async () => {
+          const state = await readPoolState2(connection, new import_web3109.PublicKey(pool2));
+          if (!state?.poolDomain) throw new Error("pool_unreadable");
+          const poolDomain = BigInt(state.poolDomain);
+          poolDomains.set(poolKey, poolDomain);
+          return poolDomain;
+        })();
+        poolDomainReads.set(poolKey, read);
+        read.then(
+          () => {
+            poolDomainReads.delete(poolKey);
+            poolDomainWarmFailedAt.delete(poolKey);
+          },
+          () => {
+            poolDomainReads.delete(poolKey);
+            poolDomainWarmFailedAt.set(poolKey, Date.now());
+          }
+        );
+      }
+      walletEta(seedHex);
+      await read;
+    } catch {
+    }
+  })();
+}
 async function ownRefundAddress(store, connection) {
   const poolKey = `${store.state.network}:${store.state.pool}`;
   let poolDomain = poolDomains.get(poolKey);
+  if (poolDomain === void 0 && poolDomainReads.has(poolKey)) {
+    poolDomain = await poolDomainReads.get(poolKey).catch(() => void 0);
+  }
   if (poolDomain === void 0) {
     const pool2 = await readPoolState2(connection, new import_web3109.PublicKey(store.state.pool));
     if (!pool2?.poolDomain) fail18("p03_float_pool_unreadable_retry_same_request");
     poolDomain = BigInt(pool2.poolDomain);
     poolDomains.set(poolKey, poolDomain);
   }
-  payerGenerator ??= JSON.parse(readFileSync(fileURLToPath9(new URL(
-    "../../vendor/shielded-x402-model/vectors/rust-vectors.json",
-    new URL("__bundled_source__/wallet/src/pay/floatPay.mjs", import.meta.url).href
-  )), "utf8")).payerKeys.generator;
-  const { eta } = deriveWalletViewingAuthority2({ seedBytes: Uint8Array.from(Buffer.from(store.state.seedHex, "hex")), generator: payerGenerator });
-  return deriveShieldedSolanaP03Recipient({ eta, poolDomain, resourceNonce: randomBytes11(32) }).payTo;
+  return deriveShieldedSolanaP03Recipient({ eta: walletEta(store.state.seedHex), poolDomain, resourceNonce: randomBytes11(32) }).payTo;
 }
 function canonicalBody({ requestId, resourceUrl, requirement, refundTo }) {
   const opaque = `w-${hash8(`carbon-road/float-request/v1|${requestId}`).slice(0, 40)}`;
@@ -92356,7 +92716,7 @@ function paidResult(record, replayed) {
     float: { floatId: record.floatId }
   };
 }
-var import_web3109, FLOAT_PAYMENT_SCHEMA, REGENERATE_CODES, FLOAT_PAYMENT_WAL_PREFIX, FLOAT_CONFIG_SCHEMA, FLOAT_PAY_PATH, MAX_BODY_BYTES, FLOAT_REFUND_ETA_SECONDS, REFUND_SETTLED_AFTER_MS, FINISHING_POLL_MS, FINISHING_LIMIT_MS, SELLER_TIMEOUT_MS, CONFIG_TIMEOUT_MS, CONFIG_CACHE_MS, DECIMAL3, POSITIVE, PENDING_CODES, hash8, fail18, floatPaymentWalName, configCache, poolDomains, payerGenerator, plainText;
+var import_web3109, FLOAT_PAYMENT_SCHEMA, REGENERATE_CODES, FLOAT_PAYMENT_WAL_PREFIX, FLOAT_CONFIG_SCHEMA, FLOAT_PAY_PATH, MAX_BODY_BYTES, FLOAT_REFUND_ETA_SECONDS, REFUND_SETTLED_AFTER_MS, FINISHING_POLL_MS, FINISHING_LIMIT_MS, SELLER_TIMEOUT_MS, CONFIG_TIMEOUT_MS, CONFIG_CACHE_MS, DECIMAL3, POSITIVE, PENDING_CODES, hash8, fail18, floatPaymentWalName, configCache, poolDomains, poolDomainReads, poolDomainWarmFailedAt, WARM_RETRY_MS, payerGenerator, etaEntry, loadPayerGenerator, plainText;
 var init_floatPay = __esm({
   "wallet/src/pay/floatPay.mjs"() {
     "use strict";
@@ -92396,6 +92756,13 @@ var init_floatPay = __esm({
     floatPaymentWalName = (requestKey) => `${FLOAT_PAYMENT_WAL_PREFIX}${requestKey}`;
     configCache = /* @__PURE__ */ new Map();
     poolDomains = /* @__PURE__ */ new Map();
+    poolDomainReads = /* @__PURE__ */ new Map();
+    poolDomainWarmFailedAt = /* @__PURE__ */ new Map();
+    WARM_RETRY_MS = 3e4;
+    loadPayerGenerator = () => payerGenerator ??= JSON.parse(readFileSync(fileURLToPath9(new URL(
+      "../../vendor/shielded-x402-model/vectors/rust-vectors.json",
+      new URL("__bundled_source__/wallet/src/pay/floatPay.mjs", import.meta.url).href
+    )), "utf8")).payerKeys.generator;
     plainText = (value) => value.replace(/[^ -~]+/g, " ").trim().slice(0, 300);
   }
 });
@@ -92852,6 +93219,22 @@ function writeFinalized(store, name, record, settlement) {
   store.writeWal(name, finalized);
   return finalized;
 }
+function finalizePendingFromHistory({ store, history, programId, olderThanMs }) {
+  let written = 0;
+  for (const name of store.listWal().filter((entry) => entry.startsWith("resource-payment-"))) {
+    try {
+      const record = readPriorPayment(store, name);
+      if (record === FINAL_UNCHANGED || !isPending(record)) continue;
+      if (olderThanMs !== void 0 && !(Number.isSafeInteger(record.answeredAtMs) && Date.now() - record.answeredAtMs >= olderThanMs)) continue;
+      const settlement = settlementInHistory(history, record.paymentHeader, store.state, programId);
+      if (!settlement) continue;
+      writeFinalized(store, name, record, settlement);
+      written += 1;
+    } catch {
+    }
+  }
+  return written;
+}
 async function awaitResourceReceiptFinality({
   store,
   connection,
@@ -93203,7 +93586,27 @@ async function payResourceOnce({
       releaseReservation(store, name.slice("resource-payment-".length));
     }
   };
+  let priorHistory;
   try {
+    if (deps.settlePriorBeforeQuote === true && !record && !reconciling) {
+      const answeredLongAgo = (other) => isPending(other) && Number.isSafeInteger(other.answeredAtMs) && Date.now() - other.answeredAtMs >= FINALITY_GATE_SKIP_AFTER_MS;
+      if (others.some((name) => !finalOthers.has(name) && answeredLongAgo(store.readWal(name)))) {
+        try {
+          priorHistory = assertAuthenticatedFinalizedP03History(
+            await withPhaseScope(mark, "prior-walk", () => withRecentWalletHistory(() => finality.walkHistory()))
+          );
+          const settled = finalizePendingFromHistory({
+            store,
+            history: priorHistory,
+            programId,
+            olderThanMs: FINALITY_GATE_SKIP_AFTER_MS
+          });
+          mark("prior-finality-settled-from-walk", String(settled));
+        } catch {
+          priorHistory = void 0;
+        }
+      }
+    }
     for (const name of others) {
       if (reconciling) break;
       if (finalOthers.has(name)) continue;
@@ -93240,7 +93643,11 @@ async function payResourceOnce({
           serviceUrl: serviceUrl2,
           reservedReplayValues: held,
           amountAtomic: maximumAtomic,
-          deps: { fetchImpl: deps.fetchImpl, walkHistory: finality.walkHistory }
+          // The report read above when there is one (the prewarm is taken once).
+          deps: {
+            fetchImpl: deps.fetchImpl,
+            walkHistory: priorHistory !== void 0 ? async () => priorHistory : finality.walkHistory
+          }
         }));
       } catch {
         first = false;
@@ -94953,13 +95360,26 @@ var init_EncryptedJsonFile = __esm({
        * one value under one key encrypt it once (the P03 settle journal).
        */
       async writeText(payload2) {
+        await this.writeTextStamped(payload2);
+        return payload2;
+      }
+      /**
+       * writeText() that returns the written file's `ino:size:mtimeNs`, read by
+       * fstat on the fsynced temporary file before the rename (a rename keeps all
+       * three), so a file another writer renames in later can never carry this
+       * write's stamp. Undefined when the file is not durable (no fsync handle).
+       */
+      async writeTextStamped(payload2) {
         await mkdir3(dirname18(this.filePath), { recursive: true });
         const temporaryPath = `${this.filePath}.${process.pid}.${randomBytes16(6).toString("hex")}.tmp`;
         await writeFile2(temporaryPath, payload2, { mode: 384 });
+        let stamp;
         if (this.options.durable) {
           const temporary = await open2(temporaryPath, "r+");
           try {
             await temporary.sync();
+            const stats = await temporary.stat({ bigint: true });
+            stamp = `${stats.ino}:${stats.size}:${stats.mtimeNs}`;
           } finally {
             await temporary.close();
           }
@@ -94978,7 +95398,7 @@ var init_EncryptedJsonFile = __esm({
           }
         }
         this.migratedPlaintext = false;
-        return payload2;
+        return stamp;
       }
       shouldRewriteEncrypted() {
         return this.encrypted && this.migratedPlaintext;
@@ -96657,8 +97077,7 @@ function createMemoEcdhWorker(options) {
       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: () => {
+    return { parts: jobs.map((job) => job.result), cancel: () => {
       for (const job of jobs) job.cancel();
     } };
   };
@@ -97502,14 +97921,14 @@ async function createSellerAdapter({
         if (job !== void 0) {
           precomputesRunning += 1;
           owned.cancel = job.cancel;
-          precomputed = job.result.then((entries) => {
+          precomputed = Promise.all(job.parts.map((part) => part.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(() => {
+          }).catch(() => void 0))).finally(() => {
             precomputesRunning -= 1;
           });
         }
@@ -119444,7 +119863,10 @@ async function payAndFetch(session, url, init = {}, opts = {}) {
     let price;
     let challenge3;
     if (!rerun) {
-      if (store !== void 0) startHistoryPrewarm(session, store, mark);
+      if (store !== void 0) {
+        startHistoryPrewarm(session, store, mark);
+        warmFloatPay({ store, connection: session.connection });
+      }
       const response = await unpaidRequest(target, () => keepAliveInit({
         method,
         headers,
@@ -121139,6 +121561,7 @@ function combinePoolBalances(partsAtomic, movingAtomic2 = "0") {
 
 // wallet/src/mcp/tools.mjs
 init_recover();
+init_recoveryPath();
 init_walk();
 init_payResource();
 init_floatPay();
@@ -123278,7 +123701,7 @@ function moveBody({ amountAtomic, refundTo, fromPool, n, toPool }) {
   const bodyText = `{"amountAtomic":${JSON.stringify(amountAtomic)},"refundTo":${JSON.stringify(refundTo)},"requestId":${JSON.stringify(requestId)},"toPool":${JSON.stringify(toPool)}}`;
   return { bodyText, moveId: hash10(bodyText) };
 }
-function walletEta(store) {
+function walletEta2(store) {
   const generator2 = JSON.parse(readFileSync(fileURLToPath15(new URL(
     "../../vendor/shielded-x402-model/vectors/rust-vectors.json",
     new URL("__bundled_source__/wallet/src/move/job.mjs", import.meta.url).href
@@ -123561,7 +123984,7 @@ async function runMove({
           return answer("done", void 0, { ...base, ...dust });
         }
         const n = moveLegs(store, from.pool).reduce((high, entry) => Math.max(high, entry.n), 0) + 1;
-        const refundTo = ownTargetAddress(walletEta(open3(targetPath, passphrase2)), to.poolDomain);
+        const refundTo = ownTargetAddress(walletEta2(open3(targetPath, passphrase2)), to.poolDomain);
         const { bodyText, moveId } = moveBody({ amountAtomic: plan.leg.amountAtomic, refundTo, fromPool: from.pool, n, toPool: to.pool });
         leg = {
           schema: MOVE_WAL_SCHEMA,
@@ -126902,6 +127325,7 @@ async function refreshWallet({ session, store, history: walked, share }) {
     }
   });
   assertAuthenticatedFinalizedP03History(history);
+  finalizePendingFromHistory({ store, history, programId: session.programId });
   const snapshot = snapshotFromRecovery({
     state: store.state,
     programId: session.programId,
@@ -126913,6 +127337,8 @@ async function refreshWallet({ session, store, history: walked, share }) {
   });
   writeBalanceSnapshot(store, snapshot);
   returnArrivedFloatRefundBudgets(store, snapshot);
+  prepareFinalizedP03RecoveryFold(history).catch(() => {
+  });
 }
 function shieldedUnknown(store) {
   return computeBalance({ store, snapshotRead: readBalanceSnapshot(store), source: "local" }).split?.shieldedAtomic == null;
@@ -127442,12 +127868,15 @@ function createWalletTools({
       runDeferredRefresh();
     });
   }
-  async function refreshIfStale() {
+  async function refreshIfStale(onPhase = () => {
+  }) {
     let stale;
     try {
       stale = shieldedUnknown(session.openStore());
     } catch {
       return;
+    } finally {
+      onPhase("mcp-stale-read");
     }
     if (!stale || refreshFailedAt && Date.now() - refreshFailedAt < REFRESH_RETRY_MS) return;
     if (finalityWait || refreshRun && refreshInBackground) return;
@@ -127629,13 +128058,16 @@ function createWalletTools({
         return refuse9("mcp_argument_invalid", "request_id must be 1-128 characters of A-Z a-z 0-9 . _ : -", "leave request_id out for a new payment");
       }
       knownIds.set(sha256Hex2(Buffer.from(requestId, "utf8")), requestId);
+      const gateTimes = [["mcp-args", Date.now()]];
       const pocketRequest = { requestId, url: target.url, method: request.method, headers: request.headers, body: request.body };
       const early = autoPockets.beforePay(pocketRequest);
       if (early) {
         const one2 = localBalance(session);
         return json({ ...early, ...one2 ? { balanceAtomic: one2.balanceAtomic, balance: one2.balance, breakdown: { ...one2.breakdown, ...early.breakdown ?? {} } } : {} });
       }
-      await refreshIfStale();
+      gateTimes.push(["mcp-pockets", Date.now()]);
+      await refreshIfStale((phase) => gateTimes.push([phase, Date.now()]));
+      gateTimes.push(["mcp-refresh", Date.now()]);
       const switched = await switchGate(cap.maxPaymentAtomic, requestId, "x402_pay");
       if (switched) return switched;
       let timing;
@@ -127644,12 +128076,13 @@ function createWalletTools({
       } catch {
         timing = void 0;
       }
-      const mark = (phase) => {
+      const mark = (phase, at) => {
         try {
-          timing?.(phase);
+          timing?.(phase, void 0, at);
         } catch {
         }
       };
+      for (const [phase, at] of gateTimes) mark(phase, at);
       mark("mcp-gates");
       const payOnce = async () => {
         const end = autoPockets.paymentStart();