shinjuku-shielded 0.3.40 → 0.3.42

package/manifest.json

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

package/shinjuku-wallet.mjs

@@ -48426,10 +48426,21 @@ function walNames(directory) {
   });
 }
 function bindWalDirectory(directory, key, claim = true) {
-  mkdirSync(directory, { recursive: true, mode: 448 });
   const ownerPath = join3(directory, WAL_OWNER_FILE);
+  const verified = verifiedWalOwners.get(key);
+  try {
+    if (verified?.get(resolve3(directory)) === ownerStatId(ownerPath)) return;
+  } catch {
+  }
+  mkdirSync(directory, { recursive: true, mode: 448 });
   const identity = createHmac("sha256", key).update(WAL_OWNER_SCHEMA).digest("hex");
   const verifyOwner = () => {
+    let statId;
+    try {
+      statId = ownerStatId(ownerPath);
+    } catch {
+      statId = void 0;
+    }
     let owner;
     try {
       owner = JSON.parse(readFileSync(ownerPath, "utf8"));
@@ -48439,6 +48450,10 @@ function bindWalDirectory(directory, key, claim = true) {
     if (owner?.schema !== WAL_OWNER_SCHEMA || owner.identity !== identity || Object.keys(owner).sort().join() !== "identity,schema") {
       throw new WalletStoreError("wallet_wal_owner_mismatch");
     }
+    if (statId === void 0) return;
+    let byDirectory = verifiedWalOwners.get(key);
+    if (!byDirectory) verifiedWalOwners.set(key, byDirectory = /* @__PURE__ */ new Map());
+    byDirectory.set(resolve3(directory), statId);
   };
   if (existsSync(ownerPath)) {
     verifyOwner();
@@ -48571,7 +48586,7 @@ function openWalletStore(path, passphrase2) {
   };
   return store;
 }
-var STORE_SCHEMA, WAL_SCHEMA, SCRYPT, WAL_OWNER_FILE, WAL_OWNER_SCHEMA, WalletStoreError, KEY_CACHE_LIMIT, keyCacheSecret, keyCache, keyStats, keyCacheId, rememberKey, assertPassphrase, assertWalName;
+var STORE_SCHEMA, WAL_SCHEMA, SCRYPT, WAL_OWNER_FILE, WAL_OWNER_SCHEMA, WalletStoreError, KEY_CACHE_LIMIT, keyCacheSecret, keyCache, keyStats, keyCacheId, rememberKey, verifiedWalOwners, ownerStatId, assertPassphrase, assertWalName;
 var init_store = __esm({
   "wallet/src/store/store.mjs"() {
     "use strict";
@@ -48597,6 +48612,11 @@ var init_store = __esm({
       keyCache.set(id, key);
       while (keyCache.size > KEY_CACHE_LIMIT) keyCache.delete(keyCache.keys().next().value);
     };
+    verifiedWalOwners = /* @__PURE__ */ new WeakMap();
+    ownerStatId = (path) => {
+      const stat = statSync(path, { bigint: true });
+      return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+    };
     assertPassphrase = (passphrase2) => {
       if (typeof passphrase2 !== "string" || passphrase2.length < 8) {
         throw new WalletStoreError("wallet_passphrase_too_short: the wallet passphrase must be at least 8 characters");
@@ -56623,6 +56643,23 @@ function walletCompactHistoryCache(store) {
 async function loadWalletP03History(args) {
   const runKey = lastRunReportKey(args.store, args.programId, args.pool, args.deploymentIdentity, args.cache);
   const prewarm = runKey === void 0 ? void 0 : prewarmedWalks.get(runKey);
+  const share = args.share;
+  if (share !== void 0) {
+    if (prewarm !== void 0 && strictScope.getStore() !== true && args.forceRead !== true && Number.isFinite(share.notBeforeMs) && prewarm.startedAt >= share.notBeforeMs && Date.now() - prewarm.startedAt <= HISTORY_PREWARM_JOIN_MS) {
+      try {
+        const report3 = await prewarm.promise;
+        PREWARMED_REPORTS.add(report3);
+        markPhase("walk-prewarm-shared");
+        return report3;
+      } catch {
+      }
+    }
+    const { share: _share, ...walkArgs } = args;
+    const startedAt2 = Date.now();
+    const report2 = await loadWalletP03HistoryNow(walkArgs);
+    if (runKey !== void 0) recentLoads.set(runKey, { startedAt: startedAt2, report: report2 });
+    return report2;
+  }
   if (prewarm !== void 0) {
     prewarmedWalks.delete(runKey);
     if (strictScope.getStore() !== true && args.forceRead !== true && Date.now() - prewarm.startedAt <= HISTORY_PREWARM_JOIN_MS) {
@@ -60112,6 +60149,7 @@ var init_sealedCache = __esm({
 });
 
 // wallet/src/recovery/recoveryCache.mjs
+import { performance as performance2 } from "node:perf_hooks";
 function contextBinding(context) {
   return [
     context.transitionKind,
@@ -60163,7 +60201,28 @@ function decodeOutput(value) {
   VERIFIED_OPENINGS.add(opening);
   return { ...output2, leafIndex: decimal3(value.leafIndex) };
 }
-function openRecoveryCache(store, { programId, pool: pool2 }) {
+function openRecoveryCache(store, ids) {
+  const run5 = openRecoveryCacheSteps(store, ids);
+  let step = run5.next();
+  while (!step.done) step = run5.next();
+  return step.value;
+}
+async function openRecoveryCacheSliced(store, ids) {
+  const run5 = openRecoveryCacheSteps(store, ids);
+  let started = performance2.now();
+  let step = run5.next();
+  while (!step.done) {
+    if (performance2.now() - started >= 25) {
+      await new Promise((resolve38) => {
+        setImmediate(resolve38);
+      });
+      started = performance2.now();
+    }
+    step = run5.next();
+  }
+  return step.value;
+}
+function* openRecoveryCacheSteps(store, { programId, pool: pool2 }) {
   const file = sealedCacheFile(store, { file: RECOVERY_CACHE_FILE, schema: RECOVERY_CACHE_SCHEMA, keyLabel: KEY_LABEL });
   if (!file) return void 0;
   const read = file.read();
@@ -60180,6 +60239,7 @@ function openRecoveryCache(store, { programId, pool: pool2 }) {
           entryKey(memo2.digest, memo2.binding),
           { digest: memo2.digest, binding: memo2.binding, outputs: memo2.outputs.map(decodeOutput) }
         );
+        yield;
       }
     } catch {
       entries.clear();
@@ -60245,14 +60305,14 @@ var init_recoveryCache = __esm({
 
 // wallet/src/recovery/memoDecryptPool.mjs
 import { availableParallelism } from "node:os";
-import { performance as performance2 } from "node:perf_hooks";
+import { performance as performance3 } from "node:perf_hooks";
 import { Worker as Worker2 } from "node:worker_threads";
 function sliceClock() {
-  let started = performance2.now();
+  let started = performance3.now();
   return async () => {
-    if (performance2.now() - started < SLICE_MS) return;
+    if (performance3.now() - started < SLICE_MS) return;
     await yieldTurn();
-    started = performance2.now();
+    started = performance3.now();
   };
 }
 async function sharedXOnMainThread(xs, eta) {
@@ -60581,7 +60641,7 @@ 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 { performance as performance3 } from "node:perf_hooks";
+import { performance as performance4 } from "node:perf_hooks";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function pinnedGenerator2(profileVector) {
   if (profileVector?.payerKeys?.generator) return profileVector.payerKeys.generator;
@@ -60652,18 +60712,18 @@ function walMemoBundles(store) {
 }
 async function walMemoBundlesSliced(store) {
   const bundles = /* @__PURE__ */ new Map();
-  let started = performance3.now();
+  let started = performance4.now();
   for (const name of store.listWal()) {
     const record = store.readWal(name);
     if (record?.memoBundleHex) {
       const bytes2 = Uint8Array.from(Buffer.from(hexOf2(record.memoBundleHex), "hex"));
       bundles.set(hexOf2(record.memoDigest ?? bundleDigest2(bytes2)), bytes2);
     }
-    if (performance3.now() - started >= 25) {
+    if (performance4.now() - started >= 25) {
       await new Promise((resolve38) => {
         setImmediate(resolve38);
       });
-      started = performance3.now();
+      started = performance4.now();
     }
   }
   return bundles;
@@ -60742,7 +60802,7 @@ async function legacyOutputs({ store, digests, serviceUrl: serviceUrl2, fresh, d
   return { entries, bundlesExamined: bundles.length };
 }
 async function syncedOutputs({ store, finalizedHistory: finalizedHistory2, digests, serviceUrl: serviceUrl2, fresh, deps, chainProgramId, pool: pool2, eta, decrypt }) {
-  const cache = deps.recoveryCache !== void 0 ? deps.recoveryCache : openRecoveryCache(store, { programId: chainProgramId.toBase58(), pool: pool2.toBase58() });
+  const cache = deps.recoveryCache !== void 0 ? deps.recoveryCache : await openRecoveryCacheSliced(store, { programId: chainProgramId.toBase58(), pool: pool2.toBase58() });
   const contexts = finalizedHistory2.contexts;
   const found = /* @__PURE__ */ new Map();
   const pending = [];
@@ -60779,13 +60839,13 @@ async function syncedOutputs({ store, finalizedHistory: finalizedHistory2, diges
         }
       }
       const items = [];
-      let sliceStart = performance3.now();
+      let sliceStart = performance4.now();
       for (const context of chunk) {
-        if (performance3.now() - sliceStart >= 25) {
+        if (performance4.now() - sliceStart >= 25) {
           await new Promise((resolve38) => {
             setImmediate(resolve38);
           });
-          sliceStart = performance3.now();
+          sliceStart = performance4.now();
         }
         const digest2 = hexOf2(context.memoDigest);
         const fromService = served.get(digest2);
@@ -60940,8 +61000,15 @@ async function runRecover({ store, connection, programId, digests, serviceUrl: s
   }
   markPhase("recover-memos");
   const recovered = [];
+  let replayStarted = performance4.now();
   for (const { digest: digest2, context, outputs } of read.entries) {
     for (const output2 of outputs) {
+      if (performance4.now() - replayStarted >= 25) {
+        await new Promise((resolve38) => {
+          setImmediate(resolve38);
+        });
+        replayStarted = performance4.now();
+      }
       const replayValue = replayValueOf(
         output2.kind,
         context.poolDomain,
@@ -72476,8 +72543,15 @@ function respendNoteSubset({ accounts, notes, outputIndex, amountAtomic, refused
   return void 0;
 }
 function exitReservedNoteCommitments(store) {
+  const run5 = exitReservedNoteCommitmentSteps(store);
+  let step = run5.next();
+  while (!step.done) step = run5.next();
+  return step.value;
+}
+function* exitReservedNoteCommitmentSteps(store) {
   const reserved = /* @__PURE__ */ new Set();
   for (const name of typeof store?.listWal === "function" ? store.listWal() : []) {
+    yield;
     const selfPay2 = name.startsWith("self-pay-");
     if (!selfPay2 && !name.startsWith("note-exit-")) continue;
     if (name.startsWith("self-pay-merge-")) continue;
@@ -72531,7 +72605,7 @@ function startFinalizedChainTime(connection) {
     return time + Math.floor(age / 1e3);
   };
 }
-async function everyAccountHeld({ store, connection, programId, serviceUrl: serviceUrl2, reservedReplayValues, deps = {} }) {
+async function everyAccountHeld({ store, connection, programId, serviceUrl: serviceUrl2, reservedReplayValues, amountAtomic, 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()));
@@ -72542,14 +72616,31 @@ async function everyAccountHeld({ store, connection, programId, serviceUrl: serv
     serviceUrl: serviceUrl2,
     deps: { fetchImpl: deps.fetchImpl, finalizedHistory: history, transitionContextFor: history.transitionContextFor }
   });
-  return recovery.recovered.filter((entry) => entry.kind === "account" && entry.spendStatus === "unspent").every((entry) => {
+  const poolDomain = history.contexts[0]?.poolDomain;
+  const held = (entry) => {
     if (entry.leafIndex === void 0 || entry.leafIndex === null) return true;
     try {
-      return reservedReplayValues.has(accountNullifier(entry.commitment, viewing.eta, entry.leafIndex).toString());
+      const value = entry.kind === "account" ? accountNullifier(entry.commitment, viewing.eta, entry.leafIndex) : noteNullifier2(poolDomain, entry.commitment, viewing.eta, entry.leafIndex);
+      return reservedReplayValues.has(value.toString());
     } catch {
       return true;
     }
-  });
+  };
+  const unspent = (kind) => recovery.recovered.filter((entry) => entry.kind === kind && entry.spendStatus === "unspent");
+  const unspentAccounts = unspent("account");
+  const unheldAccounts = unspentAccounts.filter((entry) => !held(entry));
+  if (unheldAccounts.length === 0) return true;
+  if (amountAtomic === void 0) return false;
+  const unspentNotes = unspent("note");
+  const unheldNotes = unspentNotes.filter((entry) => !held(entry));
+  const anyHeld = unheldAccounts.length !== unspentAccounts.length || unheldNotes.length !== unspentNotes.length && (() => {
+    const exitReserved = exitReservedNoteCommitments(store);
+    return unspentNotes.some((entry) => held(entry) && !exitReserved.has(BigInt(entry.commitment).toString()));
+  })();
+  if (!anyHeld) return false;
+  const largestAccount = unheldAccounts.reduce((max, entry) => BigInt(entry.account.b) > max ? BigInt(entry.account.b) : max, 0n);
+  const notesValue = unheldNotes.reduce((sum2, entry) => sum2 + BigInt(entry.note.b), 0n);
+  return largestAccount + notesValue < BigInt(amountAtomic);
 }
 async function prepareRecoveredPayment({
   store,
@@ -93148,6 +93239,7 @@ async function payResourceOnce({
           programId,
           serviceUrl: serviceUrl2,
           reservedReplayValues: held,
+          amountAtomic: maximumAtomic,
           deps: { fetchImpl: deps.fetchImpl, walkHistory: finality.walkHistory }
         }));
       } catch {
@@ -96638,6 +96730,30 @@ function sellerHttpReply(result) {
   const body = result.result ? Buffer.from(result.result.bodyBase64, "base64") : Buffer.from(JSON.stringify(result.paymentRequired ?? { code: result.code, ...result.reason === FACILITATOR_UNDERFUNDED ? { reason: result.reason } : {} }));
   return { status: result.status, headers, body };
 }
+function earlyConfirmedTransaction(connection, signature) {
+  if (typeof connection.getTransaction !== "function" || typeof connection.getVerifiedTransaction === "function" || typeof connection.getVerifiedTransactions === "function") {
+    return void 0;
+  }
+  return connection.getTransaction(signature, CONFIRMED_TRANSACTION_READ).then((raw) => raw ?? null, () => null);
+}
+function withPrefetchedTransaction(connection, signature, prefetched) {
+  let pending = prefetched;
+  const getTransaction = (requested, options) => {
+    if (pending && requested === signature && options?.commitment === CONFIRMED_TRANSACTION_READ.commitment && options?.maxSupportedTransactionVersion === CONFIRMED_TRANSACTION_READ.maxSupportedTransactionVersion) {
+      const answer = pending;
+      pending = void 0;
+      return Promise.resolve(answer);
+    }
+    return connection.getTransaction(requested, options);
+  };
+  return new Proxy(connection, {
+    get(target, property) {
+      if (property === "getTransaction") return getTransaction;
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
 async function createSellerAdapter({
   config,
   connection,
@@ -96953,11 +97069,21 @@ async function createSellerAdapter({
       mark("receipt-unverified");
       return completed2;
     }
-    const status = await visibleReceiptStatus(connection, receipt.transaction, visibility);
+    const early = earlyConfirmedTransaction(connection, receipt.transaction);
+    let polled = false;
+    const status = await visibleReceiptStatus(
+      connection,
+      receipt.transaction,
+      { ...visibility, sleep: (ms) => {
+        polled = true;
+        return visibility.sleep(ms);
+      } }
+    );
     const level = receiptStatusLevel(status);
     if (!level || require2 === "finalized" && level !== "finalized") fail26("receipt_pending");
+    const prefetched = early && !polled && level === "confirmed" ? await early : null;
     await validateReceiptTransaction(
-      connection,
+      prefetched ? withPrefetchedTransaction(connection, receipt.transaction, prefetched) : connection,
       receipt,
       { paymentHeader: offer.paymentHeader },
       { pool: profile.pool },
@@ -97289,7 +97415,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;
+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 init_service = __esm({
   "wallet/src/seller/service.mjs"() {
     "use strict";
@@ -97358,6 +97484,7 @@ var init_service = __esm({
       6e5
     ]);
     FOLLOW_UP_RESETTLE_FROM = 4;
+    CONFIRMED_TRANSACTION_READ = Object.freeze({ commitment: "confirmed", maxSupportedTransactionVersion: 1 });
   }
 });
 
@@ -97533,20 +97660,19 @@ async function selfPay({
     ...record,
     state: "paid",
     transaction,
-    noteCommitment: (deps.findNote ?? selfPaidNoteCommitment)(store, unshieldId, eta).toString()
+    noteCommitment: (await (deps.findNote ?? selfPaidNoteCommitment)(store, unshieldId, eta)).toString()
   };
   store.writeWal(name, record);
   return record;
 }
-function selfPaidNoteCommitment(store, unshieldId, eta) {
+async function selfPaidNoteCommitment(store, unshieldId, eta) {
   const key = sha256Hex2(Buffer.from(selfPayRequestId(unshieldId), "utf8"));
   const payment = store.readWal(`resource-payment-${key}`);
   const proof = store.readWal(`resource-proof-${key}`)?.proved?.output;
   const accepted = payment?.paymentRequired?.accepts?.find((entry) => entry.scheme === "shielded-exact");
   if (!proof?.memoBundleHex || !accepted) fail27("payment_wal_missing");
-  const { accepted: outputs } = trialDecryptBundle({
+  const [{ accepted: outputs }] = await trialDecryptBundles([{
     bundleBytes: Uint8Array.from(Buffer.from(proof.memoBundleHex.replace(/^0x/, ""), "hex")),
-    eta,
     poolDomain: BigInt(proof.poolDomain),
     outCommitment: BigInt(proof.outCommitment),
     contextCommitment: BigInt(proof.quoteCommitment),
@@ -97554,7 +97680,7 @@ function selfPaidNoteCommitment(store, unshieldId, eta) {
     transitionKind: 2,
     zeroLeaf: P03_PINNED_ZERO_LEAF,
     subtreeStartIndex: 0n
-  });
+  }], eta);
   const notes = outputs.filter((entry) => entry.kind === "note");
   if (notes.length !== 1 || notes[0].note.b !== BigInt(proof.amountAtomic)) fail27("self_paid_note_not_found");
   return notes[0].commitment;
@@ -97566,7 +97692,7 @@ var init_selfPay = __esm({
     init_fs();
     init_service();
     init_notes2();
-    init_memo2();
+    init_memoDecryptPool();
     init_store();
     init_recoveryPath();
     init_payResource();
@@ -126400,16 +126526,17 @@ 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 };
 }
-var walkWalletHistory = (session, store) => loadWalletP03History({
+var walkWalletHistory = (session, store, share) => loadWalletP03History({
   store,
   connection: connectSplit(session.connection, session.historyUrl),
   programId: session.programId,
   pool: store.state.pool,
-  deploymentIdentity: session.proofTools.deploymentIdentity
+  deploymentIdentity: session.proofTools.deploymentIdentity,
+  ...share ? { share } : {}
 });
-async function refreshWallet({ session, store, history: walked }) {
+async function refreshWallet({ session, store, history: walked, share }) {
   const walStates = captureWalStates(store);
-  const history = walked ?? await walkWalletHistory(session, store);
+  const history = walked ?? await walkWalletHistory(session, store, share);
   const result = await runRecover({
     store,
     connection: session.connection,
@@ -126666,7 +126793,13 @@ function createWalletTools({
   let refreshFailedAt = 0;
   let refreshFailedCode;
   let refreshInBackground = false;
-  const refreshStep = (store, history) => (ops.refresh ?? refreshWallet)({ session, store, ...history ? { history } : {} });
+  const refreshStep = (store, history, share) => (ops.refresh ?? refreshWallet)({
+    session,
+    store,
+    ...history ? { history } : {},
+    ...share ? { share } : {}
+  });
+  let lastWriterEndedAt = 0;
   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 () => {
@@ -126680,6 +126813,7 @@ function createWalletTools({
       return await task(session.openStore());
     } finally {
       await release();
+      lastWriterEndedAt = Date.now();
     }
   });
   const autoPockets = createAutoPockets({
@@ -126764,7 +126898,12 @@ function createWalletTools({
     }
   };
   const withPoolSwitch = (tool) => ({ ...tool, run: async (...args) => {
-    const output2 = await tool.run(...args);
+    let output2;
+    try {
+      output2 = await tool.run(...args);
+    } finally {
+      if (tool.annotations?.readOnlyHint !== true) lastWriterEndedAt = Date.now();
+    }
     if (!succession || !output2 || output2.isError || typeof output2.text !== "string") return output2;
     const read = readSwitch();
     const field4 = switchField(read);
@@ -126814,6 +126953,7 @@ function createWalletTools({
   function refreshShared({ background = false } = {}) {
     if (!refreshRun) {
       refreshInBackground = background;
+      const calledAt = Date.now();
       refreshRun = (async () => {
         let early;
         if (background && refreshWalk) {
@@ -126829,7 +126969,8 @@ function createWalletTools({
         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);
+          const share = early !== void 0 && !same2 ? { notBeforeMs: Math.max(calledAt, lastWriterEndedAt) } : void 0;
+          return refreshStep(store, same2 ? early.history : void 0, share);
         });
       })().then(() => {
         refreshFailedAt = 0;