shinjuku-shielded 0.3.30 → 0.3.32

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "a523d67b85ebcfd6f07f653c2a9bde16a7c9d87f908874ddae71cf91083fabc8",
-  "bytes": 11177579,
-  "sourceCommit": "025c6a4ab1a1c3e38019cdd7843b524a6a90d62a",
+  "sha256": "3ec79a8335ea99f87cf8f2c34ea8723c70a30bd6f30fc5c0fb177edfa1816714",
+  "bytes": 11184498,
+  "sourceCommit": "8bd35a850efa3fb8dac143ea02a6d02a3f4008c6",
   "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.30",
+  "version": "0.3.32",
   "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": "a523d67b",
-  "shinjukuSha256": "a523d67b85ebcfd6f07f653c2a9bde16a7c9d87f908874ddae71cf91083fabc8",
+  "shinjukuRelease": "3ec79a83",
+  "shinjukuSha256": "3ec79a8335ea99f87cf8f2c34ea8723c70a30bd6f30fc5c0fb177edfa1816714",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -50445,8 +50445,9 @@ function createMemoReader(baseUrl, { fetchImpl = fetch, pause: pause3 = pauseFor
   };
   const origin = new URL(baseUrl).origin;
   const keyOf2 = (digest2) => `${origin}|${digest2}`;
-  let ahead = prefetchedMemosByFetch.get(fetchImpl);
-  if (ahead === void 0) prefetchedMemosByFetch.set(fetchImpl, ahead = /* @__PURE__ */ new Map());
+  const aheadKey = typeof fetchImpl?.baseFetch === "function" ? fetchImpl.baseFetch : fetchImpl;
+  let ahead = prefetchedMemosByFetch.get(aheadKey);
+  if (ahead === void 0) prefetchedMemosByFetch.set(aheadKey, ahead = /* @__PURE__ */ new Map());
   const live = (key) => {
     const entry = ahead.get(key);
     if (entry !== void 0 && now() - entry.at > MEMO_PREFETCH_LIFE_MS) ahead.delete(key);
@@ -54852,6 +54853,23 @@ function foldCompactLeaves(leaves, counts) {
   });
   return roots;
 }
+function foldCompactLeavesReusing(pool2, leaves, counts) {
+  const prior = lastFolds.get(pool2);
+  let common = 0;
+  if (prior !== void 0) {
+    const most = Math.min(prior.leaves.length, leaves.length);
+    while (common < most && prior.leaves[common] === leaves[common]) common += 1;
+  }
+  const known = (at) => prior !== void 0 && at <= common && prior.roots.has(at);
+  const roots = foldCompactLeaves(leaves, new Set([...counts].filter((at) => !known(at))));
+  for (const at of counts) if (known(at)) roots.set(at, prior.roots.get(at));
+  const kept = new Map(roots);
+  if (prior !== void 0) {
+    for (const [at, root] of prior.roots) if (at <= common && !kept.has(at)) kept.set(at, root);
+  }
+  lastFolds.set(pool2, { leaves: leaves.slice(), roots: kept });
+  return roots;
+}
 function fieldOf(hex4) {
   if (typeof hex4 !== "string" || !HEX64.test(hex4)) throw refuse3("p03_compact_history_record_invalid");
   const value = BigInt(`0x${hex4}`);
@@ -55062,7 +55080,7 @@ function withBoundedOwnReads(connection) {
     }
   });
 }
-async function readPages(history, pool2, needed, first) {
+async function readPages(history, pool2, needed, first, { wakeSlot } = {}) {
   const records = [];
   const imports = [];
   let initialization;
@@ -55093,7 +55111,19 @@ async function readPages(history, pool2, needed, first) {
     initialization = result.initialization;
     syncedSlot = result.syncedSlot;
     records.push(...result.records);
-    if (result.total < needed) throw refuse3("p03_compact_history_source_behind");
+    if (result.total < needed) {
+      if (isIndex(wakeSlot)) {
+        Promise.resolve().then(() => history._rpcRequest("getP03Transitions", [pool2, {
+          commitment: "finalized",
+          fromOrdinal: 0,
+          toOrdinal: 1,
+          minContextSlot: wakeSlot
+        }])).catch(() => {
+        });
+        markPhase("compact-behind-wake");
+      }
+      throw refuse3("p03_compact_history_source_behind");
+    }
   }
   return { records: records.slice(0, needed), imports, initialization, syncedSlot };
 }
@@ -55322,7 +55352,12 @@ async function readCompactP03History({
   knownSnapshot,
   // compactP03HistoryReport: run beside the spot checks once the initialization is verified
   // ({ snapshot, initialization, contexts }); its result comes back as `alongside`.
-  alongside
+  alongside,
+  // Called once with the served contexts in chain order, before the fold and every own-RPC
+  // check: they are NOT verified yet. A payment asks the memo service for their memos here
+  // (payAndFetch.mjs), and uses an answer only for a context the verified report names. Its
+  // result and any throw are ignored.
+  onList
 }) {
   const program = new import_web397.PublicKey(programId);
   const poolKey = new import_web397.PublicKey(pool2);
@@ -55349,7 +55384,7 @@ async function readCompactP03History({
     initialization: served.initialization,
     syncedSlot: served.syncedSlot,
     cached: true
-  } : await readPages(source, poolString, count2, first);
+  } : await readPages(source, poolString, count2, first, { wakeSlot: snapshot.slot });
   markPhase(page.cached === true ? "compact-list-cached" : "compact-list");
   const binding = {
     programId: programString,
@@ -55375,6 +55410,10 @@ async function readCompactP03History({
     }
   });
   const imports = orderCompactImports(page.imports, contexts, { snapshot, replay });
+  try {
+    onList?.(contexts);
+  } catch {
+  }
   const picks = [];
   const order = [...contexts.keys()];
   const checks = page.cached === true ? 0 : spotChecks;
@@ -55406,7 +55445,7 @@ async function readCompactP03History({
   for (const anchor of anchors) counts.add(Number(anchor.index / SUBTREE_LEAVES3));
   if (appendRoots) for (let at = 1; at <= count2; at += 1) counts.add(at);
   for (const at of counts) if (at > count2) throw refuse3("p03_compact_history_snapshot_invalid");
-  roots = foldCompactLeaves(contexts.map((context) => context.outCommitment), counts);
+  roots = foldCompactLeavesReusing(poolString, contexts.map((context) => context.outCommitment), counts);
   if (roots.get(count2) !== snapshot.currentRoot) throw refuse3("p03_compact_history_root_mismatch");
   for (const anchor of anchors) {
     if (roots.get(Number(anchor.index / SUBTREE_LEAVES3)) !== anchor.root) throw refuse3("p03_compact_history_root_mismatch");
@@ -55470,7 +55509,8 @@ async function compactP03HistoryReport({
   forceRead = false,
   freshMs = 0,
   priorAttestation,
-  knownSnapshot
+  knownSnapshot,
+  onList
 }) {
   if (deploymentIdentity === void 0) throw new Error("p03_history_deployment_identity_required");
   const program = new import_web397.PublicKey(programId);
@@ -55539,6 +55579,7 @@ async function compactP03HistoryReport({
     pool: pool2,
     alongside: attest,
     ...knownSnapshot !== void 0 ? { knownSnapshot } : {},
+    ...onList !== void 0 ? { onList } : {},
     ...warm ? { served: cached.served } : {},
     ...cached ? { initialization: cached.initialization } : {}
   });
@@ -55616,7 +55657,7 @@ async function tryCompactP03HistoryReport(options) {
     return { ok: false, reason: refusalReason(error), ...typeof error?.detail === "string" ? { detail: error.detail } : {}, error };
   }
 }
-var import_web397, P03_COMPACT_HISTORY_SOURCE_MODEL, P03_COMPACT_PAGE, P03_COMPACT_SPOT_CHECKS, FIELD_MODULUS5, SUBTREE_LEAVES3, LOCAL_DEPTH2, OUTER_DEPTH2, PRIMARY_PROOF_BYTES2, FIELD_BYTES3, ED25519_SPKI_PREFIX2, VERSION_1_PREFIX2, HEX64, BASE58, REPLAY_STORE_INDEXED2, PROFILES2, MOVE_HEAD_BYTES2, MOVE_INSERTED_VALUES2, refuse3, hash4, bitAt, zeroRootsMemo, isSignature, isIndex, IMPORT_KEYS, IMPORT_MAX_VALUES, LIST_ATTEMPTS, OWN_READ_TIMEOUT_MS, BOUNDED_OWN_METHODS;
+var import_web397, P03_COMPACT_HISTORY_SOURCE_MODEL, P03_COMPACT_PAGE, P03_COMPACT_SPOT_CHECKS, FIELD_MODULUS5, SUBTREE_LEAVES3, LOCAL_DEPTH2, OUTER_DEPTH2, PRIMARY_PROOF_BYTES2, FIELD_BYTES3, ED25519_SPKI_PREFIX2, VERSION_1_PREFIX2, HEX64, BASE58, REPLAY_STORE_INDEXED2, PROFILES2, MOVE_HEAD_BYTES2, MOVE_INSERTED_VALUES2, refuse3, hash4, bitAt, zeroRootsMemo, lastFolds, isSignature, isIndex, IMPORT_KEYS, IMPORT_MAX_VALUES, LIST_ATTEMPTS, OWN_READ_TIMEOUT_MS, BOUNDED_OWN_METHODS;
 var init_compact = __esm({
   "wallet/src/history/compact.mjs"() {
     "use strict";
@@ -55727,6 +55768,7 @@ var init_compact = __esm({
     };
     hash4 = (left, right) => poseidon2([left, right], 3);
     bitAt = (value, level) => Math.floor(value / 2 ** level) % 2;
+    lastFolds = /* @__PURE__ */ new Map();
     isSignature = (value) => typeof value === "string" && value.length >= 64 && value.length <= 88 && BASE58.test(value);
     isIndex = (value) => Number.isSafeInteger(value) && value >= 0;
     IMPORT_KEYS = ["afterOrdinal", "instructionIndex", "record", "signature", "slot", "transactionIndex", "values"];
@@ -56299,7 +56341,7 @@ function prewarmWalletP03History(args) {
     return false;
   }
 }
-async function loadWalletP03HistoryNow({ store, connection: given, programId, pool: pool2, deploymentIdentity, cache, forceRead = false }) {
+async function loadWalletP03HistoryNow({ store, connection: given, programId, pool: pool2, deploymentIdentity, cache, forceRead = false, onCompactList }) {
   const { connection, source } = resolveHistorySource(given, pool2);
   announceHistorySource(source);
   const split5 = connection?.historyRpc;
@@ -56329,7 +56371,17 @@ async function loadWalletP03HistoryNow({ store, connection: given, programId, po
     }
   }
   if (split5 && cache === void 0 && (source === "pinned" || source === "flag")) {
-    const compact = await compactFirst({ store, connection, source, programId, pool: pool2, deploymentIdentity, forceRead, knownSnapshot: movedSnapshot });
+    const compact = await compactFirst({
+      store,
+      connection,
+      source,
+      programId,
+      pool: pool2,
+      deploymentIdentity,
+      forceRead,
+      knownSnapshot: movedSnapshot,
+      onCompactList
+    });
     if (compact !== void 0) {
       if (runKey !== void 0) rememberRunReport(runKey, compact);
       return compact;
@@ -56369,7 +56421,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 }) {
+async function compactFirst({ store, connection, source, programId, pool: pool2, deploymentIdentity, forceRead, knownSnapshot, onCompactList }) {
   const started = Date.now();
   let behindNoticed = false;
   let behindTries = 0;
@@ -56380,6 +56432,8 @@ async function compactFirst({ store, connection, source, programId, pool: pool2,
     pool: pool2,
     deploymentIdentity,
     forceRead,
+    // The served list, unverified, before its fold (compact.mjs onList): a payment's memo prefetch.
+    ...typeof onCompactList === "function" ? { onList: onCompactList } : {},
     cache: walletCompactHistoryCache(store),
     freshMs: HISTORY_WARM_FRESH_MS,
     // The walk cache's attestation, read only when the compact cache holds none.
@@ -60363,7 +60417,7 @@ async function runRecover({ store, connection, programId, digests, serviceUrl: s
   const pool2 = new import_web3102.PublicKey(state.pool);
   const chainProgramId = new import_web3102.PublicKey(programId);
   const poolStateRead = (async () => {
-    const poolState3 = await readPoolState2(connection, pool2);
+    const poolState3 = await (deps.poolState ?? readPoolState2(connection, pool2));
     if (!poolState3) throw new Error("pool account not found");
     if (!poolState3.owner.equals(chainProgramId)) throw new Error("pool account owner mismatch");
     markPhase("recover-pool");
@@ -62405,6 +62459,7 @@ var init_errorCodes = __esm({
       "fetch_url_refused",
       "fetch_offer_unsupported",
       "fetch_challenge_invalid",
+      "fetch_seller_unreachable",
       "fetch_session_closed",
       "fetch_max_payment_required",
       "mcp_cap_required",
@@ -70299,11 +70354,14 @@ async function runRecoveredP03NoteExit({
   }
   wal = { ...wal, state: "confirmed", signature };
   store.writeWal(walName2, wal);
-  poolState2 = await readPool2(connection, pool2, "finalized");
-  if (!poolState2 || !poolState2.owner.equals(chainProgramId) || poolState2.version !== 3) {
-    throw new Error("finalized note-exit pool postcondition invalid");
+  for (let attempt = 1; ; attempt += 1) {
+    history = await walkHistory();
+    poolState2 = await readPool2(connection, pool2, "finalized");
+    if (!poolState2 || !poolState2.owner.equals(chainProgramId) || poolState2.version !== 3) {
+      throw new Error("finalized note-exit pool postcondition invalid");
+    }
+    if (attempt >= 4 || history.finalizedPoolSnapshot.currentIndex === poolState2.currentIndex && history.finalizedPoolSnapshot.currentRoot === poolState2.currentRoot) break;
   }
-  history = await walkHistory();
   await prepareFold(history);
   const spentPath = buildRecoveryPath({
     history,
@@ -71906,6 +71964,9 @@ async function prepareRecoveredPayment({
   const generator = pinnedGenerator4();
   const viewing = deriveWalletViewingAuthority2({ seedBytes: seedBytes5(state), generator });
   const chainTime2 = deps.chainTime === void 0 ? startFinalizedChainTime(connection) : void 0;
+  const poolState2 = deps.recover === void 0 ? readPoolState2(connection, pool2) : void 0;
+  poolState2?.catch(() => {
+  });
   if (deps.provePayment === void 0 && proofTools !== void 0) {
     (deps.prewarmProof ?? ((tools) => setImmediate(() => {
       prewarmP03PaymentProofTools(tools).catch(() => {
@@ -71979,7 +72040,12 @@ async function prepareRecoveredPayment({
     digests,
     serviceUrl: serviceUrl2,
     fresh: true,
-    deps: { fetchImpl: deps.fetchImpl, finalizedHistory: history, transitionContextFor: history.transitionContextFor }
+    deps: {
+      fetchImpl: deps.fetchImpl,
+      finalizedHistory: history,
+      transitionContextFor: history.transitionContextFor,
+      ...poolState2 !== void 0 ? { poolState: poolState2 } : {}
+    }
   });
   markPhase("recover");
   const unspentAccounts = recovery.recovered.filter((entry) => entry.kind === "account" && entry.spendStatus === "unspent");
@@ -72222,6 +72288,7 @@ var init_prepareRecoveredPayment = __esm({
     init_recoveryPath();
     init_recoveredPayment();
     init_recover();
+    init_chain2();
     init_notes2();
     init_accountSelection();
     init_phaseTiming();
@@ -72326,7 +72393,7 @@ async function validateReceiptTransaction(connection, receipt, record, state, pr
     [{ signature: receipt.transaction, slot: status.slot, failed: false }],
     blockCache,
     transactions,
-    { commitment }
+    { commitment, positionWhen: () => false }
   );
   const settlements = targetInstructions([...transactions.values()], program).filter((instruction) => (instruction.data[0] === 4 || instruction.data[0] === COMPRESSED_SETTLE_TAG.payment || instruction.data[0] === E1_SETTLE_TAG.payment) && instruction.accounts[0] === pool2.toBase58());
   if (settlements.length !== 1) fail16("receipt_payment_instruction_missing");
@@ -91166,6 +91233,7 @@ async function readJson(response, limit) {
   }
 }
 async function readFloatConfig({ origin, fetchImpl = fetch }) {
+  const readAtMs = Date.now();
   let response;
   try {
     response = await fetchImpl(
@@ -91199,7 +91267,7 @@ async function readFloatConfig({ origin, fetchImpl = fetch }) {
   if (config?.schema !== FLOAT_CONFIG_SCHEMA || !DECIMAL3.test(String(config.feeAtomic ?? "")) || !DECIMAL3.test(String(config.largestAtomic ?? "")) || typeof config.network !== "string" || typeof config.asset !== "string" || !prefix || prefix.pathname !== FLOAT_PAY_PATH || prefix.href !== config.payUrlPrefix || !feePayerOk) {
     fail18("p03_float_config_unreadable");
   }
-  return {
+  const read = {
     feeAtomic: String(config.feeAtomic),
     largestAtomic: String(config.largestAtomic),
     network: config.network,
@@ -91207,6 +91275,23 @@ async function readFloatConfig({ origin, fetchImpl = fetch }) {
     payUrlPrefix: config.payUrlPrefix,
     pocketFeePayer: config.pocketFeePayer
   };
+  configCache.set(origin, { config: read, readAtMs });
+  return read;
+}
+function dropFloatConfigs() {
+  configCache.clear();
+}
+async function readFloatOffer({ origin, paymentRequired, store, fetchImpl = fetch }) {
+  const kept = configCache.get(origin);
+  if (kept && Date.now() - kept.readAtMs < CONFIG_CACHE_MS) {
+    try {
+      return { offer: floatOffer({ paymentRequired, store, config: kept.config }), config: kept.config };
+    } catch {
+      configCache.delete(origin);
+    }
+  }
+  const config = await readFloatConfig({ origin, fetchImpl });
+  return { offer: floatOffer({ paymentRequired, store, config }), config };
 }
 function floatOriginOf(floatOrigin, serviceUrl2) {
   const value = floatOrigin ?? serviceUrl2;
@@ -91300,7 +91385,7 @@ function withSellerResource(xPayment, record) {
   return patched;
 }
 function floatFetch(base, seen) {
-  return async (target, init = {}) => {
+  const wrapper = async (target, init = {}) => {
     const response = await base(target, keepAliveInit(init));
     const paid = Object.keys(init.headers ?? {}).some((name) => name.toLowerCase() === "payment-signature");
     if (paid || response.status === 402 || response.status < 400) return response;
@@ -91322,6 +91407,7 @@ function floatFetch(base, seen) {
     };
     return new Response(null, { status: 400 });
   };
+  return Object.defineProperty(wrapper, "baseFetch", { value: base });
 }
 function floatRefusalError(refusal2, record) {
   const extra = {
@@ -91468,6 +91554,7 @@ async function payViaFloat({
             continue;
           }
           dropUnsent();
+          dropFloatConfigs();
           throw floatRefusalError(seen.refusal, record);
         }
         if (PENDING_CODES.has(error?.sellerCode) && Date.now() < finishingUntil) {
@@ -91569,7 +91656,7 @@ function paidResult(record, replayed) {
     float: { floatId: record.floatId }
   };
 }
-var import_web3109, FLOAT_PAYMENT_SCHEMA, REGENERATE_CODES, FLOAT_PAYMENT_WAL_PREFIX, FLOAT_CONFIG_SCHEMA, FLOAT_PAY_PATH, MAX_BODY_BYTES, FLOAT_REFUND_ETA_SECONDS, REFUND_SETTLED_AFTER_MS, FINISHING_POLL_MS, FINISHING_LIMIT_MS, SELLER_TIMEOUT_MS, CONFIG_TIMEOUT_MS, DECIMAL3, POSITIVE, PENDING_CODES, hash8, fail18, floatPaymentWalName, plainText;
+var import_web3109, FLOAT_PAYMENT_SCHEMA, REGENERATE_CODES, FLOAT_PAYMENT_WAL_PREFIX, FLOAT_CONFIG_SCHEMA, FLOAT_PAY_PATH, MAX_BODY_BYTES, FLOAT_REFUND_ETA_SECONDS, REFUND_SETTLED_AFTER_MS, FINISHING_POLL_MS, FINISHING_LIMIT_MS, SELLER_TIMEOUT_MS, CONFIG_TIMEOUT_MS, CONFIG_CACHE_MS, DECIMAL3, POSITIVE, PENDING_CODES, hash8, fail18, floatPaymentWalName, configCache, plainText;
 var init_floatPay = __esm({
   "wallet/src/pay/floatPay.mjs"() {
     "use strict";
@@ -91598,6 +91685,7 @@ var init_floatPay = __esm({
     FINISHING_LIMIT_MS = 6e4;
     SELLER_TIMEOUT_MS = 12e4;
     CONFIG_TIMEOUT_MS = 3e4;
+    CONFIG_CACHE_MS = 6e4;
     DECIMAL3 = /^(0|[1-9][0-9]*)$/;
     POSITIVE = /^[1-9][0-9]*$/;
     PENDING_CODES = /* @__PURE__ */ new Set(["float_paid_finishing", "payment_pending_retry_same_payment"]);
@@ -91606,6 +91694,7 @@ var init_floatPay = __esm({
       throw Object.assign(new Error(code), extra);
     };
     floatPaymentWalName = (requestKey) => `${FLOAT_PAYMENT_WAL_PREFIX}${requestKey}`;
+    configCache = /* @__PURE__ */ new Map();
     plainText = (value) => value.replace(/[^ -~]+/g, " ").trim().slice(0, 300);
   }
 });
@@ -96223,6 +96312,7 @@ async function createSellerAdapter({
       return { status: original.result.status, result: original.result, receipt: original.receipt };
     }
     let offer = original;
+    let intakeChain;
     try {
       if (!offer.outboundJson) {
         const parsed = parseSolanaP03HttpPaymentPayload(payment.payload);
@@ -96237,6 +96327,7 @@ async function createSellerAdapter({
         const recoveredNote = await scanner.recoverMerchantNoteYielding({ parsed, authenticatedQuote: auth });
         mark("intake-note-recovered");
         const chain = await intakeRead;
+        intakeChain = chain;
         mark("intake-anchor-read");
         const issuedAt = Number(chain.chainTimestamp);
         const expiresAt = Math.min(issuedAt + 300, Number(payment.accepted.extra.validBefore));
@@ -96277,11 +96368,18 @@ async function createSellerAdapter({
         await put(nonce, offer);
         mark("intake-durable");
       }
+      const firstIntake = intakeChain !== void 0 && !offer.settleAttempted;
+      if (firstIntake) {
+        await readCurrentAnchor(intakeChain);
+        offer = { ...offer, phase: "settlement_pending", settleAttempted: true };
+        await put(nonce, offer);
+        mark("first-intake-settle");
+      }
       const preVerifyReadAt = Date.now();
       const preVerifyRead = offer.settleAttempted ? void 0 : readAnchor();
       preVerifyRead?.catch(() => void 0);
-      const claimed = await facilitator("claim", offer.outboundJson);
-      mark("claim");
+      const claimed = firstIntake ? void 0 : await facilitator("claim", offer.outboundJson);
+      if (!firstIntake) mark("claim");
       if (claimed) {
         offer = await persistReceipt(nonce, offer, claimed, mark);
         return { status: offer.result.status, result: offer.result, receipt: offer.receipt };
@@ -117778,6 +117876,7 @@ init_payResource();
 init_quote2();
 init_floatPay();
 init_walletHistory();
+init_recover();
 init_keepAlive();
 init_phaseTiming();
 init_chain2();
@@ -118053,8 +118152,8 @@ async function offeredPrice(paymentRequired, store, serviceUrl2) {
   }
   if (rail === "exact" && store) {
     const origin = new URL(serviceUrl2).origin;
-    const config = await readFloatConfig({ origin });
-    return { rail, amountAtomic: floatOffer({ paymentRequired, store, config }).paidAtomic, floatConfig: { origin, config } };
+    const { offer, config } = await readFloatOffer({ origin, paymentRequired, store });
+    return { rail, amountAtomic: offer.paidAtomic, floatConfig: { origin, config } };
   }
   let highest;
   for (const offer of paymentRequired.accepts) {
@@ -118128,7 +118227,7 @@ async function payAndFetch(session, url, init = {}, opts = {}) {
     let challenge3;
     if (!rerun) {
       if (store !== void 0) startHistoryPrewarm(session, store, mark);
-      const response = await fetch(target, keepAliveInit({
+      const response = await unpaidRequest(target, () => keepAliveInit({
         method,
         headers,
         ...body ? { body } : {},
@@ -118171,6 +118270,19 @@ async function payAndFetch(session, url, init = {}, opts = {}) {
     throw error;
   }
 }
+var UNPAID_NOT_SENT = /* @__PURE__ */ new Set(["UND_ERR_CONNECT_TIMEOUT", "ECONNREFUSED"]);
+async function unpaidRequest(target, init) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await fetch(target, init());
+    } catch (error) {
+      const code = typeof error?.cause?.code === "string" && /^[A-Z][A-Z0-9_]{2,40}$/.test(error.cause.code) ? error.cause.code : void 0;
+      if (attempt === 0 && UNPAID_NOT_SENT.has(code)) continue;
+      const cause = error?.name === "TimeoutError" ? "no answer in 120 s" : code ?? "network error";
+      fail20("fetch_seller_unreachable", `the seller did not answer the first, unpaid request (${cause}); nothing was paid`);
+    }
+  }
+}
 function startHistoryPrewarm(session, store, mark) {
   try {
     withPhaseScope(mark, "prewarm", () => prewarmWalletP03History({
@@ -118178,7 +118290,16 @@ function startHistoryPrewarm(session, store, mark) {
       connection: connectSplit(session.connection, session.historyUrl),
       programId: session.programId,
       pool: store.state.pool,
-      deploymentIdentity: session.proofTools.deploymentIdentity
+      deploymentIdentity: session.proofTools.deploymentIdentity,
+      // The memos the proof's recovery will read, asked when the compact list arrives, beside
+      // its fold, spot checks, and attestation (B2 #3, 2026-10-15: the recovery waited 0.18-0.44 s
+      // 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 });
+      }
     }));
   } catch {
   }
@@ -125282,8 +125403,7 @@ async function railOffer(paymentRequired, rail, store, facilitator) {
   }
   try {
     if (!facilitator) throw new Error("p03_float_origin_missing");
-    const config = await readFloatConfig({ origin: new URL(facilitator).origin });
-    const offer = floatOffer({ paymentRequired, store, config });
+    const { offer } = await readFloatOffer({ origin: new URL(facilitator).origin, paymentRequired, store });
     return { priceAtomic: offer.priceAtomic, feeAtomic: offer.feeAtomic, totalAtomic: offer.paidAtomic };
   } catch (error) {
     const refusal2 = floatRefusal(error) ?? ["p03_float_config_unreadable", "the price through Shinjuku could not be read; nothing was paid", "call x402_preview again in a minute"];
@@ -125534,15 +125654,16 @@ async function runShieldFromElsewhere({ session, depositId, amountAtomic, onStag
   const result = await (steps.submit ?? submitRelayedDeposit)(common);
   return { state: result.state, transaction: typeof result.receipt?.signature === "string" ? result.receipt.signature : null };
 }
-async function refreshWallet({ session, store }) {
+var walkWalletHistory = (session, store) => loadWalletP03History({
+  store,
+  connection: connectSplit(session.connection, session.historyUrl),
+  programId: session.programId,
+  pool: store.state.pool,
+  deploymentIdentity: session.proofTools.deploymentIdentity
+});
+async function refreshWallet({ session, store, history: walked }) {
   const walStates = captureWalStates(store);
-  const history = await loadWalletP03History({
-    store,
-    connection: connectSplit(session.connection, session.historyUrl),
-    programId: session.programId,
-    pool: store.state.pool,
-    deploymentIdentity: session.proofTools.deploymentIdentity
-  });
+  const history = walked ?? await walkWalletHistory(session, store);
   const result = await runRecover({
     store,
     connection: session.connection,
@@ -125788,7 +125909,9 @@ function createWalletTools({
   let refreshRun;
   let refreshFailedAt = 0;
   let refreshFailedCode;
-  const refreshStep = (store) => (ops.refresh ?? refreshWallet)({ session, store });
+  let refreshInBackground = false;
+  const refreshStep = (store, history) => (ops.refresh ?? refreshWallet)({ session, store, ...history ? { history } : {} });
+  const refreshWalk = ops.refreshWalk ?? (ops.refresh ? void 0 : (store) => walkWalletHistory(session, store));
   const errorCode2 = (error, fallback) => describeError(error, { fallback, safeText: SAFE_TEXT }).split(/[\s:;(]/, 1)[0];
   const underLease = (task) => session.serial(async () => {
     let release;
@@ -125932,9 +126055,27 @@ function createWalletTools({
     deps: ops.oneTimeAdopt && typeof ops.oneTimeAdopt === "object" ? ops.oneTimeAdopt : {}
   });
   if (ops.oneTimeAdopt !== false) adopter.start();
-  function refreshShared() {
+  function refreshShared({ background = false } = {}) {
     if (!refreshRun) {
-      refreshRun = underLease((store) => refreshStep(store)).then(() => {
+      refreshInBackground = background;
+      refreshRun = (async () => {
+        let early;
+        if (background && refreshWalk) {
+          try {
+            const store = session.openStore();
+            const records = JSON.stringify(captureWalStates(store));
+            const pool2 = store.state.pool;
+            early = { records, pool: pool2, history: await refreshWalk(store) };
+          } catch {
+            early = void 0;
+          }
+        }
+        return underLease((store) => {
+          const same2 = early !== void 0 && early.pool === store.state.pool && early.records === JSON.stringify(captureWalStates(store));
+          if (early !== void 0 && !same2) log("MCP_REFRESH_WALK_AGAIN");
+          return refreshStep(store, same2 ? early.history : void 0);
+        });
+      })().then(() => {
         refreshFailedAt = 0;
         log("MCP_REFRESH_DONE");
       }, (error) => {
@@ -125944,6 +126085,7 @@ function createWalletTools({
         throw error;
       }).finally(() => {
         refreshRun = void 0;
+        refreshInBackground = false;
       });
     }
     return refreshRun;
@@ -125976,7 +126118,7 @@ function createWalletTools({
         }
         if (watched === finalityTarget && status?.confirmationStatus === "finalized") {
           log("MCP_FINALITY_REFRESH");
-          await refreshShared().catch(() => {
+          await refreshShared({ background: true }).catch(() => {
           });
           return;
         }
@@ -126001,6 +126143,7 @@ function createWalletTools({
       return;
     }
     if (!stale || refreshFailedAt && Date.now() - refreshFailedAt < REFRESH_RETRY_MS) return;
+    if (refreshRun && refreshInBackground) return;
     await refreshShared().catch(() => {
     });
   }
@@ -126376,6 +126519,8 @@ function createWalletTools({
       );
     } else if (code.startsWith("wallet_spend_refused_")) {
       next = "the wallet file's own budget refused it (init --max-payment / --max-cumulative); nothing was paid. Read wallet_balance detail.budget";
+    } else if (code === "fetch_seller_unreachable") {
+      next = `Nothing was paid and nothing was sent to the seller. Call x402_pay again with request_id "${requestId}" and the same url, method, headers, and body (it never pays twice); if it fails the same way again, the seller is down: tell your owner`;
     } else if (code.startsWith("wallet_quote_refused_") || code.startsWith("fetch_")) {
       next = "nothing was paid; do not retry this URL unchanged";
     } else {
@@ -135589,6 +135734,7 @@ function failureHint(command, reason, deps, values) {
   if (/fetch_offer_unsupported/.test(reason)) {
     return `nothing was paid: the seller's 402 offers no scheme this wallet pays (shielded-exact, or standard exact through Shinjuku). Hidden-amount (confidential) payments are retired since 2026-10-11`;
   }
+  if (/fetch_seller_unreachable/.test(reason)) return "nothing was paid: the seller did not answer the first, unpaid request. Rerun the same command (same --request-id) later; if it fails again, the seller is down";
   if (/fetch_challenge_invalid/.test(reason)) return "nothing was paid: the seller's 402 is not a valid x402 v2 challenge (PAYMENT-REQUIRED header). Do not pay this seller until it sends one";
   if (/fetch_url_refused/.test(reason)) return "nothing was sent: use the https URL. Plain http goes only to a private host (localhost, 10.x, 192.168.x) or to an .onion inside a --tor run";
   if (/fetch_options_invalid/.test(reason)) {