shinjuku-shielded 0.3.45 → 0.3.46

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "54ae7e6525d0c2a5330f3243891a2cbc5d728a4bcea81a61ba3aaf065bed8b63",
-  "bytes": 11266570,
-  "sourceCommit": "f4f870fa4e4b3f57cc4dfdb472b75e5a3fef8db2",
+  "sha256": "fe90fa0a418682c08b49b05bcda64ffd7b6cf8803166f95968205c80a2fcab4b",
+  "bytes": 11282021,
+  "sourceCommit": "4664c1b8a728712acc576493a6cabb03ccbe4167",
   "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.45",
+  "version": "0.3.46",
   "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": "54ae7e65",
-  "shinjukuSha256": "54ae7e6525d0c2a5330f3243891a2cbc5d728a4bcea81a61ba3aaf065bed8b63",
+  "shinjukuRelease": "fe90fa0a",
+  "shinjukuSha256": "fe90fa0a418682c08b49b05bcda64ffd7b6cf8803166f95968205c80a2fcab4b",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -48326,6 +48326,9 @@ function encryptJson(key, value) {
   return { nonceHex: nonce.toString("hex"), tagHex: cipher.getAuthTag().toString("hex"), ciphertextHex: ciphertext.toString("hex") };
 }
 function decryptJson(key, envelope, label) {
+  return decryptJsonText(key, envelope, label).value;
+}
+function decryptJsonText(key, envelope, label) {
   try {
     const decipher = createDecipheriv(
       "aes-256-gcm",
@@ -48337,7 +48340,8 @@ function decryptJson(key, envelope, label) {
       decipher.update(Buffer.from(envelope.ciphertextHex, "hex")),
       decipher.final()
     ]);
-    return JSON.parse(plaintext.toString("utf8"));
+    const text3 = plaintext.toString("utf8");
+    return { text: text3, value: JSON.parse(text3) };
   } catch {
     throw new WalletStoreError(`${label}_decrypt_failed`);
   }
@@ -48409,6 +48413,9 @@ function writeEnvelope(path, key, schema, value) {
 `, "utf8"));
 }
 function readWalEnvelope(path, key) {
+  return readWalEnvelopeText(path, key).value;
+}
+function readWalEnvelopeText(path, key) {
   let envelope;
   try {
     envelope = JSON.parse(readFileSync(path, "utf8"));
@@ -48416,7 +48423,51 @@ function readWalEnvelope(path, key) {
     throw new WalletStoreError("wallet_wal_unreadable");
   }
   if (envelope?.schema !== WAL_SCHEMA) throw new WalletStoreError("wallet_wal_schema_invalid");
-  return decryptJson(key, envelope, "wallet_wal");
+  return { ...decryptJsonText(key, envelope, "wallet_wal"), sealId: `${envelope.nonceHex}:${envelope.tagHex}` };
+}
+function walSealOf(path) {
+  const head = Buffer.alloc(WAL_SEAL_HEAD_BYTES);
+  let length;
+  const fd = openSync(path, "r");
+  try {
+    length = readSync(fd, head, 0, WAL_SEAL_HEAD_BYTES, 0);
+  } finally {
+    closeSync(fd);
+  }
+  const text3 = head.subarray(0, length).toString("utf8");
+  if (!text3.startsWith(WAL_SEAL_PREFIX)) return void 0;
+  const match = WAL_SEAL_REST.exec(text3.slice(WAL_SEAL_PREFIX.length));
+  return match ? `${match[1]}:${match[2]}` : void 0;
+}
+function readWalCached(path, key) {
+  const byPath = walPlaintextsOf(key);
+  let statId;
+  try {
+    statId = walStatId(path);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      byPath.delete(path);
+      return void 0;
+    }
+    statId = void 0;
+  }
+  const cached = statId === void 0 ? void 0 : byPath.get(path);
+  if (cached !== void 0 && cached.statId === statId) {
+    let seal;
+    try {
+      seal = walSealOf(path);
+    } catch {
+      seal = void 0;
+    }
+    if (seal !== void 0 && seal === cached.sealId) return JSON.parse(cached.text);
+  }
+  byPath.delete(path);
+  const read = readWalEnvelopeText(path, key);
+  if (statId !== void 0) {
+    if (byPath.size >= WAL_PLAINTEXTS_PER_KEY) byPath.delete(byPath.keys().next().value);
+    byPath.set(path, { statId, sealId: read.sealId, text: read.text });
+  }
+  return read.value;
 }
 function walNames(directory) {
   return readdirSync(directory).filter((name) => name.endsWith(".json") && name !== WAL_OWNER_FILE).map((name) => {
@@ -48564,29 +48615,45 @@ function openWalletStore(path, passphrase2) {
     writeWal(name, record) {
       assertWalName(name);
       bindWalDirectory(walDirectory, key);
-      writeEnvelope(join3(walDirectory, `${name}.json`), key, WAL_SCHEMA, record);
+      const walPath = join3(walDirectory, `${name}.json`);
+      walPlaintextsOf(key).delete(walPath);
+      try {
+        writeEnvelope(walPath, key, WAL_SCHEMA, record);
+      } finally {
+        walPlaintextsOf(key).delete(walPath);
+      }
     },
     readWal(name) {
       assertWalName(name);
       bindWalDirectory(walDirectory, key);
       const walPath = join3(walDirectory, `${name}.json`);
-      if (!existsSync(walPath)) return void 0;
-      return readWalEnvelope(walPath, key);
+      if (name.startsWith(WAL_UNCACHED_PREFIX)) {
+        if (!existsSync(walPath)) return void 0;
+        return readWalEnvelope(walPath, key);
+      }
+      return readWalCached(walPath, key);
     },
     listWal() {
       bindWalDirectory(walDirectory, key);
-      return walNames(walDirectory);
+      const names = walNames(walDirectory);
+      const byPath = walPlaintextsOf(key);
+      if (byPath.size > 0) {
+        const listed = new Set(names.map((name) => join3(walDirectory, `${name}.json`)));
+        for (const path2 of byPath.keys()) if (dirname2(path2) === walDirectory && !listed.has(path2)) byPath.delete(path2);
+      }
+      return names;
     },
     removeWal(name) {
       assertWalName(name);
       bindWalDirectory(walDirectory, key);
       const walPath = join3(walDirectory, `${name}.json`);
+      walPlaintextsOf(key).delete(walPath);
       if (existsSync(walPath)) unlinkSync(walPath);
     }
   };
   return store;
 }
-var STORE_SCHEMA, WAL_SCHEMA, SCRYPT, WAL_OWNER_FILE, WAL_OWNER_SCHEMA, WalletStoreError, KEY_CACHE_LIMIT, keyCacheSecret, keyCache, keyStats, keyCacheId, rememberKey, verifiedWalOwners, ownerStatId, assertPassphrase, assertWalName;
+var STORE_SCHEMA, WAL_SCHEMA, SCRYPT, WAL_OWNER_FILE, WAL_OWNER_SCHEMA, WalletStoreError, KEY_CACHE_LIMIT, keyCacheSecret, keyCache, keyStats, keyCacheId, rememberKey, walPlaintexts, WAL_PLAINTEXTS_PER_KEY, WAL_UNCACHED_PREFIX, WAL_SEAL_HEAD_BYTES, WAL_SEAL_PREFIX, WAL_SEAL_REST, walStatIdForTests, walStatId, walPlaintextsOf, verifiedWalOwners, ownerStatId, assertPassphrase, assertWalName;
 var init_store = __esm({
   "wallet/src/store/store.mjs"() {
     "use strict";
@@ -48612,6 +48679,24 @@ var init_store = __esm({
       keyCache.set(id, key);
       while (keyCache.size > KEY_CACHE_LIMIT) keyCache.delete(keyCache.keys().next().value);
     };
+    walPlaintexts = /* @__PURE__ */ new WeakMap();
+    WAL_PLAINTEXTS_PER_KEY = 4096;
+    WAL_UNCACHED_PREFIX = "resource-proof-";
+    WAL_SEAL_HEAD_BYTES = 512;
+    WAL_SEAL_PREFIX = `{
+  "schema": ${JSON.stringify(WAL_SCHEMA)},
+  "nonceHex": "`;
+    WAL_SEAL_REST = /^([0-9a-f]{24})",\n  "tagHex": "([0-9a-f]{32})",\n/;
+    walStatId = (path) => {
+      if (walStatIdForTests) return walStatIdForTests(path);
+      const stat = statSync(path, { bigint: true });
+      return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+    };
+    walPlaintextsOf = (key) => {
+      let byPath = walPlaintexts.get(key);
+      if (!byPath) walPlaintexts.set(key, byPath = /* @__PURE__ */ new Map());
+      return byPath;
+    };
     verifiedWalOwners = /* @__PURE__ */ new WeakMap();
     ownerStatId = (path) => {
       const stat = statSync(path, { bigint: true });
@@ -49274,6 +49359,7 @@ function keepAliveDispatcher() {
     const global2 = globalThis[GLOBAL_DISPATCHER];
     if (global2?.constructor?.name !== "Agent") return void 0;
     shared = new global2.constructor({ keepAliveTimeout: KEEP_ALIVE_MS, keepAliveMaxTimeout: KEEP_ALIVE_MS });
+    shared.on?.("connect", () => markPhase("socket-new"));
     return shared;
   } catch {
     return void 0;
@@ -49287,6 +49373,7 @@ var GLOBAL_DISPATCHER, KEEP_ALIVE_MS, shared;
 var init_keepAlive = __esm({
   "wallet/src/fetch/keepAlive.mjs"() {
     "use strict";
+    init_phaseTiming();
     GLOBAL_DISPATCHER = /* @__PURE__ */ Symbol.for("undici.globalDispatcher.1");
     KEEP_ALIVE_MS = 2e4;
   }
@@ -50129,7 +50216,8 @@ function connectSplit(own, historyUrl, commitment = "finalized", { pause: pause3
   const counts = Object.freeze({
     history: Object.fromEntries([...HISTORY_RPC_METHODS, "getTransactions"].map((name) => [name, 0])),
     // getTransaction here counts crossCheck's reads only; the walk's own getTransaction always goes to the history source.
-    own: Object.fromEntries([...ownRouted, "getTransaction"].map((name) => [name, 0])),
+    // getSignaturesForAddress here counts the reads asked through historyRpcOwnConnection only.
+    own: Object.fromEntries([...ownRouted, "getTransaction", "getSignaturesForAddress"].map((name) => [name, 0])),
     // signaturesVerified: history-source transactions whose Ed25519 signatures
     // verified (verifiedTransaction); crossChecked: served transactions the
     // own RPC read again and found equal (crossCheck).
@@ -50293,6 +50381,19 @@ function connectSplit(own, historyUrl, commitment = "finalized", { pause: pause3
     get: () => (counts.history[name] ?? 0) + (counts.own[name] ?? 0),
     enumerable: true
   }])));
+  const ownCounted = new Proxy(own, {
+    get(target, property) {
+      const value = Reflect.get(target, property);
+      if (typeof value !== "function") return value;
+      if (Object.hasOwn(counts.own, property)) {
+        return (...args) => {
+          counts.own[property] += 1;
+          return value.apply(target, args);
+        };
+      }
+      return value.bind(target);
+    }
+  });
   const crossCheck = async ({ count: count2 = HISTORY_CROSS_CHECK_COUNT } = {}) => {
     const eligible = [...served.keys()];
     const picks = Math.min(count2, eligible.length);
@@ -50341,6 +50442,7 @@ function connectSplit(own, historyUrl, commitment = "finalized", { pause: pause3
       if (property === "historyRpcIntegrity") return historyRpcIntegrity;
       if (property === "historyRpcWarm") return historyRpcWarm;
       if (property === "historyRpcSource") return history;
+      if (property === "historyRpcOwnConnection") return ownCounted;
       const value = Reflect.get(target, property);
       return typeof value === "function" ? value.bind(target) : value;
     }
@@ -50983,7 +51085,13 @@ function createCompactHistoryCacheStore({ path, hmacKey, now }) {
       // 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] } } : {}
+      // `unverified`: some roots were reused from an earlier file and not hashed again by the
+      // process that wrote this one (a new process then folds them itself; hintCompactFold).
+      ...state.foldRoots ? { foldRoots: {
+        zero: state.foldRoots.zero,
+        roots: [...state.foldRoots.roots],
+        ...state.foldRoots.unverified === true ? { unverified: true } : {}
+      } } : {}
     }),
     deserialize: (value) => {
       const init = value?.initialization;
@@ -51006,7 +51114,11 @@ function createCompactHistoryCacheStore({ path, hmacKey, now }) {
         }),
         ...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] } } : {}
+        ...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],
+          ...value.foldRoots.unverified === true ? { unverified: true } : {}
+        } } : {}
       };
     }
   });
@@ -53100,7 +53212,12 @@ async function programDataCoverageFor({
   onFullAttestation,
   // Called before the two reads are asked once more after a transport failure or a timeout
   // (compact.mjs: a new Tor circuit). Absent: no second try.
-  onReuseRetry
+  onReuseRetry,
+  // The connection for the two reuse reads ONLY (compact.mjs: the split's own RPC, bounded),
+  // so one RPC answers both, at or after snapshotSlot, with no history-source floor below it
+  // (2026-10-16 c1s: the signature read on the proxy cost a -32016 retry, about 0.2 s).
+  // The full attestation and its newest signature keep `connection`. Absent: `connection`.
+  reuseConnection = connection
 }) {
   if (deploymentIdentity === void 0) return { coverage: void 0, attestation: void 0, reused: false };
   let priorRefused = false;
@@ -53112,12 +53229,12 @@ async function programDataCoverageFor({
       try {
         const [, newest2] = await Promise.all([
           readProgramDataHeader({
-            connection,
+            connection: reuseConnection,
             address: address5,
             snapshotSlot,
             deployedAtSlot: BigInt(prior.coverage.deployedAtSlot)
           }),
-          newestSignature(connection, address5, snapshotSlot)
+          newestSignature(reuseConnection, address5, snapshotSlot)
         ]);
         if (newest2.signature === prior.newestSignature) {
           const coverage2 = Object.freeze({ ...prior.coverage, throughFinalizedSlot: BigInt(snapshotSlot) });
@@ -55311,6 +55428,10 @@ function foldCompactLeavesReusing(pool2, leaves, counts, { frontier, fresh = /*
 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 (foldRoots.unverified === true) {
+    markPhase("compact-roots-unverified");
+    return false;
+  }
   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;
@@ -55334,15 +55455,31 @@ function dropCachedFoldRoots(pool2, cache) {
   droppedPools.add(pool2);
   lastFolds.delete(pool2);
   dropRecoveryFold();
+  rewriteFoldRoots(pool2, cache, () => void 0);
+}
+function rewriteFoldRoots(pool2, cache, next) {
   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 });
+    const { foldRoots, savedAt, ...rest } = current;
+    const replaced = next(foldRoots);
+    if (replaced === foldRoots) return;
+    await cache.save({ ...rest, ...replaced === void 0 ? {} : { foldRoots: replaced } }, { savedAt });
   })().catch(() => {
   });
 }
+function markFoldRootsVerified(pool2, cache) {
+  rewriteFoldRoots(pool2, cache, (foldRoots) => {
+    const hashed = lastFolds.get(pool2);
+    if (foldRoots.unverified !== true || droppedPools.has(pool2) || hashed === void 0 || hashed.tainted) return foldRoots;
+    const every = foldRoots.roots.every((root, at) => {
+      const own = hashed.roots.get(at + 1);
+      return own !== void 0 && hex64(own) === root;
+    });
+    return every ? { zero: foldRoots.zero, roots: foldRoots.roots } : foldRoots;
+  });
+}
 function startCachedRootsVerify({ pool: pool2, leaves, cachedRoots, cache }) {
   if (verifying.has(pool2) || cachedRoots.size === 0) return;
   verifying.add(pool2);
@@ -55350,7 +55487,8 @@ function startCachedRootsVerify({ pool: pool2, leaves, cachedRoots, cache }) {
   }).finally(() => verifying.delete(pool2));
 }
 async function verifyCachedRoots({ pool: pool2, leaves, cachedRoots, cache }) {
-  const last = Math.max(...cachedRoots.keys());
+  let last = 0;
+  for (const at of cachedRoots.keys()) if (at > last) last = at;
   if (last > leaves.length) return;
   let sliceStart = 0;
   const quiet = async () => {
@@ -55379,6 +55517,7 @@ async function verifyCachedRoots({ pool: pool2, leaves, cachedRoots, cache }) {
   }
   forgetCachedFoldRoots(pool2, cachedRoots);
   markPhase("compact-roots-verified");
+  markFoldRootsVerified(pool2, cache);
 }
 function fieldOf(hex4) {
   if (typeof hex4 !== "string" || !HEX64.test(hex4)) throw refuse3("p03_compact_history_record_invalid");
@@ -55605,9 +55744,7 @@ async function readPages(history, pool2, needed, first, { wakeSlot } = {}) {
       throw Object.assign(refuse3("p03_compact_history_source_refused"), { cause: response.error });
     }
     const result = response?.result;
-    if (!result || typeof result !== "object" || result.pool !== pool2 || result.fromOrdinal !== from || !isIndex(result.total) || !isIndex(result.syncedSlot) || !Array.isArray(result.records) || result.records.length !== Math.max(0, Math.min(result.total, from + P03_COMPACT_PAGE) - from) || !result.initialization || !isSignature(result.initialization.signature) || !isIndex(result.initialization.slot)) {
-      throw refuse3("p03_compact_history_source_answer_invalid");
-    }
+    if (!pageShapeValid(result, pool2, from)) throw refuse3("p03_compact_history_source_answer_invalid");
     if (initialization !== void 0 && (result.initialization.signature !== initialization.signature || result.initialization.slot !== initialization.slot || result.syncedSlot < syncedSlot)) {
       throw refuse3("p03_compact_history_source_answer_invalid");
     }
@@ -55637,6 +55774,25 @@ async function readPages(history, pool2, needed, first, { wakeSlot } = {}) {
   }
   return { records: records.slice(0, needed), imports, initialization, syncedSlot };
 }
+async function readCompactPoolSnapshot({ connection, programId, pool: pool2 }) {
+  return readFinalizedPool(withBoundedOwnReads(connection), new import_web397.PublicKey(programId), new import_web397.PublicKey(pool2));
+}
+function pageShapeValid(result, pool2, from) {
+  return Boolean(result) && typeof result === "object" && result.pool === pool2 && result.fromOrdinal === from && isIndex(result.total) && isIndex(result.syncedSlot) && Array.isArray(result.records) && result.records.length === Math.max(0, Math.min(result.total, from + P03_COMPACT_PAGE) - from) && Boolean(result.initialization) && isSignature(result.initialization.signature) && isIndex(result.initialization.slot);
+}
+function isCompactPageZeroAnswer(response, pool2) {
+  if (response === null || typeof response !== "object" || "error" in response) return false;
+  const result = response.result;
+  if (!pageShapeValid(result, pool2, 0)) return false;
+  if (result.imports === void 0) return true;
+  if (!Array.isArray(result.imports)) return false;
+  try {
+    for (const entry of result.imports) validateImport(entry, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function splitWire(bytes2) {
   if (bytes2.length < 2) throw refuse3("p03_compact_history_spot_check_invalid");
   if (bytes2[0] === VERSION_1_PREFIX2) {
@@ -55865,14 +56021,26 @@ async function readCompactP03HistoryNow({
   initialization: knownInitialization,
   // walletHistory.mjs: the pool's current index that a refresh read on this same own RPC moments
   // ago and refused as moved (p03_history_refresh_transition_detected carries it; that read held
-  // only the tree's header). The page request starts at once, beside the pool account read below,
-  // unless the cached records already reach that index.
+  // only the tree's header), or, after a payment took this run's last report, that report's index
+  // plus one subtree (its own settle moved the pool; refresh-skipped-own-pay). A hint only: the page
+  // request starts at once, beside the pool account read below, unless the cached records already
+  // reach that index. No check uses it; the pool account read below decides the count.
   knownIndex,
   // walletHistory.mjs compactFirst: the full pool account (readFinalizedPool, tree included) that
   // an earlier try of this same load read and folded nothing to because the source was behind
   // (p03_compact_history_source_behind carries it as behindSnapshot). Folded to again instead of
   // a second read of the pool account and its 386 KB tree; every check below runs on it as before.
   knownSnapshot,
+  // walletHistory.mjs compactFirst, with knownSnapshot only: the answer ({ response }) of the read that
+  // ended the behind wait, a full page 0 asked with minContextSlot = knownSnapshot.slot
+  // (waitForCompactSource). It is page 0 here instead of a second request for it; readPages checks
+  // it exactly as any page. Without knownSnapshot it is ignored.
+  knownFirst,
+  // walletHistory.mjs loadWalletP03HistoryNow, through compactFirst's first try only: the promise of
+  // readCompactPoolSnapshot started beside a refresh that then missed. It is this read's pool account
+  // read (the same finalized read and parse; every check below runs on it as before); when it failed,
+  // the pool account is read here as before. Ignored with knownSnapshot.
+  poolPreRead,
   // compactP03HistoryReport: run beside the spot checks once the initialization is verified
   // ({ snapshot, initialization, contexts }); its result comes back as `alongside`.
   alongside,
@@ -55896,22 +56064,36 @@ async function readCompactP03HistoryNow({
   own = withBoundedOwnReads(own);
   const hintIndex = knownSnapshot?.currentIndex ?? knownIndex;
   const cachedReachesKnown = hintIndex !== void 0 && served !== void 0 && Array.isArray(served.records) && Boolean(served.initialization) && BigInt(served.records.length) * SUBTREE_LEAVES3 >= hintIndex;
-  const first = served === void 0 || hintIndex !== void 0 && !cachedReachesKnown ? requestPage(source, poolString, 0) : void 0;
-  if (first !== void 0) markPhase("compact-page0-sent");
-  const snapshot = knownSnapshot ?? await readFinalizedPool(own, program, poolKey);
+  const reusedFirst = knownSnapshot !== void 0 && knownFirst !== void 0 ? knownFirst : void 0;
+  const first = reusedFirst ?? (served === void 0 || hintIndex !== void 0 && !cachedReachesKnown ? requestPage(source, poolString, 0) : void 0);
+  if (first !== void 0 && reusedFirst === void 0) markPhase("compact-page0-sent");
+  let snapshot = knownSnapshot;
+  if (snapshot === void 0 && poolPreRead !== void 0) {
+    markPhase("compact-pool-handed-over");
+    try {
+      snapshot = await poolPreRead;
+    } catch {
+      markPhase("compact-pool-preread-failed");
+    }
+  }
+  snapshot ??= await readFinalizedPool(own, program, poolKey);
   markPhase(knownSnapshot !== void 0 ? "compact-pool-reused" : "compact-pool");
   if (snapshot.terminal) throw refuse3("p03_compact_history_pool_terminal");
   if (snapshot.currentIndex % SUBTREE_LEAVES3 !== 0n) throw refuse3("p03_compact_history_snapshot_invalid");
   const count2 = Number(snapshot.currentIndex / SUBTREE_LEAVES3);
   if (!Number.isSafeInteger(count2)) throw refuse3("p03_compact_history_snapshot_invalid");
   const anchors = freezeFinalizedAnchors(snapshot);
+  const readServedPages = () => {
+    if (reusedFirst !== void 0) markPhase("compact-behind-page0-reused");
+    return readPages(source, poolString, count2, first, { wakeSlot: snapshot.slot });
+  };
   const page = count2 === 0 ? { records: [], imports: [], initialization: void 0, syncedSlot: void 0 } : served !== void 0 && Array.isArray(served.records) && served.records.length >= count2 && served.initialization ? {
     records: served.records.slice(0, count2),
     imports: Array.isArray(served.imports) ? served.imports : [],
     initialization: served.initialization,
     syncedSlot: served.syncedSlot,
     cached: true
-  } : await readPages(source, poolString, count2, first, { wakeSlot: snapshot.slot }).catch((error) => {
+  } : await readServedPages().catch((error) => {
     if (error?.compactHistoryRefusal === "p03_compact_history_source_behind") error.behindSnapshot = snapshot;
     throw error;
   });
@@ -56060,6 +56242,8 @@ async function compactP03HistoryReport({
   priorAttestation,
   knownIndex,
   knownSnapshot,
+  knownFirst,
+  poolPreRead,
   onList
 }) {
   if (deploymentIdentity === void 0) throw new Error("p03_history_deployment_identity_required");
@@ -56078,6 +56262,13 @@ async function compactP03HistoryReport({
     try {
       const attested2 = await programDataCoverage({
         connection: withBoundedOwnReads(connection),
+        // The two reuse reads on the split's own RPC, both bounded (it has no timeout): one RPC answers
+        // both at the snapshot slot (walk.mjs programDataCoverageFor reuseConnection; production c1s:
+        // the signature read on the history proxy cost a -32016 retry while it was behind).
+        ...connection.historyRpcOwnConnection === void 0 ? {} : { reuseConnection: /* @__PURE__ */ ((own) => ({
+          getAccountInfoAndContext: (...args) => boundedOwnRead(() => own.getAccountInfoAndContext(...args)),
+          getSignaturesForAddress: (...args) => boundedOwnRead(() => own.getSignaturesForAddress(...args))
+        }))(connection.historyRpcOwnConnection) },
         program,
         initialization: initialization2,
         snapshotSlot: snapshot2.slot,
@@ -56130,6 +56321,8 @@ async function compactP03HistoryReport({
     alongside: attest,
     ...knownIndex !== void 0 ? { knownIndex } : {},
     ...knownSnapshot !== void 0 ? { knownSnapshot } : {},
+    ...knownFirst !== void 0 ? { knownFirst } : {},
+    ...poolPreRead !== void 0 ? { poolPreRead } : {},
     ...onList !== void 0 ? { onList } : {},
     ...warm ? { served: cached.served } : {},
     ...cached ? { initialization: cached.initialization } : {},
@@ -56192,6 +56385,8 @@ async function compactP03HistoryReport({
     });
   }
   if (cache) {
+    const poolString = poolKey.toBase58();
+    const writesFoldRoots = compact.outerFrontier !== void 0 && !droppedPools.has(poolString);
     try {
       await cache.save({
         programId: program.toBase58(),
@@ -56206,11 +56401,16 @@ async function compactP03HistoryReport({
         initialization,
         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: {
+        // `unverified` while some came from the cache unhashed here: the check clears it once it
+        // hashed them (markFoldRootsVerified); a process that exits first leaves it, and the next
+        // process folds them itself.
+        ...writesFoldRoots ? { foldRoots: {
           zero: hex64(zeroRoots()[OUTER_DEPTH2]),
-          roots: report.contexts.map((context) => hex64(context.appendRoot))
+          roots: report.contexts.map((context) => hex64(context.appendRoot)),
+          ...compact.cachedRoots.size > 0 ? { unverified: true } : {}
         } } : {}
       });
+      if (writesFoldRoots && droppedPools.has(poolString)) rewriteFoldRoots(poolString, cache, () => void 0);
     } catch {
     }
   }
@@ -56944,6 +57144,7 @@ async function loadWalletP03History(args) {
       try {
         const report2 = await prewarm.promise;
         PREWARMED_REPORTS.add(report2);
+        PAYMENT_TAKEN_REPORTS.add(report2);
         markPhase("walk-prewarmed");
         if (runKey !== void 0) recentLoads.set(runKey, { startedAt: prewarm.startedAt, report: report2 });
         return report2;
@@ -56955,6 +57156,7 @@ async function loadWalletP03History(args) {
     const recent = recentLoads.get(runKey);
     if (recent !== void 0 && Date.now() - recent.startedAt <= HISTORY_PREWARM_JOIN_MS) {
       PREWARMED_REPORTS.add(recent.report);
+      PAYMENT_TAKEN_REPORTS.add(recent.report);
       markPhase("walk-recent");
       return recent.report;
     }
@@ -56996,9 +57198,27 @@ async function loadWalletP03HistoryNow({ store, connection: given, programId, po
   const remembered = runKey === void 0 || forceRead ? void 0 : lastRunReports.get(runKey);
   const earlier = remembered !== void 0 && Date.now() - remembered.at <= HISTORY_WARM_FRESH_MS ? remembered.report : void 0;
   let movedIndex;
-  if (earlier !== void 0) {
+  let poolPreRead;
+  const compactNext = Boolean(split5) && cache === void 0 && (source === "pinned" || source === "flag");
+  if (earlier !== void 0 && compactNext && PAYMENT_TAKEN_REPORTS.has(earlier)) {
+    markPhase("refresh-skipped-own-pay");
+    if (typeof onCompactList === "function" && Array.isArray(earlier.contexts)) {
+      try {
+        onCompactList(earlier.contexts);
+      } catch {
+      }
+    }
+    const index = earlier.finalizedPoolSnapshot?.currentIndex;
+    if (typeof index === "bigint") movedIndex = index + SUBTREE_LEAVES4;
+  } else if (earlier !== void 0) {
     markPhase("refresh-start");
     const refreshing = refreshFinalizedP03HistorySnapshot({ connection, programId, pool: pool2, history: earlier });
+    if (compactNext) {
+      poolPreRead = readCompactPoolSnapshot({ connection, programId, pool: pool2 });
+      poolPreRead.catch(() => {
+      });
+      markPhase("compact-pool-prestarted");
+    }
     if (typeof onCompactList === "function" && Array.isArray(earlier.contexts)) {
       try {
         onCompactList(earlier.contexts);
@@ -57020,7 +57240,7 @@ async function loadWalletP03HistoryNow({ store, connection: given, programId, po
       if (strict) floor?.strict();
     }
   }
-  if (split5 && cache === void 0 && (source === "pinned" || source === "flag")) {
+  if (compactNext) {
     const compact = await compactFirst({
       store,
       connection,
@@ -57030,6 +57250,7 @@ async function loadWalletP03HistoryNow({ store, connection: given, programId, po
       deploymentIdentity,
       forceRead,
       knownIndex: movedIndex,
+      poolPreRead,
       onCompactList
     });
     if (compact !== void 0) {
@@ -57071,7 +57292,7 @@ async function loadWalletP03HistoryNow({ store, connection: given, programId, po
   if (runKey !== void 0) rememberRunReport(runKey, result.report);
   return result.report;
 }
-async function compactFirst({ store, connection, source, programId, pool: pool2, deploymentIdentity, forceRead, knownIndex, onCompactList }) {
+async function compactFirst({ store, connection, source, programId, pool: pool2, deploymentIdentity, forceRead, knownIndex, poolPreRead, onCompactList }) {
   const started = Date.now();
   let behindNoticed = false;
   let behindTries = 0;
@@ -57096,8 +57317,10 @@ async function compactFirst({ store, connection, source, programId, pool: pool2,
     }
   };
   let behindSnapshot;
+  let behindPage;
   for (let tries = 0; ; tries += 1) {
-    const result = await tryCompactP03HistoryReport(behindSnapshot !== void 0 ? { ...options, knownSnapshot: behindSnapshot } : tries === 0 && knownIndex !== void 0 ? { ...options, knownIndex } : options);
+    const result = await tryCompactP03HistoryReport(behindSnapshot !== void 0 ? { ...options, knownSnapshot: behindSnapshot, ...behindPage !== void 0 ? { knownFirst: behindPage } : {} } : tries === 0 ? { ...options, ...knownIndex !== void 0 ? { knownIndex } : {}, ...poolPreRead !== void 0 ? { poolPreRead } : {} } : options);
+    behindPage = void 0;
     if (result.ok) {
       markPhase("walk-compact");
       const who = source === "pinned" ? "the pinned history proxy" : "--history-rpc";
@@ -57117,7 +57340,7 @@ async function compactFirst({ store, connection, source, programId, pool: pool2,
       markPhase("compact-behind-wait");
       behindTries += 1;
       behindSnapshot = result.error?.behindSnapshot;
-      await waitForCompactSource(options.history, pool2, behindTries === 1 ? behindSnapshot?.slot : void 0, behindDelay);
+      behindPage = await waitForCompactSource(options.history, pool2, behindTries === 1 ? behindSnapshot?.slot : void 0, behindDelay);
       continue;
     }
     writeStderr(`history: the compact transition list was refused (${result.reason}${result.detail ? `; cause ${result.detail}` : ""}); walking the pool history instead
@@ -57131,7 +57354,7 @@ async function waitForCompactSource(source, pool2, slot3, budgetMs) {
   const until = Date.now() + budgetMs;
   for (; ; ) {
     const abort = new AbortController();
-    const params = [pool2, { commitment: "finalized", fromOrdinal: 0, toOrdinal: 1, minContextSlot: slot3 }];
+    const params = [pool2, { commitment: "finalized", fromOrdinal: 0, toOrdinal: P03_COMPACT_PAGE, minContextSlot: slot3 }];
     const read = (typeof source.abortableRpcRequest === "function" ? source.abortableRpcRequest("getP03Transitions", params, abort.signal) : source._rpcRequest("getP03Transitions", params)).catch(() => ({ failed: true }));
     let timer;
     const answer = await Promise.race([read, new Promise((resolve38) => {
@@ -57141,7 +57364,7 @@ async function waitForCompactSource(source, pool2, slot3, budgetMs) {
     if (answer === void 0) abort.abort();
     if (answer?.result !== void 0) {
       markPhase("compact-behind-caught-up");
-      return void 0;
+      return isCompactPageZeroAnswer(answer, pool2) ? { response: answer } : void 0;
     }
     if (answer !== void 0 && answer?.error?.code !== -32016) return sleep5(Math.max(0, until - Date.now()));
     const left = until - Date.now();
@@ -57198,7 +57421,7 @@ function reportHistoryRpc(split5, source, result, crossChecked) {
   writeStderr(`history: ${who} answered ${list(split5.history)}; your own RPC answered ${list(split5.own)} (the pool account the history must match, and the cross-check)${window2}${integrity}
 `);
 }
-var strictScope, withStrictHistorySource, recentScope, withRecentWalletHistory, recentLoads, forgetRecentWalletHistory, historyCacheKey, HISTORY_PREWARM_JOIN_MS, prewarmedWalks, PREWARMED_REPORTS, isPrewarmedWalletHistory, COMPACT_BEHIND_POLL_MS, COMPACT_BEHIND_READ_MS, COMPACT_BEHIND_RETRY_MS, lastRunReports, writeStderr, announcedSources;
+var strictScope, withStrictHistorySource, recentScope, withRecentWalletHistory, recentLoads, forgetRecentWalletHistory, historyCacheKey, HISTORY_PREWARM_JOIN_MS, SUBTREE_LEAVES4, prewarmedWalks, PREWARMED_REPORTS, PAYMENT_TAKEN_REPORTS, isPrewarmedWalletHistory, COMPACT_BEHIND_POLL_MS, COMPACT_BEHIND_READ_MS, COMPACT_BEHIND_RETRY_MS, lastRunReports, writeStderr, announcedSources;
 var init_walletHistory = __esm({
   "wallet/src/history/walletHistory.mjs"() {
     "use strict";
@@ -57220,8 +57443,10 @@ var init_walletHistory = __esm({
     };
     historyCacheKey = (store) => createHmac5("sha256", Buffer.from(store.state.seedHex, "hex")).update("carbon-shielded-wallet/history-cache-key/v1").digest("hex");
     HISTORY_PREWARM_JOIN_MS = 1e4;
+    SUBTREE_LEAVES4 = 128n;
     prewarmedWalks = /* @__PURE__ */ new Map();
     PREWARMED_REPORTS = /* @__PURE__ */ new WeakSet();
+    PAYMENT_TAKEN_REPORTS = /* @__PURE__ */ new WeakSet();
     isPrewarmedWalletHistory = (report) => report !== null && typeof report === "object" && PREWARMED_REPORTS.has(report);
     COMPACT_BEHIND_POLL_MS = 150;
     COMPACT_BEHIND_READ_MS = 1e3;
@@ -73681,8 +73906,8 @@ function bindLeavesToPool({ leaves, currentRoot, currentIndex, anchors }) {
   const root = leafField(currentRoot);
   if (root === void 0) return unbound("root missing");
   const index = typeof currentIndex === "bigint" ? currentIndex : Number.isSafeInteger(currentIndex) ? BigInt(currentIndex) : void 0;
-  if (index === void 0 || index < 0n || index % SUBTREE_LEAVES4 !== 0n) return unbound("index missing");
-  if (BigInt(leaves.length) * SUBTREE_LEAVES4 !== index) return unbound("leaf count mismatch");
+  if (index === void 0 || index < 0n || index % SUBTREE_LEAVES5 !== 0n) return unbound("index missing");
+  if (BigInt(leaves.length) * SUBTREE_LEAVES5 !== index) return unbound("leaf count mismatch");
   if (!Array.isArray(anchors)) return unbound("anchors missing");
   const parsed = [];
   for (const leaf of leaves) {
@@ -73695,7 +73920,7 @@ function bindLeavesToPool({ leaves, currentRoot, currentIndex, anchors }) {
   for (const anchor of anchors) {
     const anchorIndex = typeof anchor?.index === "bigint" ? anchor.index : void 0;
     const anchorRoot = leafField(anchor?.root);
-    if (anchorIndex === void 0 || anchorRoot === void 0 || anchorIndex < 0n || anchorIndex % SUBTREE_LEAVES4 !== 0n || anchorIndex / SUBTREE_LEAVES4 >= BigInt(roots.length) || roots[Number(anchorIndex / SUBTREE_LEAVES4)] !== anchorRoot) return unbound("anchor mismatch");
+    if (anchorIndex === void 0 || anchorRoot === void 0 || anchorIndex < 0n || anchorIndex % SUBTREE_LEAVES5 !== 0n || anchorIndex / SUBTREE_LEAVES5 >= BigInt(roots.length) || roots[Number(anchorIndex / SUBTREE_LEAVES5)] !== anchorRoot) return unbound("anchor mismatch");
   }
   return Object.freeze({ bound: true, leaves: Object.freeze(parsed) });
 }
@@ -73706,14 +73931,14 @@ function ownLeafStatus({ outCommitment, leaves, currentRoot, currentIndex, ancho
   if (!binding.bound) return Object.freeze({ status: "unknown", reason: binding.reason });
   return Object.freeze({ status: binding.leaves.includes(own) ? "landed" : "absent" });
 }
-var FIELD_MODULUS8, SUBTREE_LEAVES4, LOCAL_DEPTH3, OUTER_DEPTH3, hash6, zeroRootsMemo2, lastFold2, unbound;
+var FIELD_MODULUS8, SUBTREE_LEAVES5, LOCAL_DEPTH3, OUTER_DEPTH3, hash6, zeroRootsMemo2, lastFold2, unbound;
 var init_leafBinding = __esm({
   "wallet/src/history/leafBinding.mjs"() {
     "use strict";
     init_reference2();
     init_recoveryPath();
     FIELD_MODULUS8 = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
-    SUBTREE_LEAVES4 = 128n;
+    SUBTREE_LEAVES5 = 128n;
     LOCAL_DEPTH3 = 7;
     OUTER_DEPTH3 = 41;
     hash6 = (left, right) => poseidon2([left, right], 3);
@@ -93587,6 +93812,7 @@ async function payResourceOnce({
     }
   };
   let priorHistory;
+  let submitClockRead;
   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;
@@ -93748,6 +93974,7 @@ async function payResourceOnce({
         store.writeWal(walName2, record);
       }
       mark("prove-start");
+      submitClockRead = startFinalizedChainTime(connection);
       let prepared;
       try {
         prepared = await withPhaseScope(mark, "prove", () => (deps.prepare ?? prepareRecoveredPayment)({
@@ -93832,8 +94059,20 @@ async function payResourceOnce({
   if (hash9(record.paymentHeader) !== record.headerSha256) fail19("wal_header_mismatch");
   if (record.state !== "submitted") {
     const required = record.paymentRequired.accepts.find((entry) => entry.scheme === "shielded-exact");
-    const time = await readFinalizedClock(connection);
-    if (!Number.isSafeInteger(time) || time >= Number(required.extra.validBefore)) fail19("quote_expired_before_submission");
+    const validBefore = Number(required.extra.validBefore);
+    let time;
+    try {
+      time = submitClockRead === void 0 ? void 0 : await submitClockRead();
+    } catch {
+      time = void 0;
+    }
+    submitClockRead = void 0;
+    if (Number.isSafeInteger(time) && time + SUBMIT_CLOCK_MARGIN_SECONDS < validBefore) mark("submit-clock-early");
+    else {
+      time = await readFinalizedClock(connection);
+      mark("submit-clock-fresh");
+    }
+    if (!Number.isSafeInteger(time) || time >= validBefore) fail19("quote_expired_before_submission");
     mark("submit-clock");
     await assertRefusedPaymentsCannotLand({
       store,
@@ -93911,7 +94150,7 @@ async function payResourceOnce({
   withPhaseScope(mark, "anchor-next", () => requestSubAnchorForNewLeaf());
   return { replayed: false, receipt, resultBase64, receiptFinality: "pending" };
 }
-var import_web3111, fail19, failUnresolved, hash9, OWNER_UNSHIELD_REQUEST, OWNER_UNSHIELD_ORIGIN, POCKET_FILL_ID, POOL_MOVE_PATH, RECEIPT_FINALITY_TIMEOUT_MS, RECEIPT_FINALITY_POLL_MS, FINALITY_GATE_MARGIN_SLOTS, FINALITY_GATE_POLL_MS, FINALITY_GATE_SETTLE_MARGIN_SLOTS, FINALITY_GATE_SETTLE_WINDOW_SLOTS, receiptSettleSlot, FINALITY_GATE_SKIP_AFTER_MS, PENDING_FINALITY, isPending, REPLAY_INPUTS, PAYMENT_OUTPUT_INPUT2, QUOTE_MARGIN_SECONDS, SELLER_REFUSED_PAY_AGAIN, SELLER_REASON_FACILITATOR_UNDERFUNDED, ANCHOR_EPOCH_MS, ANCHOR_MARGIN_MS, ANCHOR_WAIT_CAP_MS, DEAD_PAYMENT_MARGIN_SECONDS, SYSVAR_OWNER, quoteLiveAt, replayValuesOf, finalPayments, FINAL_UNCHANGED;
+var import_web3111, fail19, failUnresolved, hash9, OWNER_UNSHIELD_REQUEST, OWNER_UNSHIELD_ORIGIN, POCKET_FILL_ID, POOL_MOVE_PATH, RECEIPT_FINALITY_TIMEOUT_MS, RECEIPT_FINALITY_POLL_MS, FINALITY_GATE_MARGIN_SLOTS, FINALITY_GATE_POLL_MS, FINALITY_GATE_SETTLE_MARGIN_SLOTS, FINALITY_GATE_SETTLE_WINDOW_SLOTS, receiptSettleSlot, FINALITY_GATE_SKIP_AFTER_MS, PENDING_FINALITY, isPending, REPLAY_INPUTS, PAYMENT_OUTPUT_INPUT2, QUOTE_MARGIN_SECONDS, SUBMIT_CLOCK_MARGIN_SECONDS, SELLER_REFUSED_PAY_AGAIN, SELLER_REASON_FACILITATOR_UNDERFUNDED, ANCHOR_EPOCH_MS, ANCHOR_MARGIN_MS, ANCHOR_WAIT_CAP_MS, DEAD_PAYMENT_MARGIN_SECONDS, SYSVAR_OWNER, quoteLiveAt, replayValuesOf, finalPayments, FINAL_UNCHANGED;
 var init_payResource = __esm({
   "wallet/src/pay/payResource.mjs"() {
     "use strict";
@@ -93964,6 +94203,7 @@ var init_payResource = __esm({
     REPLAY_INPUTS = [3, 10, 11, 12, 7];
     PAYMENT_OUTPUT_INPUT2 = 4;
     QUOTE_MARGIN_SECONDS = 120;
+    SUBMIT_CLOCK_MARGIN_SECONDS = 30;
     SELLER_REFUSED_PAY_AGAIN = "payment_refused_pay_again";
     SELLER_REASON_FACILITATOR_UNDERFUNDED = "facilitator_underfunded";
     ANCHOR_EPOCH_MS = 3e5;
@@ -97397,13 +97637,40 @@ function createAnchorReader({ connection, profile }) {
   const program = new import_web3120.PublicKey(profile.programId);
   const pool2 = new import_web3120.PublicKey(profile.pool);
   const programData = import_web3120.PublicKey.findProgramAddressSync([program.toBuffer()], LOADER2)[0];
-  return async ({ requireCapacity = false } = {}) => {
+  const headerKey = `${programData.toBase58()}:${profile.programDataSha256}`;
+  const headerSlice = { offset: 0, length: PROGRAM_DATA_HEADER_BYTES };
+  const accountChecks = (poolInfo, clock2, programInfo, code) => !poolInfo?.owner.equals(program) || poolInfo.executable || !clock2 || clock2.data.length < 40 || !programInfo?.owner.equals(LOADER2) || !programInfo.executable || !code?.owner.equals(LOADER2) || code.executable || code.data.length < PROGRAM_DATA_HEADER_BYTES || programInfo.data.length !== 36 || programInfo.data.readUInt32LE(0) !== 2 || !programInfo.data.subarray(4).equals(programData.toBuffer()) || code.data.readUInt32LE(0) !== 3;
+  const readFull = async () => {
     const snapshot = await connection.getMultipleAccountsInfoAndContext(
       [pool2, import_web3120.SYSVAR_CLOCK_PUBKEY, program, programData],
       { commitment: "finalized" }
     );
     const [poolInfo, clock2, programInfo, code] = snapshot.value;
-    if (!poolInfo?.owner.equals(program) || poolInfo.executable || !clock2 || clock2.data.length < 40 || !programInfo?.owner.equals(LOADER2) || !programInfo.executable || !code?.owner.equals(LOADER2) || code.executable || code.data.length < 45 || programInfo.data.length !== 36 || programInfo.data.readUInt32LE(0) !== 2 || !programInfo.data.subarray(4).equals(programData.toBuffer()) || code.data.readUInt32LE(0) !== 3 || sha2(code.data) !== profile.programDataSha256) fail26("chain_pin_mismatch");
+    if (accountChecks(poolInfo, clock2, programInfo, code) || sha2(code.data) !== profile.programDataSha256) fail26("chain_pin_mismatch");
+    hashedProgramDataHeaders.set(headerKey, Buffer.from(code.data.subarray(0, PROGRAM_DATA_HEADER_BYTES)));
+    return { slot: snapshot.context.slot, poolInfo, clock: clock2 };
+  };
+  const readHeaderOnly = async (hashed) => {
+    const headerRead = (minContextSlot) => connection.getAccountInfoAndContext(
+      programData,
+      { commitment: "finalized", dataSlice: headerSlice, ...minContextSlot === void 0 ? {} : { minContextSlot } }
+    );
+    const [snapshot, firstHeader] = await Promise.all([
+      connection.getMultipleAccountsInfoAndContext([pool2, import_web3120.SYSVAR_CLOCK_PUBKEY, program], { commitment: "finalized" }),
+      headerRead()
+    ]);
+    const slot3 = snapshot.context.slot;
+    const header = firstHeader.context.slot >= slot3 ? firstHeader : await headerRead(slot3).catch(() => void 0);
+    if (!header || header.context.slot < slot3) return readFull();
+    const [poolInfo, clock2, programInfo] = snapshot.value;
+    const code = header.value;
+    if (accountChecks(poolInfo, clock2, programInfo, code) || code.data.length !== PROGRAM_DATA_HEADER_BYTES) fail26("chain_pin_mismatch");
+    if (!code.data.equals(hashed) || code.data.readBigUInt64LE(4) > BigInt(slot3)) return readFull();
+    return { slot: slot3, poolInfo, clock: clock2 };
+  };
+  return async ({ requireCapacity = false } = {}) => {
+    const hashed = hashedProgramDataHeaders.get(headerKey);
+    const { slot: slot3, poolInfo, clock: clock2 } = hashed && typeof connection.getAccountInfoAndContext === "function" ? await readHeaderOnly(hashed) : await readFull();
     const state = parseSolanaP03PoolState(poolInfo.data);
     if (!state.initialized || state.decimals !== profile.decimals || new import_web3120.PublicKey(state.mint).toBase58() !== profile.mint || bigint(state.poolDomain) !== BigInt(profile.poolDomain)) fail26("pool_identity_mismatch");
     if (requireCapacity && (state.terminal || state.paymentCount >= state.policy.maxPayments)) fail26("pool_not_ready");
@@ -97416,7 +97683,7 @@ function createAnchorReader({ connection, profile }) {
     return {
       ...selected,
       chainTimestamp,
-      finalizedSlot: snapshot.context.slot,
+      finalizedSlot: slot3,
       retainedAnchors: anchors.filter((a) => a !== selected)
     };
   };
@@ -97508,7 +97775,21 @@ async function createSellerAdapter({
     sharedXOf,
     log: (line) => console.error(line)
   });
-  const readChainAnchor = createAnchorReader({ connection: memoizeFinalizedReads(connection), profile });
+  const readPinnedAnchor = createAnchorReader({ connection: memoizeFinalizedReads(connection), profile });
+  let lastAnchorRead;
+  const readChainAnchor = async (options) => {
+    const startedAt = Date.now();
+    const chain = await readPinnedAnchor(options);
+    if (!lastAnchorRead || startedAt >= lastAnchorRead.startedAt) lastAnchorRead = { chain, startedAt };
+    return chain;
+  };
+  const recentAnchorEvidence = () => {
+    if (!lastAnchorRead) return void 0;
+    const ageMs = Date.now() - lastAnchorRead.startedAt;
+    if (!(ageMs >= 0 && ageMs <= INTAKE_REUSE_MAX_AGE_MS)) return void 0;
+    const { chain } = lastAnchorRead;
+    return { ...chain, chainTimestamp: chain.chainTimestamp + BigInt(Math.ceil(ageMs / 1e3)) + 1n };
+  };
   let anchorRequest;
   const requestFacilitatorAnchor = () => anchorRequest ??= (async () => {
     const response = await fetchImpl(`${config.facilitatorBaseUrl}/anchor`, {
@@ -97554,12 +97835,12 @@ async function createSellerAdapter({
       await sleep5(ANCHOR_POLL_MS);
     }
   };
-  const issuer = (resource, amount) => new ShieldedSolanaP03QuoteIssuer({
+  const issuer = (resource, amount, readCurrentQuoteAnchor = readAnchor) => new ShieldedSolanaP03QuoteIssuer({
     ...profile,
     resource,
     amount,
     randomBytes: randomBytes17,
-    readCurrentQuoteAnchor: readAnchor
+    readCurrentQuoteAnchor
   });
   for (const route of config.routes) issuer(route.resource, route.amountAtomic);
   if (existsSync(config.storePath)) {
@@ -97887,10 +98168,11 @@ async function createSellerAdapter({
     await put(nonce, renewed);
     return renewed;
   }
-  async function acceptPayment(route, body, header2) {
+  async function acceptPayment(route, body, header2, arrivedAt) {
     const payment = decodePayment(header2);
     const nonce = payment.accepted?.extra?.resourceNonce;
     const mark = timing.start();
+    if (Number.isFinite(arrivedAt) && arrivedAt <= Date.now()) mark("http-arrival", void 0, arrivedAt);
     const original = state.offers[nonce];
     if (!original || original.method !== route.method || original.url !== route.resource.url || original.bodyDigest !== `0x${sha2(body)}` || canonical4(payment.accepted) !== canonical4(original.paymentRequired.accepts[0]) || canonical4(payment.resource) !== canonical4(original.paymentRequired.resource)) fail26("offer_binding_mismatch");
     if (original.paymentHeader && original.paymentHeader !== header2) fail26("payment_retry_mismatch");
@@ -97910,9 +98192,14 @@ async function createSellerAdapter({
     try {
       if (!offer.outboundJson) {
         const parsed = parseSolanaP03HttpPaymentPayload(payment.payload);
-        const quoteIssuer = issuer(offer.resource, payment.accepted.amount);
         const authInput = { requirements: payment.accepted, resource: payment.resource, publicInput7: parsed.publicInputs[7] };
-        await quoteIssuer.authenticateForClaim(authInput);
+        const recent = recentAnchorEvidence();
+        const early = recent === void 0 ? void 0 : await issuer(offer.resource, payment.accepted.amount, async () => recent).authenticate(authInput).catch(() => void 0);
+        let intakeRead;
+        const quoteIssuer = issuer(offer.resource, payment.accepted.amount, () => intakeRead);
+        if (early === void 0) await quoteIssuer.authenticateForClaim(authInput);
+        intakeRead = readAnchor();
+        intakeRead.catch(() => void 0);
         const authenticated = quoteIssuer.authenticate(authInput);
         authenticated.catch(() => void 0);
         const owned = { keys: [], done: false, cancel: void 0 };
@@ -97933,12 +98220,10 @@ async function createSellerAdapter({
           });
         }
         let recoveredNote;
-        let intakeRead;
         try {
-          const auth = await authenticated;
+          const auth = early ?? await authenticated;
+          if (early !== void 0) mark("intake-reused-read");
           mark("intake-authenticated");
-          intakeRead = readAnchor();
-          intakeRead.catch(() => void 0);
           if (precomputed !== void 0) {
             let timer;
             await Promise.race([precomputed, new Promise((resolveWait) => {
@@ -97946,13 +98231,19 @@ async function createSellerAdapter({
             })]);
             clearTimeout(timer);
           }
-          recoveredNote = await scanner.recoverMerchantNoteYielding({ parsed, authenticatedQuote: auth });
+          try {
+            recoveredNote = await scanner.recoverMerchantNoteYielding({ parsed, authenticatedQuote: auth });
+          } catch (error) {
+            await authenticated;
+            throw error;
+          }
         } finally {
           owned.done = true;
           owned.cancel?.();
           for (const key of owned.keys) sharedXByPoint.delete(key);
         }
         mark("intake-note-recovered");
+        await authenticated;
         const chain = await intakeRead;
         intakeChain = chain;
         mark("intake-anchor-read");
@@ -98061,12 +98352,12 @@ async function createSellerAdapter({
     if (!route || origin === void 0 || origin === config.publicOrigin || !(config.aliasOrigins ?? []).includes(origin)) return route;
     return { ...route, resource: { ...route.resource, url: `${origin}${route.path}` } };
   };
-  async function handleUnlocked({ method, path, body, paymentHeader, origin }) {
+  async function handleUnlocked({ method, path, body, paymentHeader, origin, arrivedAt }) {
     const route = resourceAt(config.routes.find((candidate) => candidate.method === method && candidate.path === path), origin);
     if (paymentHeader !== void 0) return acceptPayment(route ?? {
       method,
       resource: { url: `${(config.aliasOrigins ?? []).includes(origin) ? origin : config.publicOrigin}${path}` }
-    }, body, paymentHeader);
+    }, body, paymentHeader, arrivedAt);
     if (!route) return { status: 404, code: "resource_not_found" };
     const result = route.resultFor ? await route.resultFor(body) : route.result;
     if (route.resultFor && (result?.status !== 200 || typeof result.contentType !== "string" || typeof result.bodyBase64 !== "string")) fail26("route_result_invalid");
@@ -98182,7 +98473,7 @@ async function createSellerAdapter({
   }));
   return { server, handle, close, signerPublicKey, settledTransactions, offerSummaries };
 }
-var import_web3120, BINDING, SCHEMA2, OFFERS_LAYOUT, SNAPSHOT_EVERY_MS, LOADER2, canonical4, storeProfileIdentity, jsonSafe, bigint, encodeHeader, PAYMENT_REFUSED, FACILITATOR_UNDERFUNDED, DEFINITE_VERIFY_REFUSALS, definiteVerifyRefusal, refusedBeforeSettlement, ANCHOR_REQUEST_TIMEOUT_MS2, ANCHOR_POLL_ATTEMPTS, ANCHOR_POLL_MS, MEMO_PRECOMPUTES_MAX, MEMO_PRECOMPUTE_WAIT_MS, PRE_SETTLE_REUSE_MARGIN_S, PRE_SETTLE_REUSE_MAX_AGE_MS, FINALIZED_MEMO_MAX_AGE_MS, pause, FOLLOW_UP_DELAYS_MS, FOLLOW_UP_RESETTLE_FROM, CONFIRMED_TRANSACTION_READ;
+var import_web3120, BINDING, SCHEMA2, OFFERS_LAYOUT, SNAPSHOT_EVERY_MS, LOADER2, canonical4, storeProfileIdentity, jsonSafe, bigint, encodeHeader, PROGRAM_DATA_HEADER_BYTES, hashedProgramDataHeaders, PAYMENT_REFUSED, FACILITATOR_UNDERFUNDED, DEFINITE_VERIFY_REFUSALS, definiteVerifyRefusal, refusedBeforeSettlement, ANCHOR_REQUEST_TIMEOUT_MS2, ANCHOR_POLL_ATTEMPTS, ANCHOR_POLL_MS, MEMO_PRECOMPUTES_MAX, MEMO_PRECOMPUTE_WAIT_MS, PRE_SETTLE_REUSE_MARGIN_S, PRE_SETTLE_REUSE_MAX_AGE_MS, FINALIZED_MEMO_MAX_AGE_MS, INTAKE_REUSE_MAX_AGE_MS, pause, FOLLOW_UP_DELAYS_MS, FOLLOW_UP_RESETTLE_FROM, CONFIRMED_TRANSACTION_READ;
 var init_service = __esm({
   "wallet/src/seller/service.mjs"() {
     "use strict";
@@ -98214,6 +98505,8 @@ var init_service = __esm({
     jsonSafe = (v) => JSON.parse(JSON.stringify(v, (_, item) => typeof item === "bigint" ? item.toString() : item));
     bigint = (bytes2) => BigInt(`0x${Buffer.from(bytes2).toString("hex")}`);
     encodeHeader = (v) => Buffer.from(JSON.stringify(v)).toString("base64");
+    PROGRAM_DATA_HEADER_BYTES = 45;
+    hashedProgramDataHeaders = /* @__PURE__ */ new Map();
     PAYMENT_REFUSED = "payment_refused_pay_again";
     FACILITATOR_UNDERFUNDED = "facilitator_underfunded";
     DEFINITE_VERIFY_REFUSALS = /* @__PURE__ */ new Set([
@@ -98239,6 +98532,7 @@ var init_service = __esm({
     PRE_SETTLE_REUSE_MARGIN_S = 60;
     PRE_SETTLE_REUSE_MAX_AGE_MS = 2e4;
     FINALIZED_MEMO_MAX_AGE_MS = 1e3;
+    INTAKE_REUSE_MAX_AGE_MS = 1e4;
     pause = (ms) => new Promise((resolve38) => setTimeout(resolve38, ms));
     FOLLOW_UP_DELAYS_MS = Object.freeze([
       15e3,
@@ -114159,13 +114453,13 @@ function upperZeroRoots() {
 function subtreeBit(subtreeCount, level) {
   return BigInt(subtreeCount) >> BigInt(level) & 1n;
 }
-var SUBTREE_DEPTH, SUBTREE_LEAVES5, TREE_DEPTH4, UPPER_LEVELS, EPOCH_SECONDS2, zeroLeaf, cachedZeroRoots, TreeFrontier, DEFAULT_START_TIME;
+var SUBTREE_DEPTH, SUBTREE_LEAVES6, TREE_DEPTH4, UPPER_LEVELS, EPOCH_SECONDS2, zeroLeaf, cachedZeroRoots, TreeFrontier, DEFAULT_START_TIME;
 var init_multipool_model = __esm({
   "wallet/vendor/shielded-x402-model/src/multipool-model.mjs"() {
     "use strict";
     init_reference2();
     SUBTREE_DEPTH = 7;
-    SUBTREE_LEAVES5 = 128;
+    SUBTREE_LEAVES6 = 128;
     TREE_DEPTH4 = 48;
     UPPER_LEVELS = TREE_DEPTH4 - SUBTREE_DEPTH;
     EPOCH_SECONDS2 = 300n;
@@ -114180,23 +114474,23 @@ var init_multipool_model = __esm({
         this.root = _TreeFrontier.rootFromRecord(this.record());
       }
       get index() {
-        return Number(this.subtreeCount) * SUBTREE_LEAVES5;
+        return Number(this.subtreeCount) * SUBTREE_LEAVES6;
       }
       record() {
         const zero = upperZeroRoots();
         return {
-          index: Number(this.subtreeCount) * SUBTREE_LEAVES5,
+          index: Number(this.subtreeCount) * SUBTREE_LEAVES6,
           root: this.root === void 0 ? void 0 : this.root.toString(),
           frontierNodes: this.filled.map((node3, level) => (subtreeBit(this.subtreeCount, level) === 1n ? node3 : zero[level]).toString())
         };
       }
       static rootFromRecord({ index, frontierNodes }) {
-        if (index % SUBTREE_LEAVES5 !== 0) throw new Error("frontier_index_misaligned");
+        if (index % SUBTREE_LEAVES6 !== 0) throw new Error("frontier_index_misaligned");
         if (frontierNodes && frontierNodes.length !== UPPER_LEVELS) {
           throw new Error("frontier_record_width");
         }
         const zero = upperZeroRoots();
-        const subtreeCount = BigInt(index / SUBTREE_LEAVES5);
+        const subtreeCount = BigInt(index / SUBTREE_LEAVES6);
         let accumulator = zero[0];
         for (let level = 0; level < UPPER_LEVELS; level += 1) {
           accumulator = subtreeBit(subtreeCount, level) === 1n ? poseidon2([BigInt(frontierNodes[level]), accumulator], 3) : poseidon2([accumulator, zero[level]], 3);
@@ -114241,7 +114535,7 @@ __export(pool_exports, {
   EMPTY_ROOT: () => EMPTY_ROOT,
   JUBJUB_G: () => JUBJUB_G,
   PoolTree: () => PoolTree,
-  SUBTREE_LEAVES: () => SUBTREE_LEAVES6,
+  SUBTREE_LEAVES: () => SUBTREE_LEAVES7,
   ZERO_LEAF: () => ZERO_LEAF,
   account: () => account,
   accountNullifier: () => accountNullifier2,
@@ -114269,8 +114563,8 @@ function account(w, i, b) {
   return { d: w.d, pDX: w.pDX, i, b, commitment };
 }
 function subtree(slot3, commitment) {
-  if (!Number.isInteger(slot3) || slot3 < 0 || slot3 >= SUBTREE_LEAVES6) throw new Error("slot must be in [0, 128)");
-  const leaves = Array(SUBTREE_LEAVES6).fill(ZERO_LEAF);
+  if (!Number.isInteger(slot3) || slot3 < 0 || slot3 >= SUBTREE_LEAVES7) throw new Error("slot must be in [0, 128)");
+  const leaves = Array(SUBTREE_LEAVES7).fill(ZERO_LEAF);
   leaves[slot3] = commitment;
   const levels = merkleLevels2(leaves);
   const siblings = [];
@@ -114291,7 +114585,7 @@ function accountNullifier2(a, eta, position3) {
 function dummyNoteNullifier(poolDomain, nullifier, eta, slot3) {
   return sponge2([DOMAINS.dummyNoteNullifierV2, poolDomain, nullifier, eta, BigInt(slot3)]);
 }
-var HERE, VECTORS, big, DOMAINS, JUBJUB_G, ZERO_LEAF, SUBTREE_LEAVES6, EMPTY_ROOT, PoolTree;
+var HERE, VECTORS, big, DOMAINS, JUBJUB_G, ZERO_LEAF, SUBTREE_LEAVES7, EMPTY_ROOT, PoolTree;
 var init_pool = __esm({
   "packages/ctvault-v0b/src/pool.ts"() {
     "use strict";
@@ -114305,7 +114599,7 @@ var init_pool = __esm({
     JUBJUB_G = { x: big(VECTORS.payerKeys.generator.x), y: big(VECTORS.payerKeys.generator.y) };
     ZERO_LEAF = poseidon2([DOMAINS.note, 0n, 0n, 0n, 0n], 6);
     if (ZERO_LEAF.toString() !== VECTORS.zeroLeaf) throw new Error("zero leaf drifts from the Rust vectors");
-    SUBTREE_LEAVES6 = 128;
+    SUBTREE_LEAVES7 = 128;
     EMPTY_ROOT = upperZeroRoots()[UPPER_LEVELS];
     PoolTree = class {
       frontier = new TreeFrontier();
@@ -114347,7 +114641,7 @@ var init_pool = __esm({
         if (subtreeIndex >= n) throw new Error("the leaf is not in that root");
         const st = this.subtrees[subtreeIndex];
         const up = this.upper(n, subtreeIndex);
-        return { leafIndex: BigInt(subtreeIndex * SUBTREE_LEAVES6 + st.slot), siblings: [...st.siblings, ...up.siblings], root: up.root };
+        return { leafIndex: BigInt(subtreeIndex * SUBTREE_LEAVES7 + st.slot), siblings: [...st.siblings, ...up.siblings], root: up.root };
       }
       upper(n, index) {
         const zero = upperZeroRoots();
@@ -121272,6 +121566,23 @@ function provenInputs(proofRecord) {
   }
   return commitments;
 }
+var PROOF_RECORD = "resource-proof-";
+function lazyProofEntry(store, name) {
+  let loaded = false;
+  let record;
+  const read = () => {
+    if (!loaded) {
+      record = store.readWal(name);
+      loaded = true;
+    }
+    return record;
+  };
+  return { name, type: "payment-proof", phase: "part", get record() {
+    return read();
+  }, get state() {
+    return String(read()?.state);
+  } };
+}
 function classify(name, record) {
   const state = String(record?.state);
   if (name.startsWith("deposit-") && record?.schema === DEPOSIT_WAL_SCHEMA) {
@@ -121282,7 +121593,7 @@ function classify(name, record) {
     const phase = state === "receipt" && record?.receiptFinality === "never-finalized" ? "void" : { quoted: "in-flight", ready: "in-flight", submitted: "in-flight", receipt: "done", cancelled: "void" }[state] ?? "other";
     return { type: "payment", phase, state };
   }
-  if (name.startsWith("resource-proof-")) return { type: "payment-proof", phase: "part", state };
+  if (name.startsWith(PROOF_RECORD)) return { type: "payment-proof", phase: "part", state };
   if (name.startsWith("self-pay-") && record?.schema === SELF_PAY_WAL_SCHEMA) {
     const phase = { started: "in-flight", paid: "in-flight", exited: "done", merged: "done", released: "void", abandoned: "void" }[state] ?? "other";
     return { type: "unshield", phase, state };
@@ -121309,13 +121620,23 @@ function publicUrl(value) {
     return null;
   }
 }
-function computeBalance({ store, snapshotRead, source = "local", now = Date.now(), firstDepositEstimate = false }) {
+function computeBalance({ store, snapshotRead, source = "local", now = Date.now(), firstDepositEstimate = false, onPhase }) {
+  const mark = (phase, outcome) => {
+    try {
+      onPhase?.(phase, outcome);
+    } catch {
+    }
+  };
   const state = store.state;
   const decimals = Number(state.decimals);
-  const records = store.listWal().sort().map((name) => {
+  const names = store.listWal().sort();
+  mark("bal-wal-list", "n" + names.length);
+  const records = names.map((name) => {
+    if (name.startsWith(PROOF_RECORD)) return lazyProofEntry(store, name);
     const record = store.readWal(name);
     return { name, record, ...classify(name, record) };
   });
+  mark("bal-wal-read", "n" + records.length);
   const byName = new Map(records.map((entry) => [entry.name, entry]));
   const reasons = [];
   const pendingDeposits = records.filter((entry) => entry.type === "deposit" && entry.phase !== "done" && entry.phase !== "void").map((entry) => ({
@@ -121363,6 +121684,7 @@ function computeBalance({ store, snapshotRead, source = "local", now = Date.now(
   } catch {
     pockets = void 0;
   }
+  mark("bal-pockets");
   detail.pockets = pockets ?? null;
   const report = (status, atomic3, next2) => ({
     // The one number: shielded + pockets. Null when either part is unknown.
@@ -121435,7 +121757,7 @@ function computeBalance({ store, snapshotRead, source = "local", now = Date.now(
   };
   for (const entry of records) {
     const before = Object.hasOwn(snapshot.walStates, entry.name) ? snapshot.walStates[entry.name] : void 0;
-    const beforePhase = before === void 0 ? "absent" : classify(entry.name, { ...entry.record, state: before }).phase;
+    const beforePhase = before === void 0 ? "absent" : entry.type === "payment-proof" ? entry.phase : classify(entry.name, { ...entry.record, state: before }).phase;
     if (entry.phase === "done" && beforePhase !== "done") {
       const paying = settlingPayment(entry);
       if (paying) {
@@ -127340,8 +127662,10 @@ async function refreshWallet({ session, store, history: walked, share }) {
   prepareFinalizedP03RecoveryFold(history).catch(() => {
   });
 }
-function shieldedUnknown(store) {
-  return computeBalance({ store, snapshotRead: readBalanceSnapshot(store), source: "local" }).split?.shieldedAtomic == null;
+function shieldedUnknown(store, onPhase) {
+  const snapshotRead = readBalanceSnapshot(store);
+  onPhase?.("bal-snapshot");
+  return computeBalance({ store, snapshotRead, source: "local", onPhase }).split?.shieldedAtomic == null;
 }
 var AUTO_BACKUPS_KEPT = 5;
 var AUTO_BACKUP_NAME = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z(-\d+)?$/;
@@ -127516,9 +127840,13 @@ function localBalance(session) {
     return null;
   }
 }
-function localBalanceOf(store) {
+function localBalanceOf(store, onPhase) {
   try {
-    return oneBalance(computeBalance({ store, snapshotRead: readBalanceSnapshot(store), source: "local" }), store);
+    const snapshotRead = readBalanceSnapshot(store);
+    onPhase?.("bal-snapshot");
+    const report = computeBalance({ store, snapshotRead, source: "local", onPhase });
+    onPhase?.("bal-computed");
+    return oneBalance(report, store);
   } catch {
     return null;
   }
@@ -127872,7 +128200,9 @@ function createWalletTools({
   }) {
     let stale;
     try {
-      stale = shieldedUnknown(session.openStore());
+      const store = session.openStore();
+      onPhase("mcp-stale-open");
+      stale = shieldedUnknown(store, (phase, outcome) => onPhase(`gate:${phase}`, outcome));
     } catch {
       return;
     } finally {
@@ -128066,7 +128396,7 @@ function createWalletTools({
         return json({ ...early, ...one2 ? { balanceAtomic: one2.balanceAtomic, balance: one2.balance, breakdown: { ...one2.breakdown, ...early.breakdown ?? {} } } : {} });
       }
       gateTimes.push(["mcp-pockets", Date.now()]);
-      await refreshIfStale((phase) => gateTimes.push([phase, Date.now()]));
+      await refreshIfStale((phase, outcome) => gateTimes.push([phase, Date.now(), outcome]));
       gateTimes.push(["mcp-refresh", Date.now()]);
       const switched = await switchGate(cap.maxPaymentAtomic, requestId, "x402_pay");
       if (switched) return switched;
@@ -128076,13 +128406,13 @@ function createWalletTools({
       } catch {
         timing = void 0;
       }
-      const mark = (phase, at) => {
+      const mark = (phase, at, outcome) => {
         try {
-          timing?.(phase, void 0, at);
+          timing?.(phase, outcome, at);
         } catch {
         }
       };
-      for (const [phase, at] of gateTimes) mark(phase, at);
+      for (const [phase, at, outcome] of gateTimes) mark(phase, at, outcome);
       mark("mcp-gates");
       const payOnce = async () => {
         const end = autoPockets.paymentStart();
@@ -128149,15 +128479,18 @@ function createWalletTools({
       } catch {
         paidStore = void 0;
       }
+      mark("mcp-result-open");
       let float;
       try {
         float = paidStore ? floatRecordOf(paidStore, requestId) : void 0;
       } catch {
         float = void 0;
       }
+      mark("mcp-result-float");
       const floatPaid = float?.state === "receipt";
       const amounts = floatPaid ? { priceAtomic: float.priceAtomic, feeAtomic: float.feeAtomic, amountAtomic: float.paidAtomic } : { priceAtomic: receipt.amountAtomic ?? null, feeAtomic: "0", amountAtomic: receipt.amountAtomic ?? null };
-      const one = paidStore ? localBalanceOf(paidStore) : null;
+      const one = paidStore ? localBalanceOf(paidStore, (phase, outcome) => mark(`result:${phase}`, void 0, outcome)) : null;
+      mark("mcp-result-balance");
       if (receipt.replayed !== true) refreshAtFinality(floatPaid ? leg1SettleSlot(paidStore, float, requestId) : receipt.extra?.settleSlot);
       mark("mcp-result");
       return answerResult(paidAnswerContent({