shinjuku-shielded 0.3.41 → 0.3.42

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "387938b415cfece575952e875ecafc7149e29279e202a4e862433f66f664a803",
-  "bytes": 11230018,
-  "sourceCommit": "60acd91587cd5576b91001c7dcdabbb1c0f723aa",
+  "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.41",
+  "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": "387938b4",
-  "shinjukuSha256": "387938b415cfece575952e875ecafc7149e29279e202a4e862433f66f664a803",
+  "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

@@ -60149,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,
@@ -60200,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();
@@ -60217,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();
@@ -60282,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) {
@@ -60618,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;
@@ -60689,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;
@@ -60779,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 = [];
@@ -60816,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);
@@ -60977,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,
@@ -72513,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;
@@ -72568,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()));
@@ -72579,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,
@@ -93185,6 +93239,7 @@ async function payResourceOnce({
           programId,
           serviceUrl: serviceUrl2,
           reservedReplayValues: held,
+          amountAtomic: maximumAtomic,
           deps: { fetchImpl: deps.fetchImpl, walkHistory: finality.walkHistory }
         }));
       } catch {