shinjuku-shielded 0.3.153 → 0.3.154

package/README.md

@@ -6,19 +6,19 @@ answers privately, in a terminal chat or for your agent app. Its `mcp`
 command runs a local MCP server (stdio) for your agent. Your keys never
 leave your machine.
 
-This is version 0.3.153. The npm packages `shinjuku-shield` and
+This is version 0.3.154. The npm packages `shinjuku-shield` and
 `shinjuku-shielded` hold the same files. The command is `shinjuku`.
 
 ## Set up
 
 ```sh
-npm install -g shinjuku@0.3.153
+npm install -g shinjuku@0.3.154
 shinjuku setup
 ```
 
 Type the two lines as they are. `npx install shinjuku` does not work: npx
 reads `install` as the name of another npm package. To set up without
-installing, type `npx shinjuku@0.3.153 setup`.
+installing, type `npx shinjuku@0.3.154 setup`.
 
 Setup makes the wallet on this machine, a private passphrase file, and the
 checked proof tools (about 191 MB), and writes `config.json`. It also writes
@@ -36,13 +36,13 @@ Every wallet command works after `shinjuku`, for example `shinjuku balance`,
 Claude Code:
 
 ```sh
-claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.153 mcp
+claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.154 mcp
 ```
 
 Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
 
 ```json
-{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.153", "mcp"] } } }
+{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.154", "mcp"] } } }
 ```
 
 On native Windows, if the host cannot find `npx`, use `"command": "cmd"` and
@@ -55,7 +55,7 @@ Codex (the Codex app and Codex CLI read the same file, `~/.codex/config.toml`):
 ```toml
 [mcp_servers.shinjuku]
 command = "npx"
-args = ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.153", "mcp"]
+args = ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.154", "mcp"]
 startup_timeout_sec = 120
 tool_timeout_sec = 300
 ```

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "d446c36da9b526aea16cf685fb7b1532542f1eea13d0f2acabca373711bace8f",
-  "bytes": 9048030,
-  "sourceCommit": "9c091872009ec4e8a82ff9d5540fe00015cc93d1",
+  "sha256": "706b774ac8ab6d671a81f7aa269e2a1d1e222d60f545ddde48945fbfdc8b0bcd",
+  "bytes": 9052676,
+  "sourceCommit": "7b23397db24686bbab6bd45734cb9560c914981a",
   "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",
@@ -1038,5 +1038,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-11-03T05:08:33.860Z"
+  "publishedAt": "2026-11-03T05:31:30.536Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.153",
+  "version": "0.3.154",
   "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": "d446c36d",
-  "shinjukuSha256": "d446c36da9b526aea16cf685fb7b1532542f1eea13d0f2acabca373711bace8f",
+  "shinjukuRelease": "706b774a",
+  "shinjukuSha256": "706b774ac8ab6d671a81f7aa269e2a1d1e222d60f545ddde48945fbfdc8b0bcd",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-shield#readme",

package/shinjuku-wallet.mjs

@@ -17386,7 +17386,7 @@ var require_receiver = __commonJS({
 var require_sender = __commonJS({
   "node_modules/ws/lib/sender.js"(exports, module) {
     "use strict";
-    var { Duplex } = __require("stream");
+    var { Duplex: Duplex2 } = __require("stream");
     var { randomFillSync } = __require("crypto");
     var {
       types: { isUint8Array }
@@ -18264,10 +18264,10 @@ var require_websocket = __commonJS({
     var EventEmitter = __require("events");
     var https = __require("https");
     var http3 = __require("http");
-    var net2 = __require("net");
+    var net3 = __require("net");
     var tls = __require("tls");
     var { randomBytes: randomBytes33, createHash: createHash34 } = __require("crypto");
-    var { Duplex, Readable } = __require("stream");
+    var { Duplex: Duplex2, Readable } = __require("stream");
     var { URL: URL4 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
     var Receiver = require_receiver();
@@ -19008,12 +19008,12 @@ var require_websocket = __commonJS({
     }
     function netConnect(options) {
       options.path = options.socketPath;
-      return net2.connect(options);
+      return net3.connect(options);
     }
     function tlsConnect(options) {
       options.path = void 0;
       if (!options.servername && options.servername !== "") {
-        options.servername = net2.isIP(options.host) ? "" : options.host;
+        options.servername = net3.isIP(options.host) ? "" : options.host;
       }
       return tls.connect(options);
     }
@@ -19158,7 +19158,7 @@ var require_stream = __commonJS({
   "node_modules/ws/lib/stream.js"(exports, module) {
     "use strict";
     var WebSocket = require_websocket();
-    var { Duplex } = __require("stream");
+    var { Duplex: Duplex2 } = __require("stream");
     function emitClose(stream) {
       stream.emit("close");
     }
@@ -19176,7 +19176,7 @@ var require_stream = __commonJS({
     }
     function createWebSocketStream(ws, options) {
       let terminateOnDestroy = true;
-      const duplex = new Duplex({
+      const duplex = new Duplex2({
         ...options,
         autoDestroy: false,
         emitClose: false,
@@ -19302,7 +19302,7 @@ var require_websocket_server = __commonJS({
     "use strict";
     var EventEmitter = __require("events");
     var http3 = __require("http");
-    var { Duplex } = __require("stream");
+    var { Duplex: Duplex2 } = __require("stream");
     var { createHash: createHash34 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
@@ -42866,12 +42866,15 @@ var init_keepAlive = __esm({
 });
 
 // wallet/src/net/tunnelGuard.mjs
-function tunnelClient(Dispatcher, proxyPort) {
+import net from "node:net";
+import { Duplex } from "node:stream";
+function tunnelClient(Dispatcher, proxyPort, proxyHost) {
   const direct = new Dispatcher({ httpProxy: "", httpsProxy: "", noProxy: "*" });
   const closedInRow = /* @__PURE__ */ new Map();
   return {
     async connect(params) {
       const target = String(params?.path ?? "");
+      if (optimisticTarget(target)) return optimisticConnect(params, { proxyHost, proxyPort, closedInRow });
       try {
         const answer = await direct.connect(params);
         closedInRow.delete(target);
@@ -42903,14 +42906,143 @@ function proxyDispatcher(Dispatcher, proxy) {
     noProxy: "",
     keepAliveTimeout: KEEP_ALIVE_MS,
     keepAliveMaxTimeout: KEEP_ALIVE_MS,
-    clientFactory: () => tunnelClient(Dispatcher, port)
+    clientFactory: () => tunnelClient(Dispatcher, port, url.hostname)
+  });
+}
+function optimisticTarget(target) {
+  return String(process.env[RUN_MARK] ?? "").startsWith("tor ") && /:443$/.test(target);
+}
+function tunnelRefused(statusCode) {
+  return Object.assign(new Error(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`), { name: "AbortError", code: "UND_ERR_ABORTED" });
+}
+function optimisticConnect(params, { proxyHost, proxyPort, closedInRow }) {
+  const target = String(params.path);
+  const head = `CONNECT ${target} HTTP/1.1\r
+${Object.entries(params.headers ?? {}).filter(([name, value2]) => value2 !== void 0 && !/[\r\n]/.test(`${name}${value2}`)).map(([name, value2]) => `${name}: ${value2}\r
+`).join("")}\r
+`;
+  const sent = [];
+  let socket;
+  let ready = false;
+  let open4 = false;
+  let reply = Buffer.alloc(0);
+  let pendingReject;
+  const stream = new Duplex({
+    // Backpressure (Codex review): the tunnel socket pauses when this buffer is full and resumes when TLS reads.
+    read() {
+      if (socket && !socket.destroyed && socket.isPaused()) socket.resume();
+    },
+    write(chunk, encoding, done) {
+      if (!open4) sent.push(Buffer.from(chunk, encoding));
+      if (!ready || socket.destroyed) {
+        done();
+        return;
+      }
+      socket.write(chunk, encoding, done);
+    },
+    final(done) {
+      socket?.end();
+      done();
+    },
+    destroy(error, done) {
+      socket?.destroy();
+      done(error);
+    }
+  });
+  stream.on("error", () => {
+  });
+  const abortReason = () => params.signal?.reason ?? Object.assign(new Error("This operation was aborted"), { name: "AbortError", code: "ABORT_ERR" });
+  if (params.signal?.aborted) return Promise.reject(abortReason());
+  const onAbort = () => {
+    if (pendingReject) {
+      const reject = pendingReject;
+      pendingReject = void 0;
+      socket?.destroy();
+      stream.destroy();
+      reject(abortReason());
+      return;
+    }
+    stream.destroy(abortReason());
+  };
+  params.signal?.addEventListener?.("abort", onAbort, { once: true });
+  const dial = (first) => new Promise((resolve39, reject) => {
+    if (first) pendingReject = reject;
+    reply = Buffer.alloc(0);
+    ready = false;
+    socket = net.connect(proxyPort, proxyHost);
+    socket.setNoDelay(true);
+    let connected = false;
+    socket.once("connect", () => {
+      connected = true;
+      socket.write(head);
+      for (const chunk of sent) socket.write(chunk);
+      ready = true;
+      if (first) pendingReject = void 0;
+      resolve39();
+    });
+    socket.on("data", (chunk) => {
+      if (open4) {
+        if (!stream.push(chunk)) socket.pause();
+        return;
+      }
+      reply = Buffer.concat([reply, chunk]);
+      const end = reply.indexOf("\r\n\r\n");
+      if (end < 0) return;
+      const status = Number(/^HTTP\/1\.[01] (\d{3})/.exec(reply.subarray(0, reply.indexOf("\r\n")).toString("latin1"))?.[1] ?? 0);
+      if (status !== 200) {
+        stream.destroy(tunnelRefused(status));
+        return;
+      }
+      open4 = true;
+      sent.length = 0;
+      closedInRow.delete(target);
+      const rest = reply.subarray(end + 4);
+      reply = Buffer.alloc(0);
+      if (rest.length && !stream.push(rest)) socket.pause();
+    });
+    socket.on("error", (error) => {
+      if (!connected) {
+        if (first) {
+          if (pendingReject) {
+            pendingReject = void 0;
+            reject(error);
+          }
+        } else stream.destroy(error);
+        return;
+      }
+      if (open4) stream.destroy(error);
+    });
+    socket.on("close", () => {
+      if (!connected || stream.destroyed) return;
+      if (open4) {
+        stream.push(null);
+        return;
+      }
+      const closed = (closedInRow.get(target) ?? 0) + 1;
+      if (closed < TUNNEL_CLOSED_TRIES) {
+        closedInRow.set(target, closed);
+        dial(false).catch((error) => stream.destroy(error));
+        return;
+      }
+      closedInRow.delete(target);
+      stream.destroy(Object.assign(
+        new Error(`the local proxy closed ${TUNNEL_CLOSED_TRIES} tunnels in a row with no answer`),
+        { code: "ECONNREFUSED", port: proxyPort, tunnelClosed: true }
+      ));
+    });
+  });
+  stream.once("close", () => params.signal?.removeEventListener?.("abort", onAbort));
+  return dial(true).then(() => ({ statusCode: 200, socket: stream, headers: {} }), (error) => {
+    params.signal?.removeEventListener?.("abort", onAbort);
+    throw error;
   });
 }
-var TUNNEL_CLOSED_TRIES;
+var RUN_MARK, TUNNEL_CLOSED_TRIES;
 var init_tunnelGuard = __esm({
   "wallet/src/net/tunnelGuard.mjs"() {
     "use strict";
     init_keepAlive();
+    RUN_MARK = "SHINJUKU_WALLET_PROXIED";
     TUNNEL_CLOSED_TRIES = 3;
   }
 });
@@ -47239,7 +47371,7 @@ import { spawn } from "node:child_process";
 import { randomBytes as randomBytes5 } from "node:crypto";
 import dns from "node:dns";
 import http from "node:http";
-import net from "node:net";
+import net2 from "node:net";
 function proxyRefusedConnection(error) {
   if (ownProxyRefused) return true;
   const proxied = process.env[MARK];
@@ -47335,8 +47467,8 @@ function refuseDirectSockets(proxy) {
   const host = target.hostname.replace(/^\[|\]$/g, "");
   const loopback = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
   const isProxy = (candidateHost, candidatePort) => Number(candidatePort) === port && (candidateHost === host || loopback.has(candidateHost) && loopback.has(host));
-  const connect3 = net.Socket.prototype.connect;
-  net.Socket.prototype.connect = function guardedConnect(...args) {
+  const connect3 = net2.Socket.prototype.connect;
+  net2.Socket.prototype.connect = function guardedConnect(...args) {
     const [first] = args;
     const options = Array.isArray(first) ? first[0] : first;
     const allowed = options !== null && typeof options === "object" ? options.path !== void 0 || isProxy(options.host ?? "localhost", options.port) : typeof first === "string" && !/^\d+$/.test(first) || isProxy(typeof args[1] === "string" ? args[1] : "localhost", first);
@@ -47365,7 +47497,7 @@ function localTorCheck(proxy) {
   return new Promise((resolvePromise) => {
     let text3 = "";
     let done = false;
-    const socket = net.connect({ host, port });
+    const socket = net2.connect({ host, port });
     const finish = (answer, version3) => {
       if (done) return;
       done = true;
@@ -127519,13 +127651,13 @@ function networkPreference(network) {
   return { network: n };
 }
 function offerSupport(a, prefer) {
-  const net2 = a.network.toLowerCase();
+  const net3 = a.network.toLowerCase();
   if (prefer.any || prefer.solana) {
-    if (net2 !== "solana" && net2 !== SOLANA_MAINNET.toLowerCase()) return prefer.any ? 1 : 0;
+    if (net3 !== "solana" && net3 !== SOLANA_MAINNET.toLowerCase()) return prefer.any ? 1 : 0;
     if (a.scheme === null) return 1;
     return a.asset === SOLANA_USDC && SOLANA_SCHEMES.has(a.scheme) ? 2 : 1;
   }
-  return net2 === prefer.network ? 2 : 0;
+  return net3 === prefer.network ? 2 : 0;
 }
 function pickOffer(accepts, prefer) {
   let best = accepts[0];
@@ -127538,8 +127670,8 @@ function pickOffer(accepts, prefer) {
     }
   }
   const atomic4 = best?.amount == null ? null : String(best.amount);
-  const net2 = String(best?.network ?? "").toLowerCase();
-  const usdc7 = atomic4 !== null && /^[0-9]{1,31}$/.test(atomic4) && best.asset === SOLANA_USDC && (net2 === "solana" || net2 === SOLANA_MAINNET.toLowerCase()) ? formatUsdc(atomic4) : void 0;
+  const net3 = String(best?.network ?? "").toLowerCase();
+  const usdc7 = atomic4 !== null && /^[0-9]{1,31}$/.test(atomic4) && best.asset === SOLANA_USDC && (net3 === "solana" || net3 === SOLANA_MAINNET.toLowerCase()) ? formatUsdc(atomic4) : void 0;
   const price2 = best ? { atomic: atomic4, ...usdc7 === void 0 ? {} : { usdc: usdc7 }, asset: best.asset || null, network: best.network || null, scheme: best.scheme ?? null } : { atomic: null, asset: null, network: null, scheme: null };
   return { price: price2, support };
 }
@@ -148452,8 +148584,8 @@ async function programFeeRule(connection, ids) {
   const data = Buffer.from(info.data);
   return { withdrawalFeeRate: BigInt(data.readUInt16LE(WITHDRAWAL_FEE_RATE_OFFSET)), feeErrorMargin: BigInt(data.readUInt16LE(FEE_ERROR_MARGIN_OFFSET)) };
 }
-function programMinimumFee(net2, rule) {
-  const expected = BigInt(net2) * rule.withdrawalFeeRate / 10000n;
+function programMinimumFee(net3, rule) {
+  const expected = BigInt(net3) * rule.withdrawalFeeRate / 10000n;
   return expected === 0n ? 0n : expected * (10000n - rule.feeErrorMargin) / 10000n;
 }
 function transactAccounts({ ids, nullifiers, signer, signerTokenAccount, recipient, recipientTokenAccount, feeRecipientTokenAccount }) {
@@ -148658,14 +148790,14 @@ async function readRelayConfig2({ serviceUrl: serviceUrl2, ids, fetchImpl = fetc
     computeUnitPrice: BigInt(config.computeUnitPriceMicroLamports)
   });
 }
-async function buildLocalWithdrawal({ internals, sdk, connection, ids, encryptionService, notes, tree, net: net2, fee, relay, recipient }) {
+async function buildLocalWithdrawal({ internals, sdk, connection, ids, encryptionService, notes, tree, net: net3, fee, relay, recipient }) {
   const mint = ids.mint;
   const lightWasm = sdk.lightWasm;
   const dummyKey = new internals.UtxoKeypair(encryptionService.deriveUtxoPrivateKey(), lightWasm);
   const inputs = [notes[0].utxo, notes[1]?.utxo ?? new internals.Utxo({ lightWasm, keypair: dummyKey, amount: "0", mintAddress: mint, blinding: blinding() })];
   const paths = [tree.path(notes[0].index).pathElements, notes[1] ? tree.path(notes[1].index).pathElements : zeroPath()];
   const total = inputs.reduce((sum2, utxo) => sum2 + BigInt(utxo.amount.toString()), 0n);
-  const change = total - net2 - fee;
+  const change = total - net3 - fee;
   if (change < 0n) fail43("withdraw_balance_insufficient");
   const owner = new import_web3136.PublicKey(recipient);
   const recipientTokenAccount = getAssociatedTokenAddressSync(new import_web3136.PublicKey(mint), owner, false, TOKEN_PROGRAM_ID);
@@ -148678,7 +148810,7 @@ async function buildLocalWithdrawal({ internals, sdk, connection, ids, encryptio
     root: tree.root(),
     nextIndex: tree.elements().length,
     outputAmount: change,
-    extAmount: -net2,
+    extAmount: -net3,
     fee,
     recipientTokenAccount,
     feeRecipientTokenAccount: relay.feeTokenAccount,
@@ -149850,11 +149982,11 @@ async function privacyCashDeposit({ store, rpcUrl, treeRpcUrl, keyFile: keyFile2
   });
 }
 var withdrawFee = (gross, rate, rentFee) => Math.floor(gross * rate + UNITS * rentFee);
-function grossForNet(net2, rate, rentFee) {
+function grossForNet(net3, rate, rentFee) {
   const netOf = (gross2) => gross2 - withdrawFee(gross2, rate, rentFee);
-  let gross = Math.ceil((net2 + UNITS * rentFee) / (1 - rate));
-  while (netOf(gross) < net2) gross += 1;
-  while (netOf(gross - 1) >= net2) gross -= 1;
+  let gross = Math.ceil((net3 + UNITS * rentFee) / (1 - rate));
+  while (netOf(gross) < net3) gross += 1;
+  while (netOf(gross - 1) >= net3) gross -= 1;
   return gross;
 }
 async function feeConfig(utils) {
@@ -150004,17 +150136,17 @@ function crowdLines({ crowd, uncounted, gross }) {
   const deposits2 = `deposits of ${usdc4(gross)} USDC or more landed in Privacy Cash after ${ANCHOR_WORDS[crowd.anchor]}${crowd.lowerBound ? ` (at least: ${where})` : ""}, with no withdrawal of any amount within 5 minutes after them`;
   return short ? `--hold-override: only ${crowd.count} ${deposits2}, of the ${crowd.needed} this hold waits for: an observer who pairs deposits and withdrawals by time and amount has few candidates besides yours` : `cover: ${crowd.count} ${deposits2}: to an observer who pairs deposits and withdrawals by time and amount, each could have funded this withdrawal as well as yours`;
 }
-function withdrawLines({ owner, net: net2, fee, via = "sdk", relayer = PRIVACY_CASH.relayer }) {
+function withdrawLines({ owner, net: net3, fee, via = "sdk", relayer = PRIVACY_CASH.relayer }) {
   const reads = `reads of ${owner}'s USDC balance; no read names your source wallet`;
   if (via === "local") {
     return {
-      chain: `our facilitator's relayer (${relayer}) pays ${usdc4(net2)} USDC out of Privacy Cash's pool to the one-time address ${owner} and lets it hold USDC, and takes a ${usdc4(fee)} USDC fee in the same transaction; the amount and the time are public, and no transfer from your source wallet to ${owner} appears`,
+      chain: `our facilitator's relayer (${relayer}) pays ${usdc4(net3)} USDC out of Privacy Cash's pool to the one-time address ${owner} and lets it hold USDC, and takes a ${usdc4(fee)} USDC fee in the same transaction; the amount and the time are public, and no transfer from your source wallet to ${owner} appears`,
       privacyCash: `${PRIVACY_CASH.server} sees nothing: this wallet read the tree from the chain and built the proof itself; our facilitator sees your IP address, ${owner}, the amount, the time, and the notes this withdrawal spends (if it never lands and those notes are spent later, the facilitator can link that spend to ${owner})`,
       rpc: `your IP address (a Tor exit with --tor), the Privacy Cash tree reads (every transaction of its USDC tree), and reads of ${owner}'s USDC balance; no read names your source wallet or one of your notes (this wallet finds which notes are spent in the tree it read), except on a rerun after an earlier proof's spend paid ${owner} or went through a lookup table: that rerun reads the proof's nullifier records on chain`
     };
   }
   return {
-    chain: `Privacy Cash's relayer (${PRIVACY_CASH.relayer}) pays ${usdc4(net2)} USDC out of its pool to the one-time address ${owner} and lets it hold USDC; Privacy Cash keeps a ${usdc4(fee)} USDC fee; the amount and the time are public, and no transfer from your source wallet to ${owner} appears`,
+    chain: `Privacy Cash's relayer (${PRIVACY_CASH.relayer}) pays ${usdc4(net3)} USDC out of its pool to the one-time address ${owner} and lets it hold USDC; Privacy Cash keeps a ${usdc4(fee)} USDC fee; the amount and the time are public, and no transfer from your source wallet to ${owner} appears`,
     privacyCash: `${PRIVACY_CASH.server} sees your IP address, which notes are yours (so it can find the deposits that made them), the notes this withdrawal spends, and ${owner}: it can link this withdrawal to your deposit`,
     rpc: `your IP address (a Tor exit with --tor), the reads that check your notes, and ${reads}`
   };