shinjuku-shielded 0.3.63 → 0.3.65

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "f3c652001435e22d3e54232fe742166dd8dd5ae183b92c1a24274c7a52ed137c",
-  "bytes": 12174893,
-  "sourceCommit": "46ac2745bf8ffeabba0e0cfaf8d052b20d6313e4",
+  "sha256": "f1563e53fc8d137fe44e6fb65d7247fa157b3066b7129b41ef9f99d2e3061ba7",
+  "bytes": 12180292,
+  "sourceCommit": "274f1d09a81983902118eeb923b5a4093acd757c",
   "sourceDirty": false,
   "installRecordMatchesLockfile": true,
   "releaseRule": "valid only when two fresh npm ci --ignore-scripts builds on different OSes give the same sha256; installRecordMatchesLockfile true means every entry npm installed equals its package-lock.json entry and every entry not marked optional, devOptional included, is installed: an optional entry (a package for another platform) may be absent",
@@ -1282,5 +1282,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-10-22T08:20:53.830Z"
+  "publishedAt": "2026-10-22T10:20:32.328Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.63",
+  "version": "0.3.65",
   "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": "f3c65200",
-  "shinjukuSha256": "f3c652001435e22d3e54232fe742166dd8dd5ae183b92c1a24274c7a52ed137c",
+  "shinjukuRelease": "f1563e53",
+  "shinjukuSha256": "f1563e53fc8d137fe44e6fb65d7247fa157b3066b7129b41ef9f99d2e3061ba7",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -50664,11 +50664,12 @@ function poolLayoutForLength(length) {
 }
 function connect2(rpcUrl, commitment = "finalized", { timeoutMs, wrapFetch = (fetch2) => fetch2 } = {}) {
   const pooled = (input, init) => rpcFetch(input, rpcKeepAliveInit(input, init));
-  const fetch2 = wrapFetch(timeoutMs === void 0 ? pooled : async (input, init) => {
+  const fetch2 = wrapFetch(timeoutMs === void 0 ? pooled : async (input, { onResponseHead, ...init } = {}) => {
     const circuit = torCircuit();
     const timeout = AbortSignal.timeout(timeoutMs);
     try {
       const response = await pooled(input, { ...init, signal: init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout });
+      onResponseHead?.(response);
       const body = await response.text();
       const headers = new Headers(response.headers);
       headers.delete("content-encoding");
@@ -50682,13 +50683,24 @@ function connect2(rpcUrl, commitment = "finalized", { timeoutMs, wrapFetch = (fe
   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) => {
+    value: async (method, params, signal, onResponse) => {
+      let reported = false;
+      const onResponseHead = (response2) => {
+        if (reported) return;
+        reported = true;
+        try {
+          onResponse?.({ status: response2.status, contentLength: Number(response2.headers.get("content-length")) });
+        } catch {
+        }
+      };
       const response = await fetch2(rpcUrl, {
         method: "POST",
         signal,
+        onResponseHead,
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ jsonrpc: "2.0", id: `abortable-${nextId += 1}`, method, params })
       });
+      onResponseHead(response);
       return response.json();
     },
     enumerable: false,
@@ -53948,6 +53960,24 @@ function parseE1TreeHeader(header) {
     bufferSize: u642(72)
   };
 }
+function programDataAddressOf(program) {
+  const key = b58(program);
+  let address5 = PROGRAMDATA_ADDRESSES.get(key);
+  if (address5 === void 0) {
+    address5 = import_web396.PublicKey.findProgramAddressSync([new import_web396.PublicKey(key).toBuffer()], BPF_LOADER_UPGRADEABLE_PROGRAM_ID)[0];
+    PROGRAMDATA_ADDRESSES.set(key, address5);
+  }
+  return address5;
+}
+function reuseOptionRefused(connection) {
+  const endpoint2 = connection.rpcEndpoint;
+  return typeof endpoint2 === "string" ? REUSE_REFUSED_ENDPOINTS.has(endpoint2) : REUSE_REFUSED_CONNECTIONS.has(connection);
+}
+function rememberReuseOptionRefused(connection) {
+  const endpoint2 = connection.rpcEndpoint;
+  if (typeof endpoint2 === "string") REUSE_REFUSED_ENDPOINTS.add(endpoint2);
+  else REUSE_REFUSED_CONNECTIONS.add(connection);
+}
 function slicesRefused(connection) {
   const endpoint2 = connection.rpcEndpoint;
   return typeof endpoint2 === "string" ? SLICES_REFUSED_ENDPOINTS.has(endpoint2) : SLICES_REFUSED_CONNECTIONS.has(connection);
@@ -53961,20 +53991,41 @@ function slicesMethodMissing(error) {
   const message = String(error?.message ?? "");
   return /^(404|405|501)\b/.test(message) || /-3260[12]\b/.test(message);
 }
-function slicedAccountBytes(value, accountIndex) {
+function slicedAccountBytes(value, accountIndex, slices = POOL_SLICES) {
   if (value === null || typeof value !== "object" || typeof value.owner !== "string" || !Number.isSafeInteger(value.space) || value.space < 0 || !Array.isArray(value.data) || value.data.length !== 2 || value.data[1] !== "base64" || typeof value.data[0] !== "string") {
     return void 0;
   }
   const bytes2 = Buffer.from(value.data[0], "base64");
   if (bytes2.toString("base64") !== value.data[0]) return void 0;
   let expected = 0;
-  for (const [index, offset, length] of POOL_SLICES) {
+  for (const [index, offset, length] of slices) {
     if (index === accountIndex) expected += Math.max(0, Math.min(offset + length, value.space) - offset);
   }
   return bytes2.length === expected ? bytes2 : void 0;
 }
-function slicedSnapshot(result, program, pool2, tree) {
-  if (result === null || typeof result !== "object" || !Array.isArray(result.value) || result.value.length !== 2) return void 0;
+function slicedSnapshot(result, program, pool2, tree, programData) {
+  if (result === null || typeof result !== "object" || !Array.isArray(result.value) || result.value.length !== (programData === void 0 ? 2 : 3)) return void 0;
+  const snapshot = slicedPoolSnapshot(result, program, pool2, tree);
+  if (snapshot === void 0 || programData === void 0) return snapshot;
+  const value = result.value[2];
+  const data = slicedAccountBytes(value, 2, POOL_SLICES_WITH_PROGRAMDATA);
+  const newest = result.newestSignature;
+  if (data === void 0 || typeof value.executable !== "boolean" || newest === null || typeof newest !== "object" || typeof newest.signature !== "string" || !Number.isSafeInteger(newest.slot)) {
+    return snapshot;
+  }
+  return withPoolStateOf(snapshot, Object.freeze({
+    ...snapshot,
+    programDataReuse: Object.freeze({
+      slot: snapshot.slot,
+      address: programData.toBase58(),
+      owner: value.owner,
+      executable: value.executable,
+      data,
+      newestSignature: newest.signature
+    })
+  }));
+}
+function slicedPoolSnapshot(result, program, pool2, tree) {
   const [poolValue, treeValue] = result.value;
   const poolBytes2 = slicedAccountBytes(poolValue, 0);
   if (poolBytes2 === void 0 || poolValue.space > REFRESH_READ_BYTES) return void 0;
@@ -54003,22 +54054,37 @@ function slicedSnapshot(result, program, pool2, tree) {
 async function readFinalizedPoolSliced(connection, program, pool2) {
   if (typeof connection._rpcRequest !== "function" || slicesRefused(connection)) return void 0;
   const tree = new import_web396.PublicKey(e1TreeAddress2(b58(pool2), b58(program)));
+  const programData = reuseOptionRefused(connection) ? void 0 : programDataAddressOf(program);
+  const params = programData === void 0 ? [[b58(pool2), tree.toBase58()], { commitment: "finalized", slices: POOL_SLICES }] : [
+    [b58(pool2), tree.toBase58(), programData.toBase58()],
+    { commitment: "finalized", slices: POOL_SLICES_WITH_PROGRAMDATA, newestSignature: 2 }
+  ];
   let response;
   try {
-    response = await connection._rpcRequest(P03_POOL_SLICES_METHOD, [[b58(pool2), tree.toBase58()], { commitment: "finalized", slices: POOL_SLICES }]);
+    response = await connection._rpcRequest(P03_POOL_SLICES_METHOD, params);
   } catch (error) {
+    if (programData !== void 0 && /-32602\b/.test(String(error?.message ?? ""))) {
+      rememberReuseOptionRefused(connection);
+      markPhase("pool-sliced-reuse-refused");
+      return readFinalizedPoolSliced(connection, program, pool2);
+    }
     if (slicesMethodMissing(error)) rememberSlicesRefused(connection);
     markPhase(`pool-sliced-fallback-${reuseRefusalCause(error)}`);
     return void 0;
   }
   if (response?.error !== void 0) {
+    if (programData !== void 0 && response.error?.code === -32602) {
+      rememberReuseOptionRefused(connection);
+      markPhase("pool-sliced-reuse-refused");
+      return readFinalizedPoolSliced(connection, program, pool2);
+    }
     if (response.error?.code === -32601 || response.error?.code === -32602) rememberSlicesRefused(connection);
     markPhase("pool-sliced-fallback-refused");
     return void 0;
   }
   let snapshot;
   try {
-    snapshot = slicedSnapshot(response?.result, program, pool2, tree);
+    snapshot = slicedSnapshot(response?.result, program, pool2, tree, programData);
   } catch {
     snapshot = void 0;
   }
@@ -54129,13 +54195,14 @@ async function readProgramDataHeader({ connection, address: address5, snapshotSl
     minContextSlot: snapshotSlot,
     dataSlice: { offset: 0, length: 45 }
   }));
-  const observedSlot = safeSlot(account2?.context?.slot, "programdata_snapshot_slot");
-  const value = account2?.value;
+  assertProgramDataHeader(safeSlot(account2?.context?.slot, "programdata_snapshot_slot"), account2?.value, { snapshotSlot, deployedAtSlot });
+}
+function assertProgramDataHeader(observedSlot, value, { snapshotSlot, deployedAtSlot }) {
   if (observedSlot < snapshotSlot || !value || !canonicalKey(value.owner, "programdata_owner").equals(BPF_LOADER_UPGRADEABLE_PROGRAM_ID) || value.executable === true) {
     throw new Error("p03_history_programdata_account_invalid");
   }
   const data = Buffer.from(value.data);
-  if (data.length < 45 || data.readUInt32LE(0) !== 3 || data.readBigUInt64LE(4) !== deployedAtSlot) {
+  if (data.length < PROGRAMDATA_HEADER_BYTES || data.readUInt32LE(0) !== 3 || data.readBigUInt64LE(4) !== deployedAtSlot) {
     throw new Error("p03_history_programdata_identity_invalid");
   }
 }
@@ -54204,7 +54271,11 @@ async function programDataCoverageFor({
   // 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
+  reuseConnection = connection,
+  // The pool snapshot's `programDataReuse` (readFinalizedPoolSliced, 2026-10-22): the same two facts
+  // from the same RPC as the pool account, at its slot. Used instead of the two reads only when it
+  // is at `snapshotSlot` and names the cached attestation's address; checked exactly as they are.
+  reuseAnswer
 }) {
   if (deploymentIdentity === void 0) return { coverage: void 0, attestation: void 0, reused: false };
   let priorRefused = false;
@@ -54212,27 +54283,43 @@ async function programDataCoverageFor({
   const key = coverageKey({ program, initialization, deploymentIdentity });
   if (key !== void 0 && prior?.key === key && typeof prior.newestSignature === "string" && prior.coverage?.throughFinalizedSlot <= BigInt(snapshotSlot)) {
     const address5 = new import_web396.PublicKey(prior.coverage.programDataAddress);
-    for (let attempt = 1; ; attempt += 1) {
+    const deployedAtSlot = BigInt(prior.coverage.deployedAtSlot);
+    const reuse = (signature2) => {
+      const coverage2 = Object.freeze({ ...prior.coverage, throughFinalizedSlot: BigInt(snapshotSlot) });
+      return { coverage: coverage2, attestation: { key, newestSignature: signature2, coverage: coverage2 }, reused: true };
+    };
+    const pooled = reuseAnswer !== void 0 && reuseAnswer.slot === snapshotSlot && reuseAnswer.address === address5.toBase58() ? reuseAnswer : void 0;
+    if (pooled !== void 0) {
       try {
-        const [, newest2] = await Promise.all([
-          readProgramDataHeader({
-            connection: reuseConnection,
-            address: address5,
-            snapshotSlot,
-            deployedAtSlot: BigInt(prior.coverage.deployedAtSlot)
-          }),
-          newestSignature(reuseConnection, address5, snapshotSlot)
-        ]);
-        if (newest2.signature === prior.newestSignature) {
-          const coverage2 = Object.freeze({ ...prior.coverage, throughFinalizedSlot: BigInt(snapshotSlot) });
-          return { coverage: coverage2, attestation: { key, newestSignature: newest2.signature, coverage: coverage2 }, reused: true };
+        assertProgramDataHeader(pooled.slot, pooled, { snapshotSlot, deployedAtSlot });
+        if (pooled.newestSignature === prior.newestSignature) {
+          markPhase("attest-reuse-in-pool-read");
+          return reuse(pooled.newestSignature);
         }
         cause = "programdata_newest_signature_changed";
-        break;
       } catch (error) {
         cause = reuseRefusalCause(error);
-        if (attempt >= 2 || typeof onReuseRetry !== "function" || !isTransientRpcError(error)) break;
-        await onReuseRetry({ cause });
+      }
+    } else {
+      for (let attempt = 1; ; attempt += 1) {
+        try {
+          const [, newest2] = await Promise.all([
+            readProgramDataHeader({
+              connection: reuseConnection,
+              address: address5,
+              snapshotSlot,
+              deployedAtSlot
+            }),
+            newestSignature(reuseConnection, address5, snapshotSlot)
+          ]);
+          if (newest2.signature === prior.newestSignature) return reuse(newest2.signature);
+          cause = "programdata_newest_signature_changed";
+          break;
+        } catch (error) {
+          cause = reuseRefusalCause(error);
+          if (attempt >= 2 || typeof onReuseRetry !== "function" || !isTransientRpcError(error)) break;
+          await onReuseRetry({ cause });
+        }
       }
     }
     priorRefused = true;
@@ -55680,7 +55767,7 @@ function base58Decode(value) {
   while (zeros < value.length && value[zeros] === "1") zeros += 1;
   return Uint8Array.from(Buffer.concat([Buffer.alloc(zeros), body]));
 }
-var import_web396, b58Cache, b58, REPLAY_STORE_INDEXED, CLOSE_REPLAY_TREE_TAG, EXTEND_ANCHOR_RING_TAG, WIDEN_ANCHOR_RING_TAG, WIDE_ANCHOR_RING_POOL_BYTES, LINK_SUCCESSOR_TAG, IMPORT_REPLAY_LEAVES_TAG, SETTLE_MOVE_TAG, SWEEP_PREDECESSOR_VAULT_TAG, RELINK_SUCCESSOR_TAG, ROTATE_PAYMENT_SETTLER_TAG, IMPORT_A_LEAF_BYTES, IMPORT_MEMBERSHIP_BYTES, IMPORT_PRESENT_SHIFT, IMPORT_MAX_ENTRIES, MOVE_HEAD_BYTES, MOVE_INSERTED_VALUES, DEFAULT_KEY, FIELD_BYTES2, PRIMARY_PROOF_BYTES, SUBTREE_LEAVES, PAGE_SIZE, FIELD_MODULUS3, BPF_LOADER_UPGRADEABLE_PROGRAM_ID, SYSTEM_PROGRAM, TEST_EXECUTABLES, derivationMemo, memo, reviewedExecutables, isProgramDataIdentityError, ASSUMED_ORIGINAL_EXECUTABLE, AUTHENTICATED_HISTORY_REPORTS, HISTORY_ATTESTATIONS, SNAPSHOT_POOL_STATES, REPORT_POOL_STATES, hasExecutableEvidence, P03_FINALIZED_HISTORY_SOURCE_MODEL, P03_PROGRAMDATA_COVERAGE_SOURCE_MODEL, P03_RUN_RECOVER_UNAVAILABLE_FROM_CHAIN, PROFILES, P03_SETTLEMENT_TAGS, P03_INLINE_SETTLEMENT_TAGS, P03_PAYMENT_REPLAY_INDICES, NO_CONTEXTS, REFRESH_READ_BYTES, E1_TREE_HEADER_BYTES, E1_TREE_MAGIC, E1_CHANGELOG_BYTES, E1_CHANGELOGS_OFFSET, E1_RIGHTMOST_OFFSET, E1_LEAF_COUNT_OFFSET, E1_CANOPY_OFFSET, E1_CANOPY_NODES, P03_POOL_SLICES_METHOD, POOL_SLICES, SLICED_ROOTS_OFFSET, SLICED_LEAVES_OFFSET, SLICES_REFUSED_ENDPOINTS, SLICES_REFUSED_CONNECTIONS, HISTORY_FETCH_CONCURRENCY, HISTORY_BULK_TRANSACTIONS, HISTORY_BULK_ADDRESSES, TRANSIENT_RPC_ATTEMPTS, TRANSIENT_RPC_BASE_DELAY_MS, LAGGING_NODE_STEP_OF_BASE, LAGGING_NODE_MAX_RETRIES, LAGGING_NODE_FAST_RETRIES, LAGGING_NODE_SLOW_STEP_OF_BASE, LAGGING_NODE_RPC_CODES, lastVerifiedE1Tree, e1ReplayCounts, e1TreeCandidate;
+var import_web396, b58Cache, b58, REPLAY_STORE_INDEXED, CLOSE_REPLAY_TREE_TAG, EXTEND_ANCHOR_RING_TAG, WIDEN_ANCHOR_RING_TAG, WIDE_ANCHOR_RING_POOL_BYTES, LINK_SUCCESSOR_TAG, IMPORT_REPLAY_LEAVES_TAG, SETTLE_MOVE_TAG, SWEEP_PREDECESSOR_VAULT_TAG, RELINK_SUCCESSOR_TAG, ROTATE_PAYMENT_SETTLER_TAG, IMPORT_A_LEAF_BYTES, IMPORT_MEMBERSHIP_BYTES, IMPORT_PRESENT_SHIFT, IMPORT_MAX_ENTRIES, MOVE_HEAD_BYTES, MOVE_INSERTED_VALUES, DEFAULT_KEY, FIELD_BYTES2, PRIMARY_PROOF_BYTES, SUBTREE_LEAVES, PAGE_SIZE, FIELD_MODULUS3, BPF_LOADER_UPGRADEABLE_PROGRAM_ID, SYSTEM_PROGRAM, TEST_EXECUTABLES, derivationMemo, memo, reviewedExecutables, isProgramDataIdentityError, ASSUMED_ORIGINAL_EXECUTABLE, AUTHENTICATED_HISTORY_REPORTS, HISTORY_ATTESTATIONS, SNAPSHOT_POOL_STATES, REPORT_POOL_STATES, hasExecutableEvidence, P03_FINALIZED_HISTORY_SOURCE_MODEL, P03_PROGRAMDATA_COVERAGE_SOURCE_MODEL, P03_RUN_RECOVER_UNAVAILABLE_FROM_CHAIN, PROFILES, P03_SETTLEMENT_TAGS, P03_INLINE_SETTLEMENT_TAGS, P03_PAYMENT_REPLAY_INDICES, NO_CONTEXTS, REFRESH_READ_BYTES, E1_TREE_HEADER_BYTES, E1_TREE_MAGIC, E1_CHANGELOG_BYTES, E1_CHANGELOGS_OFFSET, E1_RIGHTMOST_OFFSET, E1_LEAF_COUNT_OFFSET, E1_CANOPY_OFFSET, E1_CANOPY_NODES, P03_POOL_SLICES_METHOD, POOL_SLICES, PROGRAMDATA_HEADER_BYTES, POOL_SLICES_WITH_PROGRAMDATA, SLICED_ROOTS_OFFSET, SLICED_LEAVES_OFFSET, SLICES_REFUSED_ENDPOINTS, SLICES_REFUSED_CONNECTIONS, REUSE_REFUSED_ENDPOINTS, REUSE_REFUSED_CONNECTIONS, PROGRAMDATA_ADDRESSES, HISTORY_FETCH_CONCURRENCY, HISTORY_BULK_TRANSACTIONS, HISTORY_BULK_ADDRESSES, TRANSIENT_RPC_ATTEMPTS, TRANSIENT_RPC_BASE_DELAY_MS, LAGGING_NODE_STEP_OF_BASE, LAGGING_NODE_MAX_RETRIES, LAGGING_NODE_FAST_RETRIES, LAGGING_NODE_SLOW_STEP_OF_BASE, LAGGING_NODE_RPC_CODES, lastVerifiedE1Tree, e1ReplayCounts, e1TreeCandidate;
 var init_walk = __esm({
   "wallet/src/history/walk.mjs"() {
     "use strict";
@@ -55955,10 +56042,15 @@ var init_walk = __esm({
       ...Array.from({ length: E1.bufferSize }, (_, index) => Object.freeze([1, E1_CHANGELOGS_OFFSET + E1_CHANGELOG_BYTES * index, 32])),
       Object.freeze([1, E1_LEAF_COUNT_OFFSET, 4])
     ]);
+    PROGRAMDATA_HEADER_BYTES = 45;
+    POOL_SLICES_WITH_PROGRAMDATA = Object.freeze([...POOL_SLICES, Object.freeze([2, 0, PROGRAMDATA_HEADER_BYTES])]);
     SLICED_ROOTS_OFFSET = E1_TREE_HEADER_BYTES;
     SLICED_LEAVES_OFFSET = SLICED_ROOTS_OFFSET + 32 * E1.bufferSize;
     SLICES_REFUSED_ENDPOINTS = /* @__PURE__ */ new Set();
     SLICES_REFUSED_CONNECTIONS = /* @__PURE__ */ new WeakSet();
+    REUSE_REFUSED_ENDPOINTS = /* @__PURE__ */ new Set();
+    REUSE_REFUSED_CONNECTIONS = /* @__PURE__ */ new WeakSet();
+    PROGRAMDATA_ADDRESSES = /* @__PURE__ */ new Map();
     HISTORY_FETCH_CONCURRENCY = 4;
     HISTORY_BULK_TRANSACTIONS = 256;
     HISTORY_BULK_ADDRESSES = 256;
@@ -57839,6 +57931,8 @@ async function compactP03HistoryReportRun({
           getAccountInfoAndContext: (...args) => boundedOwnRead(() => own.getAccountInfoAndContext(...args)),
           getSignaturesForAddress: (...args) => boundedOwnRead(() => own.getSignaturesForAddress(...args))
         }))(connection.historyRpcOwnConnection) },
+        // The same two facts from the pool account's own read, when it carried them (readFinalizedPoolSliced).
+        ...snapshot2.programDataReuse === void 0 ? {} : { reuseAnswer: snapshot2.programDataReuse },
         program,
         initialization: initialization2,
         snapshotSlot: snapshot2.slot,
@@ -59082,13 +59176,23 @@ async function waitForCompactSource(source, pool2, slot3, budgetMs) {
   const until = Date.now() + budgetMs;
   for (; ; ) {
     const abort = new AbortController();
+    let answerBytes;
     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 }));
+    const read = (typeof source.abortableRpcRequest === "function" ? source.abortableRpcRequest("getP03Transitions", params, abort.signal, ({ contentLength }) => {
+      answerBytes = contentLength;
+    }) : source._rpcRequest("getP03Transitions", params)).catch(() => ({ failed: true }));
     let timer;
-    const answer = await Promise.race([read, new Promise((resolve38) => {
+    let answer = await Promise.race([read, new Promise((resolve38) => {
       timer = setTimeout(resolve38, Math.max(inTorRun() ? COMPACT_BEHIND_TOR_READ_MS : COMPACT_BEHIND_READ_MS, until - Date.now()));
     })]);
     clearTimeout(timer);
+    if (answer === void 0 && answerBytes > COMPACT_BEHIND_REFUSAL_MAX_BYTES) {
+      markPhase("compact-behind-page-coming");
+      answer = await Promise.race([read, new Promise((resolve38) => {
+        timer = setTimeout(resolve38, COMPACT_BEHIND_PAGE_BODY_MS);
+      })]);
+      clearTimeout(timer);
+    }
     if (answer === void 0) abort.abort();
     if (answer?.result !== void 0) {
       markPhase("compact-behind-caught-up");
@@ -59149,7 +59253,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 prepareReport, strictScope, withStrictHistorySource, recentScope, withRecentWalletHistory, recentLoads, forgetRecentWalletHistory, proofBuiltAt, historyCacheKey, latestPrewarm, HOME_MARKS_SETTLED_MS, HISTORY_PREWARM_JOIN_MS, SHARED_WALK_WAIT_MS, PAGE0_PREREAD_AFTER_MS, SUBTREE_LEAVES4, prewarmedWalks, sharedWalks, PREWARMED_REPORTS, PAYMENT_TAKEN_REPORTS, isPrewarmedWalletHistory, REPORT_STARTED_AT, walkStartedAtOf, COMPACT_BEHIND_POLL_MS, COMPACT_BEHIND_READ_MS, COMPACT_BEHIND_TOR_READ_MS, COMPACT_BEHIND_RETRY_MS, lastRunReports, writeStderr, announcedSources;
+var prepareReport, strictScope, withStrictHistorySource, recentScope, withRecentWalletHistory, recentLoads, forgetRecentWalletHistory, proofBuiltAt, historyCacheKey, latestPrewarm, HOME_MARKS_SETTLED_MS, HISTORY_PREWARM_JOIN_MS, SHARED_WALK_WAIT_MS, PAGE0_PREREAD_AFTER_MS, SUBTREE_LEAVES4, prewarmedWalks, sharedWalks, PREWARMED_REPORTS, PAYMENT_TAKEN_REPORTS, isPrewarmedWalletHistory, REPORT_STARTED_AT, walkStartedAtOf, COMPACT_BEHIND_POLL_MS, COMPACT_BEHIND_READ_MS, COMPACT_BEHIND_TOR_READ_MS, COMPACT_BEHIND_REFUSAL_MAX_BYTES, COMPACT_BEHIND_PAGE_BODY_MS, COMPACT_BEHIND_RETRY_MS, lastRunReports, writeStderr, announcedSources;
 var init_walletHistory = __esm({
   "wallet/src/history/walletHistory.mjs"() {
     "use strict";
@@ -59192,6 +59296,8 @@ var init_walletHistory = __esm({
     COMPACT_BEHIND_POLL_MS = 150;
     COMPACT_BEHIND_READ_MS = 1e3;
     COMPACT_BEHIND_TOR_READ_MS = 5e3;
+    COMPACT_BEHIND_REFUSAL_MAX_BYTES = 8192;
+    COMPACT_BEHIND_PAGE_BODY_MS = HISTORY_RPC_REQUEST_TIMEOUT_MS;
     COMPACT_BEHIND_RETRY_MS = [500, 1e3, 2e3, 5e3];
     lastRunReports = /* @__PURE__ */ new Map();
     writeStderr = (text3) => {
@@ -97639,7 +97745,7 @@ async function payResourceOnce({
         mark("challenge");
       }
       const { requirement, recipient } = validateChallenge(record.paymentRequired, store, url, maximumAtomic, method);
-      const chainTime2 = await (chainTimeRead ?? startFinalizedChainTime(connection))();
+      const chainTime2 = await withPhaseScope(mark, "quote", () => (chainTimeRead ?? startFinalizedChainTime(connection))());
       chainTimeRead = void 0;
       if (!requoted && Number.isSafeInteger(chainTime2) && Number(requirement.extra.validBefore) - chainTime2 < QUOTE_MARGIN_SECONDS && store.readWal(`resource-proof-${requestKey}`)?.proved === void 0) {
         requote();