shinjuku-shielded 0.3.34 → 0.3.36

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "b22ae0f772097b698eba694cfec8b31061921a38948c11702df3653881361e9f",
-  "bytes": 11185132,
-  "sourceCommit": "164420d7b29522db79b23d11ae14bc10ec26ce8f",
+  "sha256": "658897741c5d9bce482ff9d932f4ade7e51cf98f834e78c3f693da1e1771e547",
+  "bytes": 11193868,
+  "sourceCommit": "60ad77f63dbc238b88ee877a67ae54d30ebdbdfb",
   "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.34",
+  "version": "0.3.36",
   "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": "b22ae0f7",
-  "shinjukuSha256": "b22ae0f772097b698eba694cfec8b31061921a38948c11702df3653881361e9f",
+  "shinjukuRelease": "65889774",
+  "shinjukuSha256": "658897741c5d9bce482ff9d932f4ade7e51cf98f834e78c3f693da1e1771e547",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -18266,7 +18266,7 @@ var require_websocket = __commonJS({
     var http2 = __require("http");
     var net2 = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes30, createHash: createHash38 } = __require("crypto");
+    var { randomBytes: randomBytes30, createHash: createHash39 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL4 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -18934,7 +18934,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest2 = createHash38("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash39("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -19303,7 +19303,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http2 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash38 } = __require("crypto");
+    var { createHash: createHash39 } = __require("crypto");
     var extension3 = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -19610,7 +19610,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest2 = createHash38("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash39("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -49186,6 +49186,36 @@ var init_book = __esm({
   }
 });
 
+// wallet/src/fetch/keepAlive.mjs
+function proxiedRun() {
+  const env = process.env;
+  return Boolean(env.SHINJUKU_WALLET_PROXIED || env.NODE_USE_ENV_PROXY || env.HTTPS_PROXY || env.HTTP_PROXY || env.https_proxy || env.http_proxy);
+}
+function keepAliveDispatcher() {
+  if (shared !== void 0) return shared;
+  try {
+    if (proxiedRun()) return void 0;
+    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 });
+    return shared;
+  } catch {
+    return void 0;
+  }
+}
+function keepAliveInit(init = {}) {
+  const dispatcher = keepAliveDispatcher();
+  return dispatcher === void 0 ? init : { ...init, dispatcher };
+}
+var GLOBAL_DISPATCHER, KEEP_ALIVE_MS, shared;
+var init_keepAlive = __esm({
+  "wallet/src/fetch/keepAlive.mjs"() {
+    "use strict";
+    GLOBAL_DISPATCHER = /* @__PURE__ */ Symbol.for("undici.globalDispatcher.1");
+    KEEP_ALIVE_MS = 2e4;
+  }
+});
+
 // wallet/vendor/shielded-x402-model/src/reference.mjs
 import { dirname as dirname5, join as join6 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
@@ -49756,11 +49786,12 @@ var init_anchorClock = __esm({
 // wallet/src/chain.mjs
 import { createHash as createHash7, createPublicKey, randomInt, verify as verifySignature } from "node:crypto";
 function connect2(rpcUrl, commitment = "finalized", { timeoutMs } = {}) {
-  const fetch2 = timeoutMs === void 0 ? rpcFetch : async (input, init) => {
+  const pooled = (input, init) => rpcFetch(input, keepAliveInit(init));
+  const fetch2 = timeoutMs === void 0 ? pooled : async (input, init) => {
     const circuit = torCircuit();
     const timeout = AbortSignal.timeout(timeoutMs);
     try {
-      const response = await rpcFetch(input, { ...init, signal: init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout });
+      const response = await pooled(input, { ...init, signal: init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout });
       const body = await response.text();
       const headers = new Headers(response.headers);
       headers.delete("content-encoding");
@@ -49771,7 +49802,23 @@ function connect2(rpcUrl, commitment = "finalized", { timeoutMs } = {}) {
       throw error;
     }
   };
-  return countRpcCalls(new import_web395.Connection(rpcUrl, { commitment, fetch: fetch2, disableRetryOnRateLimit: true }));
+  const connection = countRpcCalls(new import_web395.Connection(rpcUrl, { commitment, fetch: fetch2, disableRetryOnRateLimit: true }));
+  let nextId = 0;
+  Object.defineProperty(connection, "abortableRpcRequest", {
+    value: async (method, params, signal) => {
+      const response = await fetch2(rpcUrl, {
+        method: "POST",
+        signal,
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: `abortable-${nextId += 1}`, method, params })
+      });
+      return response.json();
+    },
+    enumerable: false,
+    writable: false,
+    configurable: true
+  });
+  return connection;
 }
 function countRpcCalls(connection) {
   const counters = Object.fromEntries(COUNTED_RPC_METHODS.map((name) => [name, 0]));
@@ -50040,11 +50087,11 @@ function connectSplit(own, historyUrl, commitment = "finalized", { pause: pause3
     const now = Date.now();
     if (behindSince === void 0) {
       behindSince = now;
-      notice(strictAfterSlot === void 0 ? `history: the history source is behind the chain (JSON-RPC -32016: it has not reached the slot your own RPC read the pool account at); asking again after 0.5 s, 1 s, 2 s, then every 5 s, for at most ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s
-` : `history: the pool account changed after slot ${strictAfterSlot}, the newest slot the history source had reached (its history did not rebuild the pool account your own RPC reads); asking it again after 0.5 s, 1 s, 2 s, then every 5 s, for at most ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s
+      notice(strictAfterSlot === void 0 ? `history: the history source is behind the chain (JSON-RPC -32016: it has not reached the slot your own RPC read the pool account at); asking again every 0.15 s for about 2 s, then after 0.5 s, 1 s, 2 s, then every 5 s, for at most ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s
+` : `history: the pool account changed after slot ${strictAfterSlot}, the newest slot the history source had reached (its history did not rebuild the pool account your own RPC reads); asking it again every 0.15 s for about 2 s, then after 0.5 s, 1 s, 2 s, then every 5 s, for at most ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s
 `);
     }
-    const delay3 = HISTORY_RPC_BEHIND_RETRY_STEPS_MS[Math.min(behindWaits, HISTORY_RPC_BEHIND_RETRY_STEPS_MS.length - 1)];
+    const delay3 = behindWaits < HISTORY_RPC_BEHIND_FAST_TRIES ? HISTORY_RPC_BEHIND_FAST_MS : HISTORY_RPC_BEHIND_RETRY_STEPS_MS[Math.min(behindWaits - HISTORY_RPC_BEHIND_FAST_TRIES, HISTORY_RPC_BEHIND_RETRY_STEPS_MS.length - 1)];
     if (now - behindSince + delay3 > HISTORY_RPC_BEHIND_WAIT_MS) return false;
     behindWaits += 1;
     await pause3(delay3);
@@ -50571,13 +50618,14 @@ function depositIntentAddress2({ programId, pool: pool2, depositPublicInputBytes
     programId
   )[0];
 }
-var import_web395, POOL_STATE_LEN2, POOL_STATE_LEN_RING2, ANCHOR_MODE_RING2, ANCHOR_RING_SLOTS2, ANCHOR_RING_HEADER2, ANCHOR_RING_FIRST_SLOT2, ANCHOR_RING_SLOT_LEN2, POOL_STATE_LEN_V22, BUFFER_HEADER_LEN2, MEMO_BUNDLE_BYTES2, PAYLOAD_LENGTH2, PAYLOAD_LENGTH_V22, TRANSITION_KIND2, INSTRUCTION2, COUNTED_RPC_METHODS, HISTORY_RPC_METHODS, PINNED_HISTORY_PROXIES, PINNED_HISTORY_HTTPS, HISTORY_RPC_OWN, historyRpcErrors, HISTORY_RPC_BEHIND_WAIT_MS, HISTORY_RPC_REQUEST_TIMEOUT_MS, HISTORY_RPC_BEHIND_RETRY_STEPS_MS, HISTORY_RPC_BEHIND_CODE, ED25519_SPKI_PREFIX, SIGNATURE_BYTES, VERSION_1_PREFIX, HISTORY_CROSS_CHECK_COUNT, runTransactions, warmedSources, bytes323, MEMO_BATCH_MAX, MEMO_ATTEMPTS, MEMO_MAX_WAIT_SECONDS, MEMO_ANSWER_TIMEOUT_MS, MEMO_BODY_TIMEOUT_MS, pauseFor, noticeOnStderr, memoDigestHex, memoFailureText, prefetchedMemosByFetch, MEMO_PREFETCH_LIFE_MS;
+var import_web395, POOL_STATE_LEN2, POOL_STATE_LEN_RING2, ANCHOR_MODE_RING2, ANCHOR_RING_SLOTS2, ANCHOR_RING_HEADER2, ANCHOR_RING_FIRST_SLOT2, ANCHOR_RING_SLOT_LEN2, POOL_STATE_LEN_V22, BUFFER_HEADER_LEN2, MEMO_BUNDLE_BYTES2, PAYLOAD_LENGTH2, PAYLOAD_LENGTH_V22, TRANSITION_KIND2, INSTRUCTION2, COUNTED_RPC_METHODS, HISTORY_RPC_METHODS, PINNED_HISTORY_PROXIES, PINNED_HISTORY_HTTPS, HISTORY_RPC_OWN, historyRpcErrors, HISTORY_RPC_BEHIND_WAIT_MS, HISTORY_RPC_REQUEST_TIMEOUT_MS, HISTORY_RPC_BEHIND_FAST_MS, HISTORY_RPC_BEHIND_FAST_TRIES, HISTORY_RPC_BEHIND_RETRY_STEPS_MS, HISTORY_RPC_BEHIND_CODE, ED25519_SPKI_PREFIX, SIGNATURE_BYTES, VERSION_1_PREFIX, HISTORY_CROSS_CHECK_COUNT, runTransactions, warmedSources, bytes323, MEMO_BATCH_MAX, MEMO_ATTEMPTS, MEMO_MAX_WAIT_SECONDS, MEMO_ANSWER_TIMEOUT_MS, MEMO_BODY_TIMEOUT_MS, pauseFor, noticeOnStderr, memoDigestHex, memoFailureText, prefetchedMemosByFetch, MEMO_PREFETCH_LIFE_MS;
 var init_chain2 = __esm({
   "wallet/src/chain.mjs"() {
     "use strict";
     import_web395 = __toESM(require_index_cjs(), 1);
     init_esm2();
     init_proxy();
+    init_keepAlive();
     init_compressedReplay();
     init_reference2();
     init_anchorClock();
@@ -50660,6 +50708,8 @@ var init_chain2 = __esm({
     historyRpcErrors = /* @__PURE__ */ new WeakSet();
     HISTORY_RPC_BEHIND_WAIT_MS = 6e4;
     HISTORY_RPC_REQUEST_TIMEOUT_MS = 2e4;
+    HISTORY_RPC_BEHIND_FAST_MS = 150;
+    HISTORY_RPC_BEHIND_FAST_TRIES = 12;
     HISTORY_RPC_BEHIND_RETRY_STEPS_MS = Object.freeze([500, 1e3, 2e3, 5e3]);
     HISTORY_RPC_BEHIND_CODE = -32016;
     ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
@@ -52614,11 +52664,11 @@ async function refreshFinalizedP03HistorySnapshot({
   if (authenticated.programId !== program.toBase58() || authenticated.pool !== poolKey.toBase58()) {
     throw new Error("p03_history_refresh_binding_invalid");
   }
-  const snapshot = await readFinalizedPool(connection, program, poolKey);
-  if (snapshot.terminal !== authenticated.finalizedPoolSnapshot.terminal || snapshot.currentIndex !== authenticated.finalizedPoolSnapshot.currentIndex || snapshot.currentRoot !== authenticated.finalizedPoolSnapshot.currentRoot || !sameP03PoolPolicy(snapshot, authenticated.finalizedPoolSnapshot.policy) || !sameE1Tree(snapshot, authenticated.finalizedPoolSnapshot.e1Tree)) {
+  const snapshot = await readFinalizedPoolForRefresh(connection, program, poolKey);
+  if (snapshot.terminal !== authenticated.finalizedPoolSnapshot.terminal || snapshot.currentIndex !== authenticated.finalizedPoolSnapshot.currentIndex || snapshot.currentRoot !== authenticated.finalizedPoolSnapshot.currentRoot || !sameP03PoolPolicy(snapshot, authenticated.finalizedPoolSnapshot.policy) || !sameE1TreeHeader(snapshot, authenticated.finalizedPoolSnapshot.e1Tree, program, poolKey)) {
     throw Object.assign(
       new Error("p03_history_refresh_transition_detected"),
-      { snapshot, snapshotBinding: { programId: program.toBase58(), pool: poolKey.toBase58() } }
+      { currentIndex: snapshot.currentIndex, snapshotBinding: { programId: program.toBase58(), pool: poolKey.toBase58() } }
     );
   }
   const priorCoverage = authenticated.deploymentCoverage;
@@ -52704,6 +52754,26 @@ async function readFinalizedPool(connection, program, pool2) {
     })
   });
 }
+async function readFinalizedPoolForRefresh(connection, program, pool2) {
+  if (typeof connection.getMultipleAccountsInfoAndContext !== "function") return readFinalizedPool(connection, program, pool2);
+  const tree = new import_web396.PublicKey(e1TreeAddress(pool2.toBase58(), program.toBase58()));
+  const both = await retryTransientRpc(() => connection.getMultipleAccountsInfoAndContext(
+    [pool2, tree],
+    { commitment: "finalized", dataSlice: { offset: 0, length: REFRESH_READ_BYTES } }
+  ));
+  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);
+  if (snapshot.replayStore !== REPLAY_STORE_INDEXED) return snapshot;
+  const treeAccount = both.value[1];
+  return 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) {
   const value = response?.value;
   const slot3 = response?.context?.slot;
@@ -53257,6 +53327,7 @@ async function retryTransientRpc(operation, {
     } catch (error) {
       if (!isTransientRpcError(error)) throw error;
       lastError = error;
+      markPhase(`rpc-retry-${transientCause(error)}`);
       if (attempt + 1 < attempts) {
         await new Promise((resolve38) => setTimeout(resolve38, baseDelayMs * 2 ** attempt));
       }
@@ -53274,6 +53345,10 @@ function reuseRefusalCause(error) {
   if (status) return `http_${status}`;
   return error instanceof import_web396.SolanaJSONRPCError ? "rpc_error" : "read_failed";
 }
+function transientCause(error) {
+  if (error instanceof import_web396.SolanaJSONRPCError) return String(-error.code);
+  return reuseRefusalCause(error);
+}
 function isTransientRpcError(error) {
   if (error?.transientRpcError === true) return true;
   if (error instanceof import_web396.SolanaJSONRPCError) return LAGGING_NODE_RPC_CODES.has(error.code);
@@ -53419,19 +53494,16 @@ function assertP03E1TreeComplete({ program, pool: pool2, poolSnapshot, settles,
   if (Buffer.from(header.root).toString("hex") !== root) mismatch("root");
   return Object.freeze({ state: "open", address: tree.address, slot: BigInt(poolSnapshot.slot), root, leaves });
 }
-function sameE1Tree(snapshot, verified) {
+function sameE1TreeHeader(snapshot, verified, program, pool2) {
   if (verified === void 0) return snapshot.replayStore !== REPLAY_STORE_INDEXED;
-  const tree = snapshot.e1TreeAccount;
+  const tree = snapshot.e1TreeHeader;
   if (!tree || tree.address !== verified.address) return false;
   const empty = tree.data === null || tree.ownerProgramId === null || tree.ownerProgramId === SYSTEM_PROGRAM && tree.data.every((byte) => byte === 0);
   if (verified.state === "closed") return empty;
-  if (empty || tree.data.length !== E1.treeBytes) return false;
-  try {
-    const header = readE1TreeAccount(tree.data);
-    return header.leaves === verified.leaves && Buffer.from(header.root).toString("hex") === verified.root;
-  } catch {
-    return false;
-  }
+  if (empty || tree.ownerProgramId !== program.toBase58() || tree.data.length < E1_TREE_HEADER_BYTES || !Number.isSafeInteger(verified.leaves) || verified.leaves < 1) return false;
+  const data = tree.data;
+  if (data.subarray(0, 8).toString("latin1") !== "SX402T01" || !data.subarray(8, 40).equals(pool2.toBuffer()) || data[40] !== 1 || data[41] !== E1.depth || data.readUInt16LE(42) !== E1.bufferSize || data[44] !== E1.canopyDepth || data[45] !== 0 || data[46] !== 0 || data[47] !== 0) return false;
+  return data.readBigUInt64LE(56) === BigInt(2 * verified.leaves - 1);
 }
 function assertIndexedSettlementCpis(cpis, kind) {
   const exit = kind === "withdraw" || kind === "note-exit";
@@ -54207,7 +54279,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, REPLAY_STORE_INDEXED, CLOSE_REPLAY_TREE_TAG, EXTEND_ANCHOR_RING_TAG, 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, 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, HISTORY_FETCH_CONCURRENCY, HISTORY_BULK_TRANSACTIONS, HISTORY_BULK_ADDRESSES, TRANSIENT_RPC_ATTEMPTS, TRANSIENT_RPC_BASE_DELAY_MS, LAGGING_NODE_RPC_CODES;
+var import_web396, REPLAY_STORE_INDEXED, CLOSE_REPLAY_TREE_TAG, EXTEND_ANCHOR_RING_TAG, 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, 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_RPC_CODES;
 var init_walk = __esm({
   "wallet/src/history/walk.mjs"() {
     "use strict";
@@ -54216,6 +54288,7 @@ var init_walk = __esm({
     init_esm2();
     init_chain2();
     init_proxy();
+    init_phaseTiming();
     init_quote2();
     init_compressedReplay();
     init_p03E1Tree();
@@ -54442,6 +54515,8 @@ var init_walk = __esm({
     P03_INLINE_SETTLEMENT_TAGS = Object.freeze([24, 25, 26, 32]);
     P03_PAYMENT_REPLAY_INDICES = PROFILES[4].replayIndices;
     NO_CONTEXTS = Object.freeze([]);
+    REFRESH_READ_BYTES = POOL_STATE_LEN_RING2;
+    E1_TREE_HEADER_BYTES = 80;
     HISTORY_FETCH_CONCURRENCY = 4;
     HISTORY_BULK_TRANSACTIONS = 256;
     HISTORY_BULK_ADDRESSES = 256;
@@ -55357,10 +55432,15 @@ async function readCompactP03History({
   // it verified. Both are bound again below like served ones.
   served,
   initialization: knownInitialization,
-  // walletHistory.mjs: the finalized pool account (readFinalizedPool) that a refresh read on this
-  // same own RPC moments ago and refused as moved (p03_history_refresh_transition_detected
-  // carries it). Folded to instead of a second read of the pool account, and the page request
-  // starts at once unless the cached records already reach its index.
+  // 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.
+  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,
   // compactP03HistoryReport: run beside the spot checks once the initialization is verified
   // ({ snapshot, initialization, contexts }); its result comes back as `alongside`.
@@ -55380,8 +55460,9 @@ async function readCompactP03History({
     throw refuse3("p03_compact_history_connection_invalid");
   }
   own = withBoundedOwnReads(own);
-  const cachedReachesKnown = knownSnapshot !== void 0 && served !== void 0 && Array.isArray(served.records) && Boolean(served.initialization) && BigInt(served.records.length) * SUBTREE_LEAVES3 >= knownSnapshot.currentIndex;
-  const first = served === void 0 || knownSnapshot !== void 0 && !cachedReachesKnown ? requestPage(source, poolString, 0) : void 0;
+  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);
   markPhase(knownSnapshot !== void 0 ? "compact-pool-reused" : "compact-pool");
@@ -55396,7 +55477,10 @@ async function readCompactP03History({
     initialization: served.initialization,
     syncedSlot: served.syncedSlot,
     cached: true
-  } : await readPages(source, poolString, count2, first, { wakeSlot: snapshot.slot });
+  } : await readPages(source, poolString, count2, first, { wakeSlot: snapshot.slot }).catch((error) => {
+    if (error?.compactHistoryRefusal === "p03_compact_history_source_behind") error.behindSnapshot = snapshot;
+    throw error;
+  });
   markPhase(page.cached === true ? "compact-list-cached" : "compact-list");
   const binding = {
     programId: programString,
@@ -55521,6 +55605,7 @@ async function compactP03HistoryReport({
   forceRead = false,
   freshMs = 0,
   priorAttestation,
+  knownIndex,
   knownSnapshot,
   onList
 }) {
@@ -55590,6 +55675,7 @@ async function compactP03HistoryReport({
     programId,
     pool: pool2,
     alongside: attest,
+    ...knownIndex !== void 0 ? { knownIndex } : {},
     ...knownSnapshot !== void 0 ? { knownSnapshot } : {},
     ...onList !== void 0 ? { onList } : {},
     ...warm ? { served: cached.served } : {},
@@ -56364,8 +56450,9 @@ async function loadWalletP03HistoryNow({ store, connection: given, programId, po
   const runKey = lastRunReportKey(store, programId, pool2, deploymentIdentity, cache);
   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 movedSnapshot;
+  let movedIndex;
   if (earlier !== void 0) {
+    markPhase("refresh-start");
     try {
       const refreshed = await refreshFinalizedP03HistorySnapshot({ connection, programId, pool: pool2, history: earlier });
       markPhase("walk-refreshed");
@@ -56374,8 +56461,8 @@ async function loadWalletP03HistoryNow({ store, connection: given, programId, po
       return refreshed;
     } catch (error) {
       markPhase("refresh-missed");
-      if (error?.message === "p03_history_refresh_transition_detected" && error.snapshot && error.snapshotBinding?.programId === String(programId) && error.snapshotBinding?.pool === String(pool2)) {
-        movedSnapshot = error.snapshot;
+      if (error?.message === "p03_history_refresh_transition_detected" && typeof error.currentIndex === "bigint" && error.snapshotBinding?.programId === String(programId) && error.snapshotBinding?.pool === String(pool2)) {
+        movedIndex = error.currentIndex;
       }
       floor?.reset();
       if (strict) floor?.strict();
@@ -56390,7 +56477,7 @@ async function loadWalletP03HistoryNow({ store, connection: given, programId, po
       pool: pool2,
       deploymentIdentity,
       forceRead,
-      knownSnapshot: movedSnapshot,
+      knownIndex: movedIndex,
       onCompactList
     });
     if (compact !== void 0) {
@@ -56432,7 +56519,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, knownSnapshot, onCompactList }) {
+async function compactFirst({ store, connection, source, programId, pool: pool2, deploymentIdentity, forceRead, knownIndex, onCompactList }) {
   const started = Date.now();
   let behindNoticed = false;
   let behindTries = 0;
@@ -56456,8 +56543,9 @@ async function compactFirst({ store, connection, source, programId, pool: pool2,
       }
     }
   };
+  let behindSnapshot;
   for (let tries = 0; ; tries += 1) {
-    const result = await tryCompactP03HistoryReport(tries === 0 && knownSnapshot !== void 0 ? { ...options, knownSnapshot } : options);
+    const result = await tryCompactP03HistoryReport(behindSnapshot !== void 0 ? { ...options, knownSnapshot: behindSnapshot } : tries === 0 && knownIndex !== void 0 ? { ...options, knownIndex } : options);
     if (result.ok) {
       markPhase("walk-compact");
       const who = source === "pinned" ? "the pinned history proxy" : "--history-rpc";
@@ -56471,12 +56559,13 @@ async function compactFirst({ store, connection, source, programId, pool: pool2,
     if (result.reason === "p03_compact_history_source_behind" && Date.now() - started + behindDelay <= HISTORY_RPC_BEHIND_WAIT_MS) {
       if (!behindNoticed) {
         behindNoticed = true;
-        writeStderr(`history: the history proxy has fewer transitions than the pool account your own RPC read (it is behind the chain); asking it again after 0.5 s, 1 s, 2 s, then every 5 s, for at most ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s
+        writeStderr(`history: the history proxy has fewer transitions than the pool account your own RPC read (it is behind the chain); asking it again the first time as soon as it reaches that slot (checked every 0.15 s) or after 0.5 s, then after 1 s, 2 s, then every 5 s, for at most ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s
 `);
       }
       markPhase("compact-behind-wait");
       behindTries += 1;
-      await new Promise((resolve38) => setTimeout(resolve38, behindDelay));
+      behindSnapshot = result.error?.behindSnapshot;
+      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
@@ -56484,6 +56573,30 @@ async function compactFirst({ store, connection, source, programId, pool: pool2,
     return void 0;
   }
 }
+async function waitForCompactSource(source, pool2, slot3, budgetMs) {
+  const sleep5 = (ms) => new Promise((resolve38) => setTimeout(resolve38, ms));
+  if (!Number.isSafeInteger(slot3) || typeof source?._rpcRequest !== "function") return sleep5(budgetMs);
+  const until = Date.now() + budgetMs;
+  for (; ; ) {
+    const abort = new AbortController();
+    const params = [pool2, { commitment: "finalized", fromOrdinal: 0, toOrdinal: 1, 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) => {
+      timer = setTimeout(resolve38, Math.max(COMPACT_BEHIND_READ_MS, until - Date.now()));
+    })]);
+    clearTimeout(timer);
+    if (answer === void 0) abort.abort();
+    if (answer?.result !== void 0) {
+      markPhase("compact-behind-caught-up");
+      return void 0;
+    }
+    if (answer !== void 0 && answer?.error?.code !== -32016) return sleep5(Math.max(0, until - Date.now()));
+    const left = until - Date.now();
+    if (left <= 0) return void 0;
+    await sleep5(Math.min(COMPACT_BEHIND_POLL_MS, left));
+  }
+}
 function lastRunReportKey(store, programId, pool2, deploymentIdentity, cache) {
   if (cache !== void 0 || !store || typeof store !== "object" || !deploymentIdentity) return void 0;
   if (typeof store.path !== "string" || store.path.length === 0) return void 0;
@@ -56533,7 +56646,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_RETRY_MS, lastRunReports, writeStderr, announcedSources;
+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 init_walletHistory = __esm({
   "wallet/src/history/walletHistory.mjs"() {
     "use strict";
@@ -56558,6 +56671,8 @@ var init_walletHistory = __esm({
     prewarmedWalks = /* @__PURE__ */ new Map();
     PREWARMED_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;
     COMPACT_BEHIND_RETRY_MS = [500, 1e3, 2e3, 5e3];
     lastRunReports = /* @__PURE__ */ new Map();
     writeStderr = (text3) => {
@@ -59908,6 +60023,12 @@ function workerCount() {
   }
   return Math.max(1, Math.min(MAX_WORKERS, cores - 1));
 }
+function warmMemoDecryptPool() {
+  try {
+    workers();
+  } catch {
+  }
+}
 function workers() {
   if (pool !== void 0) return pool.broken ? void 0 : pool;
   pool = { list: [], pending: /* @__PURE__ */ new Map(), broken: false };
@@ -60198,15 +60319,28 @@ var init_successorHistories = __esm({
 });
 
 // wallet/src/recovery/recover.mjs
+import { createHash as createHash15 } from "node:crypto";
 import { join as join10, resolve as resolve10 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function pinnedGenerator2(profileVector) {
   if (profileVector?.payerKeys?.generator) return profileVector.payerKeys.generator;
-  const committed2 = JSON.parse(readFileSync(
-    join10(MODEL_DIR, "vectors", "rust-vectors.json"),
-    "utf8"
-  ));
-  return committed2.payerKeys.generator;
+  if (!committedGenerator) {
+    const committed2 = JSON.parse(readFileSync(
+      join10(MODEL_DIR, "vectors", "rust-vectors.json"),
+      "utf8"
+    ));
+    committedGenerator = Object.freeze(committed2.payerKeys.generator);
+  }
+  return committedGenerator;
+}
+function replayValueOf(kind, poolDomain, commitment, eta, leafIndex) {
+  const key = createHash15("sha256").update(kind === "account" ? `account|${String(commitment)}|${String(eta)}|${String(leafIndex)}` : `note|${String(poolDomain)}|${String(commitment)}|${String(eta)}|${String(leafIndex)}`).digest("base64");
+  const known = REPLAY_VALUES.get(key);
+  if (known !== void 0) return known;
+  const value = kind === "account" ? accountNullifier(commitment, eta, leafIndex) : noteNullifier2(poolDomain, commitment, eta, leafIndex);
+  if (REPLAY_VALUES.size >= REPLAY_VALUES_MAX) REPLAY_VALUES.clear();
+  REPLAY_VALUES.set(key, value);
+  return value;
 }
 function assertFinalizedRecoveryContext(context, digest2, programId, pool2) {
   const kinds = Object.freeze({ deposit: 1, payment: 2, withdraw: 3, "note-exit": 4, move: 5 });
@@ -60394,6 +60528,7 @@ function prefetchRecoveryMemos({ store, finalizedHistory: finalizedHistory2, ser
     if (pending.length === 0) return;
     createMemoReader(serviceUrl2, { fetchImpl: deps.fetchImpl ?? fetch, notice: () => {
     } }).prefetch(pending);
+    warmMemoDecryptPool();
   } catch {
   }
 }
@@ -60486,7 +60621,13 @@ async function runRecover({ store, connection, programId, digests, serviceUrl: s
   const recovered = [];
   for (const { digest: digest2, context, outputs } of read.entries) {
     for (const output2 of outputs) {
-      const replayValue = output2.kind === "account" ? accountNullifier(output2.commitment, viewingAuthority.eta, output2.leafIndex) : noteNullifier2(context.poolDomain, output2.commitment, viewingAuthority.eta, output2.leafIndex);
+      const replayValue = replayValueOf(
+        output2.kind,
+        context.poolDomain,
+        output2.commitment,
+        viewingAuthority.eta,
+        output2.leafIndex
+      );
       recovered.push({ ...output2, digest: digest2, replayValue });
     }
   }
@@ -60521,7 +60662,7 @@ async function runRecover({ store, connection, programId, digests, serviceUrl: s
     ...Array.isArray(digests) && digests.length > 0 ? { narrowedByDigests: true } : {}
   };
 }
-var import_web3102, FIELD_MODULUS6, MODEL_DIR, seedBytes3, hexOf2;
+var import_web3102, FIELD_MODULUS6, MODEL_DIR, seedBytes3, committedGenerator, REPLAY_VALUES, REPLAY_VALUES_MAX, hexOf2;
 var init_recover = __esm({
   "wallet/src/recovery/recover.mjs"() {
     "use strict";
@@ -60541,6 +60682,8 @@ var init_recover = __esm({
       fileURLToPath5(new URL("../../vendor/shielded-x402-model/", new URL("__bundled_source__/wallet/src/recovery/recover.mjs", import.meta.url).href))
     );
     seedBytes3 = (state) => Uint8Array.from(Buffer.from(state.seedHex, "hex"));
+    REPLAY_VALUES = /* @__PURE__ */ new Map();
+    REPLAY_VALUES_MAX = 5e4;
     hexOf2 = (value) => String(value).replace(/^0x/, "").toLowerCase();
   }
 });
@@ -61136,6 +61279,7 @@ var init_errorCodes = __esm({
       "p03_merchant_respend_evidence_account_file_invalid_json",
       "p03_merchant_respend_evidence_digests_invalid_json",
       "p03_merchant_respend_accounts_split_merge_first",
+      "walk_history_required",
       "merge_id_invalid",
       "merge_id_reserved",
       "p03_merchant_respend_insufficient_recovered_value",
@@ -62916,6 +63060,7 @@ var init_errorCodes = __esm({
       "absorb_note_ambiguous",
       "p03_payer_float_absorb_pocket_mismatch",
       "p03_payer_float_absorb_exit_failed",
+      "p03_payer_float_absorb_merge_failed",
       "reverted_payment",
       "config_invalid",
       "p03_payer_float_journal_unwritable",
@@ -68279,14 +68424,14 @@ var init_solana_ed255192 = __esm({
 });
 
 // spikes/shielded-x402-solana/scripts/verify-production-parameter-bundle.mjs
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import { dirname as dirname12, isAbsolute as isAbsolute4, relative as relative5, resolve as resolve11 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function fail13(message) {
   throw new Error(`production parameter bundle rejected: ${message}`);
 }
 function sha2567(bytes2) {
-  return createHash15("sha256").update(bytes2).digest("hex");
+  return createHash16("sha256").update(bytes2).digest("hex");
 }
 function assertHex2(value, bytes2, label) {
   if (typeof value !== "string" || !new RegExp(`^[0-9a-f]{${bytes2 * 2}}$`).test(value)) {
@@ -68760,7 +68905,7 @@ var init_production_proof_bundle2 = __esm({
 
 // spikes/shielded-x402-wallet/lib/p03-recovered-exit.mjs
 import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 import { dirname as dirname13, isAbsolute as isAbsolute5, join as join11, relative as relative6, resolve as resolve13 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 function fail14(reason) {
@@ -69161,7 +69306,7 @@ var init_p03_recovered_exit = __esm({
     init_pool_denomination();
     TOOLS_SCHEMA2 = "carbon-shielded-wallet/p03-public-proof-tools/v1";
     REQUEST_SCHEMA2 = "carbon-shielded-x402/p03-recovered-exit-request/v1";
-    sha2568 = (value) => createHash16("sha256").update(value).digest("hex");
+    sha2568 = (value) => createHash17("sha256").update(value).digest("hex");
     jsonBytes2 = (value) => Buffer.from(`${JSON.stringify(value, null, 2)}
 `, "utf8");
     CHILD_MAX_BUFFER2 = 128 * 1024 * 1024;
@@ -69193,7 +69338,7 @@ var init_p03_recovered_exit = __esm({
 });
 
 // spikes/shielded-x402-wallet/bin/shielded-wallet.mjs
-import { createHash as createHash17 } from "node:crypto";
+import { createHash as createHash18 } from "node:crypto";
 import { homedir } from "node:os";
 import { join as join12, resolve as resolve14 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
@@ -69680,7 +69825,7 @@ function contextHoldsPrimary(context, primaryHex) {
   const expected = contextPrimaryHex(context, primaryHex);
   if (expected === void 0) return false;
   if (context.primaryPayloadHex !== void 0) return context.primaryPayloadHex === expected;
-  return context.historySource === "compact" && typeof context.primaryPayloadSha256 === "string" && context.primaryPayloadSha256 === createHash17("sha256").update(Buffer.from(expected, "hex")).digest("hex");
+  return context.historySource === "compact" && typeof context.primaryPayloadSha256 === "string" && context.primaryPayloadSha256 === createHash18("sha256").update(Buffer.from(expected, "hex")).digest("hex");
 }
 function releaseIfSpentByOtherPayment({ store, history, prior }) {
   const authenticated = assertAuthenticatedFinalizedP03History(history);
@@ -71263,7 +71408,7 @@ var init_poseidon_params_t_6 = __esm({
 });
 
 // src/server/payments/shielded/ShieldedSolanaP03QuoteCrypto.ts
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 function serializePinnedJson(value) {
   if (Array.isArray(value)) return `[${value.map(serializePinnedJson).join(", ")}]`;
   if (value !== null && typeof value === "object") {
@@ -71302,7 +71447,7 @@ function parseMatrix(value, rows, columns, label) {
 }
 function assertParameterArtifact(artifact, expected) {
   if (!isJsonValue(artifact)) throw new Error("p03_quote_crypto_parameter_artifact_invalid");
-  const digest2 = createHash18("sha256").update(serializePinnedJson(artifact)).digest("hex");
+  const digest2 = createHash19("sha256").update(serializePinnedJson(artifact)).digest("hex");
   if (digest2 !== expected.sha256) throw new Error("p03_quote_crypto_parameter_hash_mismatch");
   if (!artifact || typeof artifact !== "object" || Array.isArray(artifact)) {
     throw new Error("p03_quote_crypto_parameter_shape_invalid");
@@ -71958,6 +72103,26 @@ function startFinalizedChainTime(connection) {
     return time + Math.floor(age / 1e3);
   };
 }
+async function everyAccountHeld({ store, connection, programId, serviceUrl: serviceUrl2, reservedReplayValues, 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 recovery = await (deps.recover ?? runRecover)({
+    store,
+    connection,
+    programId: new import_web3106.PublicKey(programId),
+    serviceUrl: serviceUrl2,
+    deps: { fetchImpl: deps.fetchImpl, finalizedHistory: history, transitionContextFor: history.transitionContextFor }
+  });
+  return recovery.recovered.filter((entry) => entry.kind === "account" && entry.spendStatus === "unspent").every((entry) => {
+    if (entry.leafIndex === void 0 || entry.leafIndex === null) return true;
+    try {
+      return reservedReplayValues.has(accountNullifier(entry.commitment, viewing.eta, entry.leafIndex).toString());
+    } catch {
+      return true;
+    }
+  });
+}
 async function prepareRecoveredPayment({
   store,
   connection,
@@ -72315,7 +72480,7 @@ var init_prepareRecoveredPayment = __esm({
 });
 
 // wallet/src/pay/receiptTransaction.mjs
-import { createHash as createHash19 } from "node:crypto";
+import { createHash as createHash20 } from "node:crypto";
 function sameQuoteCommitment(left, right) {
   const parse4 = (value) => {
     if (typeof value !== "string" || value.length > 77 || !/^(?:0|[1-9][0-9]*|0x[0-9a-f]{64})$/.test(value)) return void 0;
@@ -72339,7 +72504,7 @@ function contextPayloadMatches(context, payload2) {
   else fail16("receipt_history_proof_form_invalid");
   if (bytes2 === void 0) return false;
   if (context.primaryPayloadHex !== void 0) return context.primaryPayloadHex === bytes2.toString("hex");
-  return context.primaryPayloadSha256 === createHash19("sha256").update(bytes2).digest("hex");
+  return context.primaryPayloadSha256 === createHash20("sha256").update(bytes2).digest("hex");
 }
 function submittedPayload(paymentHeader) {
   const payload2 = decodePaymentSignatureHeader(paymentHeader)?.payload;
@@ -91130,38 +91295,8 @@ var init_pay = __esm({
   }
 });
 
-// wallet/src/fetch/keepAlive.mjs
-function proxiedRun() {
-  const env = process.env;
-  return Boolean(env.SHINJUKU_WALLET_PROXIED || env.NODE_USE_ENV_PROXY || env.HTTPS_PROXY || env.HTTP_PROXY || env.https_proxy || env.http_proxy);
-}
-function keepAliveDispatcher() {
-  if (shared !== void 0) return shared;
-  try {
-    if (proxiedRun()) return void 0;
-    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 });
-    return shared;
-  } catch {
-    return void 0;
-  }
-}
-function keepAliveInit(init = {}) {
-  const dispatcher = keepAliveDispatcher();
-  return dispatcher === void 0 ? init : { ...init, dispatcher };
-}
-var GLOBAL_DISPATCHER, KEEP_ALIVE_MS, shared;
-var init_keepAlive = __esm({
-  "wallet/src/fetch/keepAlive.mjs"() {
-    "use strict";
-    GLOBAL_DISPATCHER = /* @__PURE__ */ Symbol.for("undici.globalDispatcher.1");
-    KEEP_ALIVE_MS = 2e4;
-  }
-});
-
 // wallet/src/pay/floatPay.mjs
-import { createHash as createHash20, randomBytes as randomBytes11 } from "node:crypto";
+import { createHash as createHash21, randomBytes as randomBytes11 } from "node:crypto";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function floatRecordOf(store, requestId) {
   try {
@@ -91351,7 +91486,7 @@ function canonicalBody({ requestId, resourceUrl, requirement, refundTo }) {
   const text3 = `{"requestId":${JSON.stringify(opaque)},"resourceUrl":${JSON.stringify(resourceUrl)},"requirement":${JSON.stringify(requirement)},"refundTo":${JSON.stringify(refundTo)}}`;
   const bytes2 = Buffer.from(text3, "utf8");
   if (bytes2.length > MAX_BODY_BYTES) fail18("p03_float_body_too_large");
-  return { bodyBase64: bytes2.toString("base64"), floatId: createHash20("sha256").update(bytes2).digest("hex") };
+  return { bodyBase64: bytes2.toString("base64"), floatId: createHash21("sha256").update(bytes2).digest("hex") };
 }
 function floatAnswer(resultBase64, record, store) {
   let answer;
@@ -91557,7 +91692,8 @@ async function payViaFloat({
           method: "POST",
           body: Buffer.from(record.bodyBase64, "base64"),
           headers: { "content-type": "application/json" },
-          deps: { ...withoutCallerBody(deps), fetchImpl: floatFetch(fetchImpl, seen) }
+          // settlePriorBeforeQuote: a prior answer that holds every input is settled before the leg-1 402 (one quote, one row).
+          deps: { ...withoutCallerBody(deps), fetchImpl: floatFetch(fetchImpl, seen), settlePriorBeforeQuote: true }
         });
       } catch (error) {
         if (seen.refusal) {
@@ -92076,6 +92212,7 @@ async function finalizePendingReceipt({ store, connection, programId, name, time
   const deadline = now() + timeoutMs;
   let gated = false;
   let strict = false;
+  let gateClock;
   for (; ; ) {
     const record = store.readWal(name);
     if (!isPending(record)) return record;
@@ -92099,15 +92236,19 @@ async function finalizePendingReceipt({ store, connection, programId, name, time
       const answeredLongAgo = Number.isSafeInteger(record.answeredAtMs) && Date.now() - record.answeredAtMs >= FINALITY_GATE_SKIP_AFTER_MS;
       if (!answeredLongAgo) {
         strict = true;
-        const tip = (await finalizedClock(connection, "confirmed")).slot;
-        const target = tip > (await finalizedClock(connection)).slot ? tip + FINALITY_GATE_MARGIN_SLOTS : tip;
-        while ((await finalizedClock(connection)).slot < target && now() < deadline) {
+        const [tipClock, finalClock] = await Promise.all([finalizedClock(connection, "confirmed"), finalizedClock(connection)]);
+        const tip = tipClock.slot;
+        const target = tip > finalClock.slot ? tip + FINALITY_GATE_MARGIN_SLOTS : tip;
+        gateClock = finalClock;
+        while (gateClock.slot < target && now() < deadline) {
           await sleep5(Math.min(pollMs, FINALITY_GATE_POLL_MS));
+          gateClock = await finalizedClock(connection);
         }
       }
       markPhase("gate");
     }
-    const clock2 = await finalizedClock(connection);
+    const clock2 = gateClock ?? await finalizedClock(connection);
+    gateClock = void 0;
     const history = assertAuthenticatedFinalizedP03History(
       await (strict ? withStrictHistorySource(() => deps.walkHistory()) : deps.walkHistory())
     );
@@ -92498,6 +92639,31 @@ async function payResourceOnce({
       }
       await settlePrior(name);
     }
+    const settleDeferred = async () => {
+      const answeredAt = (name) => store.readWal(name)?.answeredAtMs ?? 0;
+      const shared2 = {};
+      for (const name of deferred.splice(0).sort((a, b) => answeredAt(b) - answeredAt(a))) await settlePrior(name, shared2);
+      held.clear();
+    };
+    if (deps.settlePriorBeforeQuote === true && deferred.length > 0 && !record) {
+      let first = false;
+      try {
+        first = await withPhaseScope(mark, "held", () => (deps.everyAccountHeld ?? everyAccountHeld)({
+          store,
+          connection,
+          programId,
+          serviceUrl: serviceUrl2,
+          reservedReplayValues: held,
+          deps: { fetchImpl: deps.fetchImpl, walkHistory: finality.walkHistory }
+        }));
+      } catch {
+        first = false;
+      }
+      if (first === true) {
+        mark("prior-finality-first");
+        await settleDeferred();
+      }
+    }
     if (!record?.paymentHeader && typeof deps.warmHistory === "function") {
       if (walkedThisRun && deps.warmHistory === deps.walkHistory) {
         mark("history-warm-reused");
@@ -92635,10 +92801,7 @@ async function payResourceOnce({
         const noProof = store.readWal(`resource-proof-${requestKey}`)?.proved === void 0;
         if (noProof && deferred.length > 0 && /^p03_merchant_respend_inputs_held_by_pending_payment/.test(message)) {
           mark("prior-finality-fallback");
-          const answeredAt = (name) => store.readWal(name)?.answeredAtMs ?? 0;
-          const shared2 = {};
-          for (const name of deferred.splice(0).sort((a, b) => answeredAt(b) - answeredAt(a))) await settlePrior(name, shared2);
-          held.clear();
+          await settleDeferred();
           continue;
         }
         if (!requoted && noProof && (/^p03_merchant_respend_quote_life_short_requote/.test(message) || /^p03_merchant_respend_quote_expired/.test(message))) {
@@ -92796,7 +92959,7 @@ var init_payResource = __esm({
 });
 
 // wallet/src/pay/cli.mjs
-import { createHash as createHash21 } from "node:crypto";
+import { createHash as createHash22 } from "node:crypto";
 import { resolve as resolve16 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 async function main2(args = process.argv.slice(2)) {
@@ -92916,7 +93079,7 @@ function writePaidAnswer(path, resultBase64) {
   } catch {
     throw new Error("p03_resource_cli_out_unwritable_rerun_same_request");
   }
-  return { path, bytes: bytes2.length, sha256: createHash21("sha256").update(bytes2).digest("hex") };
+  return { path, bytes: bytes2.length, sha256: createHash22("sha256").update(bytes2).digest("hex") };
 }
 function describeCliError(error, options = {}) {
   return describeError(error, { fallback: "p03_resource_cli_failed", nameUnknown: true, ...options });
@@ -94115,7 +94278,7 @@ var init_secp256k1 = __esm({
 });
 
 // src/server/storage/EncryptedJsonFile.ts
-import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, createHash as createHash23, randomBytes as randomBytes16 } from "node:crypto";
+import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, createHash as createHash24, randomBytes as randomBytes16 } from "node:crypto";
 import { mkdir as mkdir3, open as open2, readFile as readFile4, rename as rename3, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname18 } from "node:path";
 var EncryptedJsonFile, renameReplacing, renameReplacingSync, retryableWindowsRename, isEncryptedPayload, isMissingFile, isUnsupportedDirectorySync;
@@ -94241,7 +94404,7 @@ var init_EncryptedJsonFile = __esm({
             await pause3();
           }
           const text3 = parts.join("");
-          return { text: text3, sha256: createHash23("sha256").update(text3, "utf8").digest("hex") };
+          return { text: text3, sha256: createHash24("sha256").update(text3, "utf8").digest("hex") };
         }
         const iv = randomBytes16(12);
         const cipher = createCipheriv3("aes-256-gcm", this.key(), iv);
@@ -94253,7 +94416,7 @@ var init_EncryptedJsonFile = __esm({
         sealed.push(cipher.final());
         const ciphertext = Buffer.concat(sealed);
         const head = `{"version":1,"algorithm":"aes-256-gcm","iv":"${iv.toString("base64")}","tag":"${cipher.getAuthTag().toString("base64")}","ciphertext":"`;
-        const hash12 = createHash23("sha256").update(head, "utf8");
+        const hash12 = createHash24("sha256").update(head, "utf8");
         const encoded = [head];
         const window2 = 3 * 256 * 1024;
         for (let offset = 0; offset < ciphertext.length; offset += window2) {
@@ -94353,7 +94516,7 @@ var init_EncryptedJsonFile = __esm({
           if (decoded.length === 32) return decoded;
         } catch {
         }
-        return createHash23("sha256").update(value).digest();
+        return createHash24("sha256").update(value).digest();
       }
     };
     renameReplacing = async (from, to) => {
@@ -94919,7 +95082,7 @@ var init_poseidon_params_t_3 = __esm({
 });
 
 // src/server/payments/shielded/ShieldedSolanaP03Poseidon.ts
-import { createHash as createHash24 } from "node:crypto";
+import { createHash as createHash25 } from "node:crypto";
 function serializePinnedJson2(value) {
   if (Array.isArray(value)) return `[${value.map(serializePinnedJson2).join(", ")}]`;
   if (value !== null && typeof value === "object") {
@@ -94958,7 +95121,7 @@ function parseMatrix2(value, rows, columns, label) {
 }
 function assertShieldedSolanaP03PoseidonParameterArtifact(artifact) {
   if (!isJsonValue2(artifact)) throw new Error("p03_poseidon_parameter_artifact_invalid");
-  const digest2 = createHash24("sha256").update(serializePinnedJson2(artifact)).digest("hex");
+  const digest2 = createHash25("sha256").update(serializePinnedJson2(artifact)).digest("hex");
   if (digest2 !== SHIELDED_SOLANA_P03_POSEIDON_PARAMETERS_SHA256) {
     throw new Error("p03_poseidon_parameter_hash_mismatch");
   }
@@ -95817,7 +95980,7 @@ var init_shieldedSellerAcceptance = __esm({
 });
 
 // wallet/src/seller/config.mjs
-import { createHash as createHash25 } from "node:crypto";
+import { createHash as createHash26 } from "node:crypto";
 var import_web3119, fail26, sha2;
 var init_config = __esm({
   "wallet/src/seller/config.mjs"() {
@@ -95828,7 +95991,7 @@ var init_config = __esm({
     fail26 = (code) => {
       throw new Error(`p03_seller_${code}`);
     };
-    sha2 = (bytes2) => createHash25("sha256").update(bytes2).digest("hex");
+    sha2 = (bytes2) => createHash26("sha256").update(bytes2).digest("hex");
   }
 });
 
@@ -112945,7 +113108,7 @@ __export(binding_exports, {
   commitmentsOpen: () => commitmentsOpen,
   transcript: () => transcript
 });
-import { createHash as createHash31, randomBytes as randomBytes26 } from "node:crypto";
+import { createHash as createHash32, randomBytes as randomBytes26 } from "node:crypto";
 function transcript(t, contextCommitment, D5, T, cLo, cHi) {
   for (const [name, b] of [["programId", t.programId], ["pool", t.pool], ["mint", t.mint], ["vault", t.vault], ["counterparty", t.counterparty], ["T", T], ["C_lo", cLo], ["C_hi", cHi]]) {
     if (b.length !== 32) throw new Error(`transcript ${name} must be 32 bytes, got ${b.length}`);
@@ -113031,7 +113194,7 @@ var init_binding = __esm({
     bindCommitment = (v, k, rho) => sponge2([BIND_DOMAIN, v, k, rho]);
     TRANSCRIPT_LEN = 391;
     FORCED_TRANSCRIPT_LEN = 423;
-    challenge = (tr) => BigInt(`0x${createHash31("sha256").update(tr).digest().subarray(0, 24).toString("hex")}`);
+    challenge = (tr) => BigInt(`0x${createHash32("sha256").update(tr).digest().subarray(0, 24).toString("hex")}`);
   }
 });
 
@@ -113614,7 +113777,7 @@ __export(witness_exports, {
   memoDigestHex: () => memoDigestHex2,
   treeAppendRequest: () => treeAppendRequest
 });
-import { createHash as createHash32 } from "node:crypto";
+import { createHash as createHash33 } from "node:crypto";
 function depositRequest(p) {
   if (p.account.b !== p.bind.v || p.account.i !== 0n) throw new Error("a deposit account has b = v and i = 0");
   return {
@@ -113663,7 +113826,7 @@ var init_witness2 = __esm({
     WITNESS_SCHEMA = "carbon-shielded-x402/ctvault-v0b-witness/v1";
     dec = (x) => x.toString();
     acct = (a) => ({ d: dec(a.d), pDX: dec(a.pDX), i: dec(a.i), b: dec(a.b) });
-    memoDigestHex2 = (memo) => `0x${createHash32("sha256").update(memo, "utf8").digest("hex")}`;
+    memoDigestHex2 = (memo) => `0x${createHash33("sha256").update(memo, "utf8").digest("hex")}`;
     bindFields = (b) => ({
       value: dec(b.v),
       blinding: dec(b.k),
@@ -114409,7 +114572,7 @@ var init_service2 = __esm({
 });
 
 // wallet/src/v0b/prover.mjs
-import { createHash as createHash33 } from "node:crypto";
+import { createHash as createHash34 } from "node:crypto";
 import { join as join33, resolve as resolve32 } from "node:path";
 function parseParamsPins(text3) {
   const pins = {};
@@ -114524,7 +114687,7 @@ var init_prover2 = __esm({
       ExitCTV1: "carbon-shielded-exact/exit-ct-v1/CEREMONY-proof/v0b",
       TreeAppendV1: "carbon-shielded-exact/tree-append-v1/CEREMONY-proof/v0b"
     });
-    sha256File = (path) => createHash33("sha256").update(readFileSync(path)).digest("hex");
+    sha256File = (path) => createHash34("sha256").update(readFileSync(path)).digest("hex");
     DEPOSIT_ORDER = spec_exports.DEPOSIT_CT_PUBLIC;
     EXIT_ORDER = spec_exports.EXIT_CT_PUBLIC;
   }
@@ -116187,7 +116350,7 @@ var init_lib2 = __esm({
 });
 
 // wallet/src/laneb/keys.mjs
-import { createHash as createHash34, createHmac as createHmac9 } from "node:crypto";
+import { createHash as createHash35, createHmac as createHmac9 } from "node:crypto";
 function seedBytes7(state) {
   const seed = Buffer.from(String(state?.seedHex ?? ""), "hex");
   if (seed.length !== 32) fail50("seed_invalid");
@@ -116288,7 +116451,7 @@ var init_keys3 = __esm({
       }
       return out;
     };
-    sha5123 = (...parts) => createHash34("sha512").update(Buffer.concat(parts.map((part) => Buffer.from(part)))).digest();
+    sha5123 = (...parts) => createHash35("sha512").update(Buffer.concat(parts.map((part) => Buffer.from(part)))).digest();
     hashToScalar = (...parts) => mod9(leToBig(sha5123(...parts)));
     nonZero = (scalar) => {
       if (scalar === 0n) fail50("degenerate_scalar");
@@ -116308,7 +116471,7 @@ var init_keys3 = __esm({
 });
 
 // wallet/src/laneb/flows.mjs
-import { createHash as createHash35 } from "node:crypto";
+import { createHash as createHash36 } from "node:crypto";
 import { resolve as resolve34 } from "node:path";
 function serviceRefusal(error, what, fallbackNext) {
   if (error?.message === "laneb_service_not_enabled") {
@@ -116971,7 +117134,7 @@ var init_flows3 = __esm({
     };
     sleep3 = (ms) => new Promise((done) => setTimeout(done, ms));
     isAddress4 = (value) => typeof value === "string" && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(value);
-    sha256Hex3 = (text3) => createHash35("sha256").update(text3).digest("hex");
+    sha256Hex3 = (text3) => createHash36("sha256").update(text3).digest("hex");
     AMOUNT_SENTENCE = "We know the quoted price; for scheme confidential we also check the payer's proof that the transfer equals it. We cannot decrypt a slot. The chain shows no amount.";
     saveBook = (store, book) => store.writeWal(BOOK, book);
     planRpc = (rpc2) => ({
@@ -116981,7 +117144,7 @@ var init_flows3 = __esm({
 });
 
 // wallet/src/laneb/amountProof.mjs
-import { createHash as createHash36, randomBytes as randomBytes27 } from "node:crypto";
+import { createHash as createHash37, randomBytes as randomBytes27 } from "node:crypto";
 function readValidityContext(transactions) {
   if (!Array.isArray(transactions) || transactions.length === 0) refuse13("the plan carries no transactions");
   let validity;
@@ -117014,7 +117177,7 @@ function readValidityContext(transactions) {
   return { sourcePubkey: data.slice(1, 33), destinationPubkey: data.slice(33, 65), auditorPubkey: data.slice(65, 97), lo: half(97), hi: half(225) };
 }
 function challenge2({ nonce, half, sourcePubkey, sourceHandle, R: R2, A1, A2, commitment }) {
-  const digest2 = createHash36("sha512").update(Buffer.from(AMOUNT_PROOF_DOMAIN, "utf8")).update(nonce).update(Buffer.from(half, "utf8")).update(sourcePubkey).update(H2.toBytes()).update(sourceHandle).update(R2).update(A1).update(A2).update(commitment).digest();
+  const digest2 = createHash37("sha512").update(Buffer.from(AMOUNT_PROOF_DOMAIN, "utf8")).update(nonce).update(Buffer.from(half, "utf8")).update(sourcePubkey).update(H2.toBytes()).update(sourceHandle).update(R2).update(A1).update(A2).update(commitment).digest();
   return leToBig2(digest2) % L3;
 }
 function nonceBytes(nonce) {
@@ -117129,7 +117292,7 @@ var init_amountProof = __esm({
 });
 
 // wallet/src/laneb/x402pay.mjs
-import { createHash as createHash37, randomBytes as randomBytes28 } from "node:crypto";
+import { createHash as createHash38, randomBytes as randomBytes28 } from "node:crypto";
 import { resolve as resolve35 } from "node:path";
 async function call2(promise, what, fallbackNext) {
   try {
@@ -117601,7 +117764,7 @@ var init_x402pay = __esm({
       }
     };
     sleep4 = (ms) => new Promise((done) => setTimeout(done, ms));
-    sha256Hex4 = (bytes2) => createHash37("sha256").update(bytes2).digest("hex");
+    sha256Hex4 = (bytes2) => createHash38("sha256").update(bytes2).digest("hex");
     isAddress5 = (value) => typeof value === "string" && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(value);
     isSignature2 = (value) => typeof value === "string" && /^[1-9A-HJ-NP-Za-km-z]{64,100}$/.test(value);
     usdc5 = (atomic3) => {
@@ -118312,14 +118475,15 @@ function startHistoryPrewarm(session, store, mark) {
       // for them after the walk, M). The same set the recovery asks (every listed transition
       // its cache lacks); it takes an answer only for a transition of the verified report
       // (chain.mjs createMemoReader prefetch; recover.mjs checks each bundle's digest).
-      onCompactList: (contexts) => {
-        markPhase("memo-prefetch");
-        prefetchRecoveryMemos({ store, finalizedHistory: { contexts }, serviceUrl: session.memoServiceUrl, programId: session.programId });
-      }
+      onCompactList: memoPrefetchOnList(session, store)
     }));
   } catch {
   }
 }
+var memoPrefetchOnList = (session, store) => (contexts) => {
+  markPhase("memo-prefetch");
+  prefetchRecoveryMemos({ store, finalizedHistory: { contexts }, serviceUrl: session.memoServiceUrl, programId: session.programId });
+};
 var lazyProofTools = (session) => new Proxy({}, { get: (_target, key) => session.proofTools[key] });
 async function paidCall({ session, target, method, headers, body, cap, requestId, price, challenge: challenge3, timing, mark }) {
   if (session.closed) fail20("fetch_session_closed", "this payer session is closed; open a new one");
@@ -118372,7 +118536,8 @@ async function paidCall({ session, target, method, headers, body, cap, requestId
           connection: connectSplit(session.connection, session.historyUrl),
           programId: session.programId,
           pool: store.state.pool,
-          deploymentIdentity: session.proofTools.deploymentIdentity
+          deploymentIdentity: session.proofTools.deploymentIdentity,
+          onCompactList: memoPrefetchOnList(session, store)
         })
       }
     });
@@ -118399,7 +118564,7 @@ async function paidCall({ session, target, method, headers, body, cap, requestId
 // wallet/src/mcp/stdioServer.mjs
 init_fs();
 var import_web3131 = __toESM(require_index_cjs(), 1);
-import { createHash as createHash29 } from "node:crypto";
+import { createHash as createHash30 } from "node:crypto";
 import { dirname as dirname24, join as join27, resolve as resolve25, sep as sep4 } from "node:path";
 import { fileURLToPath as fileURLToPath17 } from "node:url";
 init_proxy();
@@ -118678,7 +118843,7 @@ function addToJsonHost(file, entry, { now = /* @__PURE__ */ new Date(), force =
 // wallet/src/setup/proofTools.mjs
 init_fs();
 init_rpcDefault();
-import { createHash as createHash22 } from "node:crypto";
+import { createHash as createHash23 } from "node:crypto";
 import { dirname as dirname17, join as join17, sep as sep3 } from "node:path";
 
 // wallet/src/setup/channel.mjs
@@ -118913,7 +119078,7 @@ var LIMITS = Object.freeze({ release: 64 * 1024, sums: 64 * 1024, file: 200 * 10
 var RELEASE_TIMEOUT_MS = 3e4;
 var FILE_TIMEOUT_MS = 15 * 6e4;
 var REQUIRED_FILES = Object.freeze(["proof-tools.json", "exit-proof-tools.json", "public-profile.json"]);
-var sha2569 = (bytes2) => createHash22("sha256").update(bytes2).digest("hex");
+var sha2569 = (bytes2) => createHash23("sha256").update(bytes2).digest("hex");
 var fail22 = (code, detail) => new Error(`${code}: ${detail}`);
 async function getBytes(fetchImpl, url, timeoutMs, label, maxBytes, budget) {
   const limit = budget ? Math.min(maxBytes, budget.left) : maxBytes;
@@ -119954,7 +120119,7 @@ init_shielded_wallet();
 
 // wallet/src/mcp/autoPockets.mjs
 init_http();
-import { createHash as createHash26 } from "node:crypto";
+import { createHash as createHash27 } from "node:crypto";
 
 // wallet/src/pocket/auto.mjs
 var import_web3126 = __toESM(require_index_cjs(), 1);
@@ -121285,7 +121450,7 @@ var REST_OF_FILL_SECONDS = Object.freeze({
 });
 var REFILLING_CODE = "wallet_refilling_retry_same_request";
 var firstCode3 = (error) => String(error?.message ?? error ?? "").split(/[\s:;(]/, 1)[0];
-var sha25610 = (text3) => createHash26("sha256").update(text3, "utf8").digest("hex");
+var sha25610 = (text3) => createHash27("sha256").update(text3, "utf8").digest("hex");
 function requestFingerprint({ url, method = "GET", headers = {}, body }) {
   const sorted = Object.entries(headers ?? {}).map(([name, value]) => [name.toLowerCase(), String(value)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
   return sha25610(JSON.stringify([String(url), String(method).toUpperCase(), sorted, body ?? null]));
@@ -124481,7 +124646,7 @@ function createOneTimeAdopter({ session, log = () => {
 
 // wallet/src/mcp/answer.mjs
 init_fs();
-import { createHash as createHash27 } from "node:crypto";
+import { createHash as createHash28 } from "node:crypto";
 import { join as join24 } from "node:path";
 var DEFAULT_MAX_INLINE_BYTES = 4e6;
 var DEFAULT_MAX_TEXT_CHARS = 64 * 1024;
@@ -124645,7 +124810,7 @@ function extractEmbeddedImages(json2, { saveDir, now, maxInlineBytes = DEFAULT_M
       return NOT_AN_IMAGE;
     }
     const sniffed = sniffImage(decoded);
-    const sha3 = createHash27("sha256").update(decoded).digest("hex");
+    const sha3 = createHash28("sha256").update(decoded).digest("hex");
     if (!sniffed) {
       const svg = claimedMime === "image/svg+xml" || looksLikeSvg(decoded);
       const saved2 = save(decoded, svg ? "svg" : "bin", saveDir, now, sha3);
@@ -124711,7 +124876,7 @@ function paidAnswerContent({
     bytes: data.length,
     ...truncated ? { answerTruncated: true } : {}
   };
-  const sha25612 = createHash27("sha256").update(data).digest("hex");
+  const sha25612 = createHash28("sha256").update(data).digest("hex");
   const sniffed = sniffImage(data);
   if (sniffed && (declared === "" || declared.startsWith("image/") || declared === "application/octet-stream")) {
     const saved2 = save(data, RASTER[sniffed], saveDir, now, sha25612);
@@ -124792,7 +124957,7 @@ function paidAnswerContent({
 
 // wallet/src/mcp/discover.mjs
 init_fs();
-import { createHash as createHash28 } from "node:crypto";
+import { createHash as createHash29 } from "node:crypto";
 import { join as join25 } from "node:path";
 var SOLANA_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 var SOLANA_USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
@@ -125263,7 +125428,7 @@ function clip(text3, max) {
   return text3.length > max ? `${text3.slice(0, max - 1)}\u2026` : text3;
 }
 function cachePath(key, cacheDir) {
-  return join25(cacheDir, `x402-discover-${createHash28("sha256").update(key).digest("hex").slice(0, 24)}.json`);
+  return join25(cacheDir, `x402-discover-${createHash29("sha256").update(key).digest("hex").slice(0, 24)}.json`);
 }
 function readCache(key, ctx, maxAge) {
   const age = (record) => ctx.clock() - Number(record?.fetchedAt);
@@ -125554,6 +125719,7 @@ var withTimeout = (promise, ms) => Promise.race([
   })
 ]);
 var ownKey = (store) => import_web3130.Keypair.fromSecretKey(Uint8Array.from(store.state.solanaSecretKey)).publicKey;
+var readFailure = (error) => [error?.name ?? "Error", error?.cause?.code, String(error?.message ?? "").replace(/[a-z][a-z0-9+.-]*:\/\/\S+/gi, "<url>").replace(/api[-_]?key=\S+/gi, "<key>").slice(0, 160)].filter(Boolean).join(" ");
 async function readOwnPublicBalance({ session, store }) {
   const owner = ownKey(store);
   const tokenAccount = getAssociatedTokenAddressSync(new import_web3130.PublicKey(store.state.asset), owner, false, TOKEN_PROGRAM_ID);
@@ -126602,7 +126768,7 @@ function createWalletTools({
       ]);
       if (answered.reading) {
         publicRead.then(({ error: late2 }) => {
-          if (late2) log(`MCP_PUBLIC_READ_FAILED_LATE ${late2?.name ?? "Error"}`);
+          if (late2) log(`MCP_PUBLIC_READ_FAILED_LATE ${readFailure(late2)}`);
         });
       }
       const { read, error } = answered;
@@ -126621,7 +126787,7 @@ function createWalletTools({
           unshieldedSolLamports: read.solLamports
         };
       } else {
-        log(`MCP_PUBLIC_READ_FAILED ${error?.name ?? "Error"}`);
+        log(`MCP_PUBLIC_READ_FAILED ${readFailure(error)}`);
         unshielded = {
           unshieldedAtomic: null,
           unshielded: null,
@@ -128050,7 +128216,7 @@ function runningBundleFile({ moduleUrl = new URL("__bundled_source__/wallet/src/
 function runningReleaseSha256({ bundleFile = runningBundleFile() } = {}) {
   if (!bundleFile) return Promise.resolve(void 0);
   return new Promise((done) => {
-    readFile(bundleFile, (error, bytes2) => done(error ? void 0 : createHash29("sha256").update(bytes2).digest("hex")));
+    readFile(bundleFile, (error, bytes2) => done(error ? void 0 : createHash30("sha256").update(bytes2).digest("hex")));
   });
 }
 async function checkWalletUpdate({ facilitator, ownSha256 = runningReleaseSha256, fetchReleaseImpl = fetchRelease } = {}) {
@@ -130125,7 +130291,7 @@ init_chain2();
 init_proxy();
 init_sealedCache();
 init_reference2();
-import { createHash as createHash30, createPublicKey as createPublicKey6, verify as verify3 } from "node:crypto";
+import { createHash as createHash31, createPublicKey as createPublicKey6, verify as verify3 } from "node:crypto";
 var PROGRAM_ID = new import_web3133.PublicKey("9fhQBbumKEFuXtMBDw8AaQyAjCorLGJQiS3skWZdQyQD");
 var USDC_MINT = new import_web3133.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
 var TREE_ACCOUNT = import_web3133.PublicKey.findProgramAddressSync([Buffer.from("merkle_tree"), USDC_MINT.toBuffer()], PROGRAM_ID)[0];
@@ -130134,7 +130300,7 @@ var TREE_ACCOUNT_BYTES = 4136;
 var NEXT_INDEX_OFFSET = 40;
 var ROOT_HISTORY_OFFSET = 912;
 var ROOT_HISTORY_SIZE_OFFSET = 4129;
-var EVENT_DISCRIMINATOR = createHash30("sha256").update("event:SplCommitmentData").digest().subarray(0, 8);
+var EVENT_DISCRIMINATOR = createHash31("sha256").update("event:SplCommitmentData").digest().subarray(0, 8);
 var EVENT_HEADER_BYTES = 84;
 var LOG_DATA = "Program data: ";
 var SIGNATURE_PAGE = 1e3;
@@ -132968,7 +133134,7 @@ var rpcFlags = [
 var HISTORY_RPC_FLAG = flag2(
   "--history-rpc",
   "<own|url>",
-  `where the pool's public history comes from (the history walk: its signature lists, transactions, and block signature lists). Default with --tor: the history proxy onion this wallet pins for the pool (the pool ${GUIDE.pool} has one; a pool without one uses your own RPC), so your RPC provider does not see that you read this pool; Default without --tor: the same history proxy over https on the facilitator's pay host (that host already serves your memos and payments), so a first walk takes seconds, not minutes of rate-limited RPC calls; a pool without one uses your own RPC. A line on stderr says which source the run uses. own: your own RPC serves it, with or without --tor, so your RPC provider sees that you read this pool. An https URL, or an http://<v3 onion>/ origin with --tor, serves it instead. That source sees that a client read this pool's public history (and your IP address unless you add --tor), not who; every wallet of the pool makes the same reads. A refresh asks it for every record of a fixed 256-record bucket of the pool's list and the newer ones, not only what is newer than your last refresh, so it sees that refresh only to the bucket (more reads than your own RPC needs). Your own RPC still serves the pool account that the history must match, and every read that names your wallet (your own payment, deposit, and pocket reads). If the source is a little behind the chain, the walk continues at once with the history up to the slot the source has reached, which matches when the pool did not change after that slot; only when it did, the walk asks the source again after 0.5 s, 1 s, 2 s, then every 5 s, for at most 60 s. The wallet checks the signatures of every transaction the source serves, and each refresh reads 3 of them, drawn at random, again on your own RPC (so your RPC provider sees 3 pool reads per refresh). If the source fails, stays behind, or serves history that does not match (a bad signature or a cross-check mismatch), the command stops and says so. It never falls back to your own RPC. A URL that holds an API key shows in the process list and shell history`,
+  `where the pool's public history comes from (the history walk: its signature lists, transactions, and block signature lists). Default with --tor: the history proxy onion this wallet pins for the pool (the pool ${GUIDE.pool} has one; a pool without one uses your own RPC), so your RPC provider does not see that you read this pool; Default without --tor: the same history proxy over https on the facilitator's pay host (that host already serves your memos and payments), so a first walk takes seconds, not minutes of rate-limited RPC calls; a pool without one uses your own RPC. A line on stderr says which source the run uses. own: your own RPC serves it, with or without --tor, so your RPC provider sees that you read this pool. An https URL, or an http://<v3 onion>/ origin with --tor, serves it instead. That source sees that a client read this pool's public history (and your IP address unless you add --tor), not who; every wallet of the pool makes the same reads. A refresh asks it for every record of a fixed 256-record bucket of the pool's list and the newer ones, not only what is newer than your last refresh, so it sees that refresh only to the bucket (more reads than your own RPC needs). Your own RPC still serves the pool account that the history must match, and every read that names your wallet (your own payment, deposit, and pocket reads). If the source is a little behind the chain, the walk continues at once with the history up to the slot the source has reached, which matches when the pool did not change after that slot; only when it did, the walk asks the source again every 0.15 s for about 2 s, then after 0.5 s, 1 s, 2 s, then every 5 s, for at most 60 s. The wallet checks the signatures of every transaction the source serves, and each refresh reads 3 of them, drawn at random, again on your own RPC (so your RPC provider sees 3 pool reads per refresh). If the source fails, stays behind, or serves history that does not match (a bad signature or a cross-check mismatch), the command stops and says so. It never falls back to your own RPC. A URL that holds an API key shows in the process list and shell history`,
   { check: "history-rpc" }
 );
 var recoverFlags = (options = {}) => [