shinjuku-shielded 0.3.42 → 0.3.44

package/manifest.json

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

package/shinjuku-wallet.mjs

@@ -96641,6 +96641,312 @@ var init_config = __esm({
   }
 });
 
+// wallet/src/seller/memoEcdhWorker.mjs
+import { Worker as Worker3 } from "node:worker_threads";
+function createMemoEcdhWorker(options) {
+  const threads = Array.from({ length: WORKER_THREADS }, () => createThread(options));
+  const compute = (memoBundle) => {
+    const records = Math.floor(memoBundle.length / MEMO_RECORD_BYTES2);
+    const share = Math.ceil(records / threads.length);
+    const jobs = [];
+    for (let index = 0; index < threads.length; index += 1) {
+      const from = index * share;
+      const to = Math.min(records, from + share);
+      if (from >= to) continue;
+      const job = threads[index].compute(memoBundle.subarray(from * MEMO_RECORD_BYTES2, to * MEMO_RECORD_BYTES2));
+      if (job !== void 0) jobs.push(job);
+    }
+    if (jobs.length === 0) return void 0;
+    const result = Promise.all(jobs.map((job) => job.result)).then((parts) => parts.flatMap((part) => part ?? [])).catch(() => void 0);
+    return { result, cancel: () => {
+      for (const job of jobs) job.cancel();
+    } };
+  };
+  return {
+    warm: () => {
+      for (const thread of threads) thread.warm();
+    },
+    compute: (memoBundle) => {
+      try {
+        return compute(memoBundle);
+      } catch {
+        return void 0;
+      }
+    },
+    close: () => {
+      for (const thread of threads) thread.close();
+    }
+  };
+}
+function createThread({ scalar, curvePointFromX, sharedXOf, log }) {
+  let worker;
+  let verified = false;
+  let disabled = false;
+  let closed = false;
+  let lastStartAt = -Infinity;
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const say6 = (line) => {
+    try {
+      log(line);
+    } catch {
+    }
+  };
+  const settleAll = () => {
+    for (const resolve38 of pending.values()) resolve38(void 0);
+    pending.clear();
+  };
+  const drop = (current) => {
+    if (worker !== current) return;
+    worker = void 0;
+    verified = false;
+    settleAll();
+    current.terminate().catch(() => void 0);
+  };
+  const post = (current, message) => {
+    try {
+      current.postMessage(message);
+      return true;
+    } catch {
+      drop(current);
+      return false;
+    }
+  };
+  const start = () => {
+    if (worker !== void 0 || disabled || closed || performance.now() - lastStartAt < WORKER_RESTART_MS) return;
+    lastStartAt = performance.now();
+    let current;
+    let expected;
+    try {
+      const point = curvePointFromX(CHECK_X);
+      expected = [point.x.toString(16), point.y.toString(16), sharedXOf(point).toString(16)].join(":");
+      current = new Worker3(WORKER_SOURCE2, { eval: true, execArgv: [], workerData: { scalar: scalar.toString() } });
+    } catch (error) {
+      say6(`SELLER_MEMO_ECDH_WORKER_START_FAILED ${error?.name ?? "Error"}`);
+      return;
+    }
+    worker = current;
+    const checkId = nextId++;
+    pending.set(checkId, (out) => {
+      if (worker !== current) return;
+      if (Array.isArray(out) && out.length === 1 && Array.isArray(out[0]) && out[0].join(":") === expected) {
+        verified = true;
+        return;
+      }
+      disabled = true;
+      say6("SELLER_MEMO_ECDH_WORKER_CHECK_FAILED the intake computes in the scan for this process");
+      drop(current);
+    });
+    current.on("message", (message) => {
+      try {
+        const resolve38 = pending.get(message?.id);
+        if (resolve38 === void 0) return;
+        pending.delete(message.id);
+        resolve38(message.failed === true || !Array.isArray(message.out) ? void 0 : message.out);
+      } catch {
+        drop(current);
+      }
+    });
+    current.on("error", (error) => {
+      if (worker === current) say6(`SELLER_MEMO_ECDH_WORKER_FAILED ${error?.name ?? "Error"}`);
+      drop(current);
+    });
+    current.on("messageerror", () => {
+      drop(current);
+    });
+    current.on("exit", (code) => {
+      if (worker === current && !closed) say6(`SELLER_MEMO_ECDH_WORKER_EXIT ${Number.isInteger(code) ? code : "?"}`);
+      drop(current);
+    });
+    current.unref();
+    post(current, { id: checkId, check: CHECK_X.toString() });
+  };
+  const compute = (memoBundle) => {
+    start();
+    const current = worker;
+    if (current === void 0) return void 0;
+    const id = nextId++;
+    const result = new Promise((resolve38) => {
+      pending.set(id, (out) => {
+        if (!verified || worker !== current || !Array.isArray(out)) {
+          resolve38(void 0);
+          return;
+        }
+        try {
+          resolve38(out.map((row) => {
+            if (!Array.isArray(row) || row.length !== 3 || !row.every((part) => /^[0-9a-f]{1,64}$/.test(part))) throw new Error("row");
+            return [`${BigInt(`0x${row[0]}`)}:${BigInt(`0x${row[1]}`)}`, BigInt(`0x${row[2]}`)];
+          }));
+        } catch {
+          resolve38(void 0);
+        }
+      });
+    }).catch(() => void 0);
+    if (!post(current, { id, bundle: Uint8Array.from(memoBundle) })) return void 0;
+    const cancel = () => {
+      const resolve38 = pending.get(id);
+      if (resolve38 === void 0) return;
+      pending.delete(id);
+      resolve38(void 0);
+      if (worker === current) post(current, { cancel: id });
+    };
+    return { result, cancel };
+  };
+  return {
+    warm: () => {
+      try {
+        start();
+      } catch {
+      }
+    },
+    compute: (memoBundle) => {
+      try {
+        return compute(memoBundle);
+      } catch {
+        return void 0;
+      }
+    },
+    close: () => {
+      closed = true;
+      const current = worker;
+      worker = void 0;
+      settleAll();
+      current?.terminate().catch(() => void 0);
+    }
+  };
+}
+var MEMO_RECORD_BYTES2, WORKER_RESTART_MS, WORKER_THREADS, CHECK_X, WORKER_SOURCE2;
+var init_memoEcdhWorker = __esm({
+  "wallet/src/seller/memoEcdhWorker.mjs"() {
+    "use strict";
+    MEMO_RECORD_BYTES2 = 200;
+    WORKER_RESTART_MS = 6e4;
+    WORKER_THREADS = 2;
+    CHECK_X = 5n;
+    WORKER_SOURCE2 = `"use strict";
+const { parentPort, workerData } = require("node:worker_threads");
+const P = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+const RECORD_BYTES = ${MEMO_RECORD_BYTES2};
+const SLICE_MS = 8;
+const mod = (value) => { const result = value % P; return result >= 0n ? result : result + P; };
+function powMod(baseInput, exponentInput) {
+  let base = mod(baseInput); let exponent = exponentInput; let result = 1n;
+  while (exponent > 0n) { if ((exponent & 1n) === 1n) result = mod(result * base); base = mod(base * base); exponent >>= 1n; }
+  return result;
+}
+function inverse(value) {
+  const normalized = mod(value);
+  if (normalized === 0n) throw new Error();
+  return powMod(normalized, P - 2n);
+}
+function inversePublic(value) {
+  let x = mod(value);
+  if (x === 0n) throw new Error();
+  let y = P; let u = 1n; let v = 0n;
+  while (x !== 0n) { const q = y / x; const r = y - q * x; y = x; x = r; const next = v - q * u; v = u; u = next; }
+  return mod(v);
+}
+const D = mod(-168696n * inverse(168700n));
+const LEGENDRE = (P - 1n) / 2n;
+let SQ = P - 1n; let SS = 0n;
+while ((SQ & 1n) === 0n) { SQ >>= 1n; SS += 1n; }
+const NON_RESIDUE_POWER = (() => { let z = 2n; while (powMod(z, LEGENDRE) !== P - 1n) z += 1n; return powMod(z, SQ); })();
+function sqrt(value) {
+  const normalized = mod(value);
+  if (normalized === 0n) return 0n;
+  const w = powMod(normalized, (SQ - 1n) / 2n);
+  let t = mod(w * w * normalized);
+  let legendre = t;
+  for (let square = 1n; square < SS; square += 1n) legendre = mod(legendre * legendre);
+  if (legendre !== 1n) return undefined;
+  let m = SS; let c = NON_RESIDUE_POWER; let root = mod(w * normalized);
+  while (t !== 1n) {
+    let i = 1n; let squared = mod(t * t);
+    while (squared !== 1n) { squared = mod(squared * squared); i += 1n; if (i >= m) throw new Error(); }
+    const b = powMod(c, 1n << (m - i - 1n));
+    root = mod(root * b); c = mod(b * b); t = mod(t * c); m = i;
+  }
+  return root;
+}
+function pointFromX(x) {
+  if (x >= P) throw new Error();
+  const x2 = mod(x * x);
+  const denominator = mod(1n - D * x2);
+  if (denominator === 0n) throw new Error();
+  const y = sqrt(mod((x2 + 1n) * inversePublic(denominator)));
+  if (y === undefined) throw new Error();
+  return { x, y };
+}
+const toExtended = (point) => ({ x: point.x, y: point.y, t: mod(point.x * point.y), z: 1n });
+const toTable = (point) => ({ x: point.x, y: point.y, t: point.t, z: point.z, dt: mod(D * point.t) });
+function addTable(left, right) {
+  const a = mod(left.x * right.x); const b = mod(left.y * right.y);
+  const c = mod(left.t * right.dt); const d = mod(left.z * right.z);
+  const h = b + a; const e = mod((left.x + left.y) * (right.x + right.y) - h);
+  const f = d - c; const g = d + c;
+  return { x: mod(e * f), y: mod(g * h), t: mod(e * h), z: mod(f * g) };
+}
+function double(point, withT) {
+  const a = mod(point.x * point.x); const b = mod(point.y * point.y);
+  const c = mod(2n * point.z * point.z); const sum = point.x + point.y;
+  const e = mod(sum * sum - a - b); const g = b - a; const f = g - c; const h = -a - b;
+  return { x: mod(e * f), y: mod(g * h), t: withT ? mod(e * h) : 0n, z: mod(f * g) };
+}
+function sharedX(point, scalar) {
+  const table = [toTable(toExtended({ x: 0n, y: 1n })), toTable(toExtended(point))];
+  for (let index = 2; index < 16; index += 1) table.push(toTable(addTable(table[index - 1], table[1])));
+  const windows = scalar === 0n ? 1 : Math.ceil(scalar.toString(2).length / 4);
+  let result = table[Number((scalar >> BigInt((windows - 1) * 4)) & 15n)];
+  for (let window = windows - 2; window >= 0; window -= 1) {
+    for (let bit = 0; bit < 4; bit += 1) result = double(result, bit === 3);
+    result = addTable(result, table[Number((scalar >> BigInt(window * 4)) & 15n)]);
+  }
+  return mod(result.x * inverse(result.z));
+}
+const scalar = BigInt(workerData.scalar);
+const cancelled = new Set();
+const queue = [];
+let running = false;
+function entry(x) { const point = pointFromX(x); return [point.x.toString(16), point.y.toString(16), sharedX(point, scalar).toString(16)]; }
+async function run() {
+  running = true;
+  while (queue.length > 0) {
+    const job = queue.shift();
+    for (const id of cancelled) if (id < job.id) cancelled.delete(id);
+    // A job cancelled while it waited in the queue is not started.
+    if (cancelled.has(job.id)) { cancelled.delete(job.id); parentPort.postMessage({ id: job.id, out: [] }); continue; }
+    const out = [];
+    try {
+      if (job.check !== undefined) out.push(entry(BigInt(job.check)));
+      else {
+        const bundle = job.bundle;
+        let sliceStart = performance.now();
+        for (let offset = 0; offset + RECORD_BYTES <= bundle.length; offset += RECORD_BYTES) {
+          if (performance.now() - sliceStart >= SLICE_MS) {
+            await new Promise((resolveTurn) => { setImmediate(resolveTurn); });
+            sliceStart = performance.now();
+            if (cancelled.has(job.id)) break;
+          }
+          try { out.push(entry(BigInt("0x" + Buffer.from(bundle.subarray(offset, offset + 32)).toString("hex")))); }
+          catch { /* no point: the scan refuses or skips it as before */ }
+        }
+      }
+      parentPort.postMessage({ id: job.id, out: cancelled.delete(job.id) ? [] : out });
+    } catch {
+      parentPort.postMessage({ id: job.id, failed: true });
+    }
+  }
+  running = false;
+}
+parentPort.on("message", (message) => {
+  if (message.cancel !== undefined) { cancelled.add(message.cancel); return; }
+  queue.push(message);
+  if (!running) run();
+});
+`;
+  }
+});
+
 // wallet/src/seller/service.mjs
 import { createServer } from "node:http";
 import { randomBytes as randomBytes17 } from "node:crypto";
@@ -96770,12 +97076,19 @@ async function createSellerAdapter({
   const signingBytes = Buffer.from(config.signingKey.slice(2), "hex");
   const signerPublicKey = `0x${Buffer.from(secp256k1.getPublicKey(signingBytes, true)).toString("hex")}`;
   deriveShieldedSolanaP03Recipient({ eta: config.eta, resourceNonce: randomBytes17(32), poolDomain: BigInt(profile.poolDomain) });
+  const ecdhScalar = config.eta % SHIELDED_SOLANA_P03_JUBJUB_SCALAR_MODULUS;
+  const sharedXOf = (point) => shieldedSolanaP03ScalarMultiply(point, ecdhScalar).x;
+  const sharedXByPoint = /* @__PURE__ */ new Map();
+  let precomputesRunning = 0;
   const scanner = new ShieldedSolanaP03MemoScanner({ ecdh: {
-    deriveSharedX: (point) => shieldedSolanaP03ScalarMultiply(
-      point,
-      config.eta % SHIELDED_SOLANA_P03_JUBJUB_SCALAR_MODULUS
-    ).x
+    deriveSharedX: (point) => sharedXByPoint.get(`${point.x}:${point.y}`) ?? sharedXOf(point)
   } });
+  const memoEcdh = createMemoEcdhWorker({
+    scalar: ecdhScalar,
+    curvePointFromX: shieldedSolanaP03CurvePointFromX,
+    sharedXOf,
+    log: (line) => console.error(line)
+  });
   const readChainAnchor = createAnchorReader({ connection: memoizeFinalizedReads(connection), profile });
   let anchorRequest;
   const requestFacilitatorAnchor = () => anchorRequest ??= (async () => {
@@ -97178,15 +97491,48 @@ async function createSellerAdapter({
     try {
       if (!offer.outboundJson) {
         const parsed = parseSolanaP03HttpPaymentPayload(payment.payload);
-        const auth = await issuer(offer.resource, payment.accepted.amount).authenticate({
-          requirements: payment.accepted,
-          resource: payment.resource,
-          publicInput7: parsed.publicInputs[7]
-        });
-        mark("intake-authenticated");
-        const intakeRead = readAnchor();
-        intakeRead.catch(() => void 0);
-        const recoveredNote = await scanner.recoverMerchantNoteYielding({ parsed, authenticatedQuote: auth });
+        const quoteIssuer = issuer(offer.resource, payment.accepted.amount);
+        const authInput = { requirements: payment.accepted, resource: payment.resource, publicInput7: parsed.publicInputs[7] };
+        await quoteIssuer.authenticateForClaim(authInput);
+        const authenticated = quoteIssuer.authenticate(authInput);
+        authenticated.catch(() => void 0);
+        const owned = { keys: [], done: false, cancel: void 0 };
+        let precomputed;
+        const job = precomputesRunning < MEMO_PRECOMPUTES_MAX ? memoEcdh.compute(parsed.memoBundle) : void 0;
+        if (job !== void 0) {
+          precomputesRunning += 1;
+          owned.cancel = job.cancel;
+          precomputed = job.result.then((entries) => {
+            if (entries === void 0 || owned.done) return;
+            for (const [key, sharedX] of entries) {
+              if (sharedXByPoint.has(key)) continue;
+              sharedXByPoint.set(key, sharedX);
+              owned.keys.push(key);
+            }
+          }).catch(() => void 0).finally(() => {
+            precomputesRunning -= 1;
+          });
+        }
+        let recoveredNote;
+        let intakeRead;
+        try {
+          const auth = await authenticated;
+          mark("intake-authenticated");
+          intakeRead = readAnchor();
+          intakeRead.catch(() => void 0);
+          if (precomputed !== void 0) {
+            let timer;
+            await Promise.race([precomputed, new Promise((resolveWait) => {
+              timer = setTimeout(resolveWait, MEMO_PRECOMPUTE_WAIT_MS);
+            })]);
+            clearTimeout(timer);
+          }
+          recoveredNote = await scanner.recoverMerchantNoteYielding({ parsed, authenticatedQuote: auth });
+        } finally {
+          owned.done = true;
+          owned.cancel?.();
+          for (const key of owned.keys) sharedXByPoint.delete(key);
+        }
         mark("intake-note-recovered");
         const chain = await intakeRead;
         intakeChain = chain;
@@ -97344,6 +97690,7 @@ async function createSellerAdapter({
     };
     await put(nonce, offer);
     mark("challenge");
+    memoEcdh.warm();
     return { status: 402, paymentRequired: issued.paymentRequired };
   }
   const server = createServer({ maxHeaderSize: 192 * 1024 }, async (request, response) => {
@@ -97398,6 +97745,7 @@ async function createSellerAdapter({
       }
     }
     closed = true;
+    memoEcdh.close();
     for (const timer of followUps.values()) clearTimeout(timer);
     followUps.clear();
   };
@@ -97415,7 +97763,7 @@ async function createSellerAdapter({
   }));
   return { server, handle, close, signerPublicKey, settledTransactions, offerSummaries };
 }
-var import_web3120, BINDING, SCHEMA2, OFFERS_LAYOUT, SNAPSHOT_EVERY_MS, LOADER2, canonical4, storeProfileIdentity, jsonSafe, bigint, encodeHeader, PAYMENT_REFUSED, FACILITATOR_UNDERFUNDED, DEFINITE_VERIFY_REFUSALS, definiteVerifyRefusal, refusedBeforeSettlement, ANCHOR_REQUEST_TIMEOUT_MS2, ANCHOR_POLL_ATTEMPTS, ANCHOR_POLL_MS, PRE_SETTLE_REUSE_MARGIN_S, PRE_SETTLE_REUSE_MAX_AGE_MS, FINALIZED_MEMO_MAX_AGE_MS, pause, FOLLOW_UP_DELAYS_MS, FOLLOW_UP_RESETTLE_FROM, CONFIRMED_TRANSACTION_READ;
+var import_web3120, BINDING, SCHEMA2, OFFERS_LAYOUT, SNAPSHOT_EVERY_MS, LOADER2, canonical4, storeProfileIdentity, jsonSafe, bigint, encodeHeader, PAYMENT_REFUSED, FACILITATOR_UNDERFUNDED, DEFINITE_VERIFY_REFUSALS, definiteVerifyRefusal, refusedBeforeSettlement, ANCHOR_REQUEST_TIMEOUT_MS2, ANCHOR_POLL_ATTEMPTS, ANCHOR_POLL_MS, MEMO_PRECOMPUTES_MAX, MEMO_PRECOMPUTE_WAIT_MS, PRE_SETTLE_REUSE_MARGIN_S, PRE_SETTLE_REUSE_MAX_AGE_MS, FINALIZED_MEMO_MAX_AGE_MS, pause, FOLLOW_UP_DELAYS_MS, FOLLOW_UP_RESETTLE_FROM, CONFIRMED_TRANSACTION_READ;
 var init_service = __esm({
   "wallet/src/seller/service.mjs"() {
     "use strict";
@@ -97432,6 +97780,7 @@ var init_service = __esm({
     init_config();
     init_receiptTransaction();
     init_timing();
+    init_memoEcdhWorker();
     BINDING = "carbon-shielded-exact/svm-v3";
     SCHEMA2 = "carbon-independent-seller-offers/v1";
     OFFERS_LAYOUT = "per-offer-v1";
@@ -97466,6 +97815,8 @@ var init_service = __esm({
     ANCHOR_REQUEST_TIMEOUT_MS2 = 9e4;
     ANCHOR_POLL_ATTEMPTS = 15;
     ANCHOR_POLL_MS = 2e3;
+    MEMO_PRECOMPUTES_MAX = 2;
+    MEMO_PRECOMPUTE_WAIT_MS = 1e3;
     PRE_SETTLE_REUSE_MARGIN_S = 60;
     PRE_SETTLE_REUSE_MAX_AGE_MS = 2e4;
     FINALIZED_MEMO_MAX_AGE_MS = 1e3;
@@ -126800,7 +127151,18 @@ function createWalletTools({
     ...share ? { share } : {}
   });
   let lastWriterEndedAt = 0;
-  const refreshWalk = ops.refreshWalk ?? (ops.refresh ? void 0 : (store) => walkWalletHistory(session, store));
+  let paysInFlight = 0;
+  let refreshDeferred = false;
+  let refreshForeground = false;
+  let refreshRunDeferred = false;
+  const REFRESH_DEFERRED = /* @__PURE__ */ Symbol("deferred refresh");
+  const runDeferredRefresh = () => {
+    if (!refreshDeferred || paysInFlight !== 0 || finalityWait || refreshRun || finalityClosed) return;
+    refreshDeferred = false;
+    refreshShared({ background: true }).catch(() => {
+    });
+  };
+  const refreshWalk = ops.refreshWalk ?? (ops.refresh ? void 0 : (store, share) => walkWalletHistory(session, store, share));
   const errorCode2 = (error, fallback) => describeError(error, { fallback, safeText: SAFE_TEXT }).split(/[\s:;(]/, 1)[0];
   const underLease = (task) => session.serial(async () => {
     let release;
@@ -126899,10 +127261,16 @@ function createWalletTools({
   };
   const withPoolSwitch = (tool) => ({ ...tool, run: async (...args) => {
     let output2;
+    const paying = tool.name === "x402_pay";
+    if (paying) paysInFlight += 1;
     try {
       output2 = await tool.run(...args);
     } finally {
       if (tool.annotations?.readOnlyHint !== true) lastWriterEndedAt = Date.now();
+      if (paying) {
+        paysInFlight -= 1;
+        runDeferredRefresh();
+      }
     }
     if (!succession || !output2 || output2.isError || typeof output2.text !== "string") return output2;
     const read = readSwitch();
@@ -126951,9 +127319,20 @@ function createWalletTools({
   });
   if (ops.oneTimeAdopt !== false) adopter.start();
   function refreshShared({ background = false } = {}) {
+    if (refreshRun && !background && refreshRunDeferred) return refreshRun.then(() => refreshShared(), () => refreshShared());
+    if (refreshRun && !background) refreshForeground = true;
     if (!refreshRun) {
       refreshInBackground = background;
+      refreshForeground = !background;
+      refreshRunDeferred = false;
       const calledAt = Date.now();
+      const deferNow = () => {
+        if (!background || refreshForeground || paysInFlight === 0) return false;
+        refreshRunDeferred = true;
+        refreshDeferred = true;
+        log("MCP_REFRESH_DEFERRED");
+        return true;
+      };
       refreshRun = (async () => {
         let early;
         if (background && refreshWalk) {
@@ -126961,18 +127340,21 @@ function createWalletTools({
             const store = session.openStore();
             const records = JSON.stringify(captureWalStates(store));
             const pool2 = store.state.pool;
-            early = { records, pool: pool2, history: await refreshWalk(store) };
+            early = { records, pool: pool2, history: await refreshWalk(store, { notBeforeMs: Math.max(calledAt, lastWriterEndedAt) }) };
           } catch {
             early = void 0;
           }
         }
         return underLease((store) => {
+          if (deferNow()) return REFRESH_DEFERRED;
+          refreshDeferred = false;
           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");
           const share = early !== void 0 && !same2 ? { notBeforeMs: Math.max(calledAt, lastWriterEndedAt) } : void 0;
           return refreshStep(store, same2 ? early.history : void 0, share);
         });
-      })().then(() => {
+      })().then((result) => {
+        if (result === REFRESH_DEFERRED) return;
         refreshFailedAt = 0;
         log("MCP_REFRESH_DONE");
       }, (error) => {
@@ -126981,8 +127363,12 @@ function createWalletTools({
         log(`MCP_REFRESH_FAILED ${refreshFailedCode}`);
         throw error;
       }).finally(() => {
+        const deferred = refreshRunDeferred;
         refreshRun = void 0;
         refreshInBackground = false;
+        refreshForeground = false;
+        refreshRunDeferred = false;
+        if (deferred || refreshDeferred) runDeferredRefresh();
       });
     }
     return refreshRun;
@@ -127053,6 +127439,7 @@ function createWalletTools({
       finalityWait = void 0;
       if (finalityClosed || finalityTarget === watched) finalityTarget = void 0;
       else startFinalityWait();
+      runDeferredRefresh();
     });
   }
   async function refreshIfStale() {
@@ -127473,7 +127860,7 @@ function createWalletTools({
       let refresh = {};
       const recentlyFailed = refreshFailedAt && Date.now() - refreshFailedAt < REFRESH_RETRY_MS && !refreshRun;
       if (report.split?.shieldedAtomic != null && report.status === "stale") {
-        if (!recentlyFailed && !finalityWait) refreshShared().catch(() => {
+        if (!recentlyFailed && (!finalityWait || refreshDeferred)) refreshShared().catch(() => {
         });
         refresh = { refreshing: true };
       } else if (report.split?.shieldedAtomic == null && recentlyFailed) {