shinjuku-shielded 0.3.42 → 0.3.43

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": "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.42",
+  "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": "f55f1fb8",
-  "shinjukuSha256": "f55f1fb8f1b63bf4caf94b552f06f6c3126ed8fd598d6d8fe8fc9abd7377b509",
+  "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

@@ -96770,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 () => {
@@ -97178,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;
@@ -97415,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";
@@ -97466,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;
@@ -126800,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;
@@ -126899,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();
@@ -126951,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) {
@@ -126961,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) => {
@@ -126981,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;
@@ -127053,6 +127129,7 @@ function createWalletTools({
       finalityWait = void 0;
       if (finalityClosed || finalityTarget === watched) finalityTarget = void 0;
       else startFinalityWait();
+      runDeferredRefresh();
     });
   }
   async function refreshIfStale() {
@@ -127473,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) {