shinjuku-shielded 0.3.26 → 0.3.27

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "f2dc55fb5d552bef98fe2d530d37c301045501d0f750a2c9a17ddf63b1a934f3",
-  "bytes": 11150739,
-  "sourceCommit": "b9639dffcfdad92b73571e89117761c8f716ef83",
+  "sha256": "adb0f68b23e192445ecb391a89f3e05dba89f05d0177aacdb092fbea3539fa85",
+  "bytes": 11154518,
+  "sourceCommit": "e8d63cd7fd58f3f334eea244fa5dc0e7b1c5c6be",
   "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.26",
+  "version": "0.3.27",
   "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": "f2dc55fb",
-  "shinjukuSha256": "f2dc55fb5d552bef98fe2d530d37c301045501d0f750a2c9a17ddf63b1a934f3",
+  "shinjukuRelease": "adb0f68b",
+  "shinjukuSha256": "adb0f68b23e192445ecb391a89f3e05dba89f05d0177aacdb092fbea3539fa85",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -119132,7 +119132,7 @@ function publicUrl(value) {
     return null;
   }
 }
-function computeBalance({ store, snapshotRead, source = "local", now = Date.now() }) {
+function computeBalance({ store, snapshotRead, source = "local", now = Date.now(), firstDepositEstimate = false }) {
   const state = store.state;
   const decimals = Number(state.decimals);
   const records = store.listWal().sort().map((name) => {
@@ -119217,6 +119217,12 @@ function computeBalance({ store, snapshotRead, source = "local", now = Date.now(
       }
       return report("empty", 0n, proved ? `deposit ${proved.depositId} is proved but not sent: back up (shinjuku-wallet help backup-export), then rerun the same deposit command with --submit --service <facilitator URL>` : "no deposit yet: deposit one of two ways (shinjuku-wallet help deposit). 1) The more private path, shinjuku-wallet deposit --relay: no SOL is needed; its first run prints a one-time address to fund with USDC from an exchange withdrawal or an outside privacy pool. 2) Send USDC and about 0.01 SOL to your solanaFeePayer address (printed by init), then run shinjuku-wallet deposit without --relay; that deposit edge is public. If this wallet only holds restored keys or receives payments, run balance --refresh");
     }
+    const valueRecords = records.filter((entry) => !["payment-proof", "privacy-cash", "add-funds"].includes(entry.type) && !(entry.type === "deposit" && (entry.phase === "pre-chain" || entry.phase === "void")));
+    const landedDeposits = valueRecords.filter((entry) => entry.type === "deposit" && entry.phase === "done" && typeof entry.record?.receipt?.signature === "string" && entry.record.receipt.signature.length > 0 && canonicalAtomic(entry.record.amountAtomic));
+    if (firstDepositEstimate && !snapshotRead?.unreadable && !state.restoredFromRecoveryText && landedDeposits.length > 0 && landedDeposits.length === valueRecords.length) {
+      reasons.push("the first check of the pool history runs now; this number is your own deposit");
+      return report("stale", sum2(landedDeposits.map((entry) => entry.record.amountAtomic)), refreshCommand(state));
+    }
     reasons.push(snapshotRead?.unreadable ? `the saved balance walk is unreadable (${snapshotRead.unreadable}); it is only a cache` : state.restoredFromRecoveryText && !couldHoldValue ? "this wallet was rebuilt from the recovery text (restore) and has no balance walk yet: its value is on chain, not in this file" : "this wallet has deposit or payment records but no balance walk yet");
     return report("unknown", null, refreshCommand(state));
   }
@@ -125228,6 +125234,7 @@ async function runUnshield({
   return { selfPayTransaction: paid.transaction ?? null, exitTransaction: exit.signature ?? null };
 }
 var BALANCE_REFRESH_WAIT_MS = 2e4;
+var BALANCE_REFRESH_GRACE_MS = 2e3;
 function movingAtomic(store) {
   let moving = 0n;
   try {
@@ -125282,6 +125289,9 @@ function localBalanceOf(store) {
 var CAP_BALANCE_WAIT_MS = 35e3;
 var CAP_BALANCE_RETRY_MS = 5e3;
 var REFRESH_RETRY_MS = 6e4;
+var FINALITY_POLL_MS = 2e3;
+var FINALITY_WAIT_MS = 6e4;
+var PUBLIC_READ_ANSWER_MS = 3e3;
 var SWITCH_WAIT_MS = 4e4;
 var ELICIT_TIMEOUT_MS = 5 * 6e4;
 var POLL_SECONDS2 = 30;
@@ -125478,6 +125488,51 @@ function createWalletTools({
     }
     return refreshRun;
   }
+  let finalityWait;
+  let finalityTarget;
+  let finalityDeadline = 0;
+  let finalityClosed = false;
+  const finalityPollMs = ops.finalityPollMs ?? FINALITY_POLL_MS;
+  const finalityWaitMs = ops.finalityWaitMs ?? FINALITY_WAIT_MS;
+  function refreshAtFinality(signature) {
+    if (typeof signature !== "string" || !signature || finalityClosed) return;
+    finalityTarget = signature;
+    finalityDeadline = Date.now() + finalityWaitMs;
+    if (finalityWait) return;
+    const statuses = ops.signatureStatuses ?? ((signatures) => session.connection.getSignatureStatuses(signatures));
+    finalityWait = (async () => {
+      for (; ; ) {
+        const watched = finalityTarget;
+        let status;
+        try {
+          status = (await statuses([watched]))?.value?.[0] ?? void 0;
+        } catch {
+          status = void 0;
+        }
+        if (finalityClosed) return;
+        if (watched === finalityTarget && status?.err) {
+          log("MCP_FINALITY_WAIT_FAILED_TRANSACTION");
+          return;
+        }
+        if (watched === finalityTarget && status?.confirmationStatus === "finalized") {
+          log("MCP_FINALITY_REFRESH");
+          await refreshShared().catch(() => {
+          });
+          return;
+        }
+        if (Date.now() + finalityPollMs > finalityDeadline) {
+          log("MCP_FINALITY_WAIT_EXPIRED");
+          return;
+        }
+        await new Promise((resolve38) => {
+          const timer = setTimeout(resolve38, finalityPollMs);
+          timer.unref?.();
+        });
+      }
+    })().finally(() => {
+      finalityWait = void 0;
+    });
+  }
   async function refreshIfStale() {
     let stale;
     try {
@@ -125760,6 +125815,7 @@ function createWalletTools({
       const floatPaid = float?.state === "receipt";
       const amounts = floatPaid ? { priceAtomic: float.priceAtomic, feeAtomic: float.feeAtomic, amountAtomic: float.paidAtomic } : { priceAtomic: receipt.amountAtomic ?? null, feeAtomic: "0", amountAtomic: receipt.amountAtomic ?? null };
       const one = paidStore ? localBalanceOf(paidStore) : null;
+      if (receipt.replayed !== true) refreshAtFinality(floatPaid ? float.floatSettleTransaction : transaction);
       mark("mcp-result");
       return answerResult(paidAnswerContent({
         status: response.status,
@@ -125886,21 +125942,23 @@ function createWalletTools({
         );
       }
       const publicRead = withTimeout((ops.readPublicBalance ?? readOwnPublicBalance)({ session, store }), PUBLIC_READ_TIMEOUT_MS).then((read2) => ({ read: read2 }), (error2) => ({ error: error2 }));
-      let report = computeBalance({ store, snapshotRead: readBalanceSnapshot(store), source: "local" });
+      let report = computeBalance({ store, snapshotRead: readBalanceSnapshot(store), source: "local", firstDepositEstimate: true });
       let refresh = {};
       const recentlyFailed = refreshFailedAt && Date.now() - refreshFailedAt < REFRESH_RETRY_MS && !refreshRun;
       if (report.split?.shieldedAtomic != null && report.status === "stale") {
-        if (!recentlyFailed) refreshShared().catch(() => {
+        if (!recentlyFailed && !finalityWait) refreshShared().catch(() => {
         });
         refresh = { refreshing: true };
       } else if (report.split?.shieldedAtomic == null && recentlyFailed) {
         refresh = { refreshed: false, refreshError: refreshFailedCode ?? "mcp_refresh_failed" };
       } else if (report.split?.shieldedAtomic == null) {
         const run5 = refreshShared().then(() => "done", (error2) => ({ failed: errorCode2(error2, "mcp_refresh_failed") }));
-        const outcome = await Promise.race([run5, new Promise((resolve38) => {
-          const timer = setTimeout(() => resolve38("waiting"), balanceRefreshWaitMs);
+        const waitFor = (ms) => Promise.race([run5, new Promise((resolve38) => {
+          const timer = setTimeout(() => resolve38("waiting"), ms);
           timer.unref?.();
         })]);
+        let outcome = await waitFor(balanceRefreshWaitMs);
+        if (outcome === "waiting") outcome = await waitFor(BALANCE_REFRESH_GRACE_MS);
         if (outcome === "done") {
           try {
             store = session.openStore();
@@ -125914,9 +125972,28 @@ function createWalletTools({
           refresh = { refreshed: false, refreshError: outcome.failed };
         }
       }
-      const { read, error } = await publicRead;
+      const answered = await Promise.race([
+        publicRead,
+        new Promise((resolve38) => {
+          const timer = setTimeout(() => resolve38({ reading: true }), PUBLIC_READ_ANSWER_MS);
+          timer.unref?.();
+        })
+      ]);
+      if (answered.reading) {
+        publicRead.then(({ error: late2 }) => {
+          if (late2) log(`MCP_PUBLIC_READ_FAILED_LATE ${late2?.name ?? "Error"}`);
+        });
+      }
+      const { read, error } = answered;
       let unshielded;
-      if (read) {
+      if (answered.reading) {
+        unshielded = {
+          unshieldedAtomic: null,
+          unshielded: null,
+          unshieldedSolLamports: null,
+          unshieldedReason: "reading: the RPC read of the wallet's own USDC account did not answer in 3 s; the shielded balance above does not wait for it. Call wallet_balance again later"
+        };
+      } else if (read) {
         unshielded = {
           unshieldedAtomic: read.unshieldedAtomic,
           unshielded: formatAtomic(BigInt(read.unshieldedAtomic), Number(store.state.decimals)),
@@ -126620,6 +126697,7 @@ function createWalletTools({
       job.result = result;
       log(`MCP_${kind.toUpperCase()}_DONE requestId=${job.requestId}`);
       if (kind !== "unshield") afterShield(job);
+      else refreshAtFinality(result?.exitTransaction ?? result?.selfPayTransaction);
     }, (error) => {
       job.failedStage = job.stage;
       job.state = "failed";
@@ -126881,6 +126959,7 @@ function createWalletTools({
   };
   Object.defineProperties(tools, {
     close: { value: () => {
+      finalityClosed = true;
       autoPockets.close();
       mover.close();
       adopter.close();