shinjuku-shielded 0.3.41 → 0.3.43

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": "0ff1dea585d7a2ca69e0a37f43684dcb411f5a28eafa84a3f7fee65f5cd13904",
+  "bytes": 11235804,
+  "sourceCommit": "20e5a0c5b4faa27b1309e57816901b0ba77c78ce",
   "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.43",
   "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": "0ff1dea5",
+  "shinjukuSha256": "0ff1dea585d7a2ca69e0a37f43684dcb411f5a28eafa84a3f7fee65f5cd13904",
   "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 {
@@ -96715,12 +96770,33 @@ 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)
   } });
+  async function precomputeMemoSharedX(memoBundle, owned) {
+    let sliceStart = performance.now();
+    for (let offset = 0; offset + MEMO_RECORD_BYTES2 <= memoBundle.length; offset += MEMO_RECORD_BYTES2) {
+      if (performance.now() - sliceStart >= MEMO_PRECOMPUTE_SLICE_MS) {
+        await new Promise((resolveTurn) => {
+          setImmediate(resolveTurn);
+        });
+        sliceStart = performance.now();
+      }
+      if (owned.done) return;
+      try {
+        const point = shieldedSolanaP03CurvePointFromX(BigInt(`0x${Buffer.from(memoBundle.subarray(offset, offset + 32)).toString("hex")}`));
+        const key = `${point.x}:${point.y}`;
+        if (sharedXByPoint.has(key)) continue;
+        sharedXByPoint.set(key, sharedXOf(point));
+        owned.keys.push(key);
+      } catch {
+      }
+    }
+  }
   const readChainAnchor = createAnchorReader({ connection: memoizeFinalizedReads(connection), profile });
   let anchorRequest;
   const requestFacilitatorAnchor = () => anchorRequest ??= (async () => {
@@ -97123,15 +97199,32 @@ 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 };
+        let precomputed;
+        if (precomputesRunning < MEMO_PRECOMPUTES_MAX) {
+          precomputesRunning += 1;
+          precomputed = precomputeMemoSharedX(parsed.memoBundle, owned).catch(() => void 0).finally(() => {
+            precomputesRunning -= 1;
+          });
+        }
+        let recoveredNote;
+        let intakeRead;
+        try {
+          const auth = await authenticated;
+          mark("intake-authenticated");
+          intakeRead = readAnchor();
+          intakeRead.catch(() => void 0);
+          await precomputed;
+          recoveredNote = await scanner.recoverMerchantNoteYielding({ parsed, authenticatedQuote: auth });
+        } finally {
+          owned.done = true;
+          for (const key of owned.keys) sharedXByPoint.delete(key);
+        }
         mark("intake-note-recovered");
         const chain = await intakeRead;
         intakeChain = chain;
@@ -97360,7 +97453,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_RECORD_BYTES2, MEMO_PRECOMPUTE_SLICE_MS, MEMO_PRECOMPUTES_MAX, 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";
@@ -97411,6 +97504,9 @@ var init_service = __esm({
     ANCHOR_REQUEST_TIMEOUT_MS2 = 9e4;
     ANCHOR_POLL_ATTEMPTS = 15;
     ANCHOR_POLL_MS = 2e3;
+    MEMO_RECORD_BYTES2 = 200;
+    MEMO_PRECOMPUTE_SLICE_MS = 8;
+    MEMO_PRECOMPUTES_MAX = 2;
     PRE_SETTLE_REUSE_MARGIN_S = 60;
     PRE_SETTLE_REUSE_MAX_AGE_MS = 2e4;
     FINALIZED_MEMO_MAX_AGE_MS = 1e3;
@@ -126745,7 +126841,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;
@@ -126844,10 +126951,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();
@@ -126896,9 +127009,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) {
@@ -126906,18 +127030,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) => {
@@ -126926,8 +127053,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;
@@ -126998,6 +127129,7 @@ function createWalletTools({
       finalityWait = void 0;
       if (finalityClosed || finalityTarget === watched) finalityTarget = void 0;
       else startFinalityWait();
+      runDeferredRefresh();
     });
   }
   async function refreshIfStale() {
@@ -127418,7 +127550,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) {