mpp32-mcp-server 1.2.0 → 1.2.1

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to `mpp32-mcp-server` are documented here. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.1] - 2026-05-11
+
+### Fixed
+
+* **"Server disconnected" on startup under Claude Desktop's bundled Node.**
+  1.2.0 imported `@solana/kit` (and `@solana-program/*`) at the top of the
+  payment-signer module. Those packages declare `engines.node: ">=20.18.0"`
+  and use Node-20-only WebCrypto Ed25519 APIs at load time. Claude Desktop
+  ships a bundled Node that on many installs is still 18.x, so the import
+  threw before the MCP server could answer the initialize handshake — the
+  process exited and Claude Desktop reported only "Server disconnected"
+  with no further diagnostics. All Solana and EVM crypto deps are now
+  loaded lazily inside the signer functions. The server boots on any Node
+  that supports MCP; only a `solana:*` payment attempt fails on too-old
+  Node, and now with a clear actionable error.
+
 ## [1.2.0] - 2026-05-11
 
 This release makes x402 payments actually work end-to-end. Prior versions

package/dist/index.js

@@ -3,7 +3,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { signX402Payment } from "./x402-signers.js";
-const SERVER_VERSION = "1.2.0";
+const SERVER_VERSION = "1.2.1";
 // ── Env loading: trim and sanitize aggressively ─────────────────────────────
 // Copy-paste from Claude Desktop / Cursor / Windsurf JSON config UIs frequently
 // adds trailing \n, \r, NBSP, BOM, or wraps the value in literal quotes. Any

package/dist/x402-signers.js

@@ -17,12 +17,50 @@
 // In both cases the outer envelope is
 //   { x402Version: 1, scheme: "exact", network, payload: <scheme payload> }
 // base64-encoded into the `X-Payment` HTTP header.
-import { address, createKeyPairSignerFromBytes, createSolanaRpc, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, partiallySignTransactionMessageWithSigners, getBase64EncodedWireTransaction, pipe, } from "@solana/kit";
-import { getTransferCheckedInstruction, findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS, } from "@solana-program/token";
-import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, } from "@solana-program/compute-budget";
-import { privateKeyToAccount } from "viem/accounts";
-import bs58 from "bs58";
-import nacl from "tweetnacl";
+async function loadSvmDeps() {
+    const [kit, tokenProgram, computeBudgetProgram, bs58Mod, naclMod] = await Promise.all([
+        import("@solana/kit"),
+        import("@solana-program/token"),
+        import("@solana-program/compute-budget"),
+        import("bs58"),
+        import("tweetnacl"),
+    ]).catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Could not load Solana signing libraries: ${msg}. ` +
+            `Solana x402 payments require Node 20.18 or newer (Claude Desktop's bundled Node may be older). ` +
+            `Upgrade Node, or run mpp32-mcp-server under a system Node 20+ via your MCP config's "command".`);
+    });
+    return {
+        address: kit.address,
+        createKeyPairSignerFromBytes: kit.createKeyPairSignerFromBytes,
+        createSolanaRpc: kit.createSolanaRpc,
+        createTransactionMessage: kit.createTransactionMessage,
+        setTransactionMessageFeePayer: kit.setTransactionMessageFeePayer,
+        setTransactionMessageLifetimeUsingBlockhash: kit.setTransactionMessageLifetimeUsingBlockhash,
+        appendTransactionMessageInstructions: kit.appendTransactionMessageInstructions,
+        partiallySignTransactionMessageWithSigners: kit.partiallySignTransactionMessageWithSigners,
+        getBase64EncodedWireTransaction: kit.getBase64EncodedWireTransaction,
+        pipe: kit.pipe,
+        getTransferCheckedInstruction: tokenProgram.getTransferCheckedInstruction,
+        findAssociatedTokenPda: tokenProgram.findAssociatedTokenPda,
+        TOKEN_PROGRAM_ADDRESS: tokenProgram.TOKEN_PROGRAM_ADDRESS,
+        getSetComputeUnitLimitInstruction: computeBudgetProgram.getSetComputeUnitLimitInstruction,
+        getSetComputeUnitPriceInstruction: computeBudgetProgram.getSetComputeUnitPriceInstruction,
+        bs58: bs58Mod.default ?? bs58Mod,
+        nacl: naclMod.default ?? naclMod,
+    };
+}
+async function loadEvmDeps() {
+    try {
+        const viemAccounts = await import("viem/accounts");
+        return { privateKeyToAccount: viemAccounts.privateKeyToAccount };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Could not load EVM signing libraries: ${msg}. ` +
+            `Base / Ethereum x402 payments require Node 18 or newer. Upgrade Node and retry.`);
+    }
+}
 // ── Network classification ──────────────────────────────────────────────────
 const SOLANA_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 const SOLANA_DEVNET = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
@@ -46,8 +84,7 @@ function chainSpecFor(network) {
     }
     throw new Error(`Unsupported EVM network "${network}". x402 EVM payments currently support: base, base-sepolia, ethereum.`);
 }
-// ── Key decoding ────────────────────────────────────────────────────────────
-function decodeSolanaSecret(raw) {
+function decodeSolanaSecret(raw, deps) {
     if (raw.startsWith("[")) {
         const arr = JSON.parse(raw);
         if (!Array.isArray(arr))
@@ -57,20 +94,20 @@ function decodeSolanaSecret(raw) {
     if (/^[0-9a-fA-F]+$/.test(raw) && raw.length % 2 === 0) {
         return new Uint8Array(Buffer.from(raw, "hex"));
     }
-    return bs58.decode(raw);
+    return deps.bs58.decode(raw);
 }
-async function buildSolanaSigner(rawKey) {
-    let bytes = decodeSolanaSecret(rawKey);
+async function buildSolanaSigner(rawKey, deps) {
+    let bytes = decodeSolanaSecret(rawKey, deps);
     if (bytes.length === 32) {
         // 32-byte seed — kit's createKeyPairSignerFromBytes wants the 64-byte
         // expanded key. Derive via tweetnacl.
-        const kp = nacl.sign.keyPair.fromSeed(bytes);
+        const kp = deps.nacl.sign.keyPair.fromSeed(bytes);
         bytes = kp.secretKey;
     }
     else if (bytes.length !== 64) {
         throw new Error(`Solana private key must be a 32-byte seed or a 64-byte expanded key; got ${bytes.length} bytes.`);
     }
-    return await createKeyPairSignerFromBytes(bytes);
+    return await deps.createKeyPairSignerFromBytes(bytes);
 }
 // ── SVM signer ──────────────────────────────────────────────────────────────
 const DEFAULT_SOLANA_RPC = "https://api.mainnet-beta.solana.com";
@@ -86,33 +123,34 @@ export async function signX402PaymentSvm(requirements, rawKey, rpcUrlOverride) {
     const amount = BigInt(requirements.maxAmountRequired);
     if (amount <= 0n)
         throw new Error(`Invalid maxAmountRequired: ${requirements.maxAmountRequired}`);
-    const signer = await buildSolanaSigner(rawKey);
+    const deps = await loadSvmDeps();
+    const signer = await buildSolanaSigner(rawKey, deps);
     const payerAddress = signer.address;
-    const mintAddress = address(requirements.asset);
-    const recipientAddress = address(requirements.payTo);
-    const feePayerAddress = address(requirements.extra.feePayer);
+    const mintAddress = deps.address(requirements.asset);
+    const recipientAddress = deps.address(requirements.payTo);
+    const feePayerAddress = deps.address(requirements.extra.feePayer);
     // Derive both sides' associated token accounts (classic SPL Token program).
     const [sourceAtaTuple, destinationAtaTuple] = await Promise.all([
-        findAssociatedTokenPda({
+        deps.findAssociatedTokenPda({
             owner: payerAddress,
             mint: mintAddress,
-            tokenProgram: TOKEN_PROGRAM_ADDRESS,
+            tokenProgram: deps.TOKEN_PROGRAM_ADDRESS,
         }),
-        findAssociatedTokenPda({
+        deps.findAssociatedTokenPda({
             owner: recipientAddress,
             mint: mintAddress,
-            tokenProgram: TOKEN_PROGRAM_ADDRESS,
+            tokenProgram: deps.TOKEN_PROGRAM_ADDRESS,
         }),
     ]);
     const sourceAta = sourceAtaTuple[0];
     const destinationAta = destinationAtaTuple[0];
     const rpcUrl = rpcUrlOverride && rpcUrlOverride.length > 0 ? rpcUrlOverride : DEFAULT_SOLANA_RPC;
-    const rpc = createSolanaRpc(rpcUrl);
+    const rpc = deps.createSolanaRpc(rpcUrl);
     const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
     const instructions = [
-        getSetComputeUnitLimitInstruction({ units: 150_000 }),
-        getSetComputeUnitPriceInstruction({ microLamports: 1000n }),
-        getTransferCheckedInstruction({
+        deps.getSetComputeUnitLimitInstruction({ units: 150_000 }),
+        deps.getSetComputeUnitPriceInstruction({ microLamports: 1000n }),
+        deps.getTransferCheckedInstruction({
             source: sourceAta,
             mint: mintAddress,
             destination: destinationAta,
@@ -121,11 +159,11 @@ export async function signX402PaymentSvm(requirements, rawKey, rpcUrlOverride) {
             decimals,
         }),
     ];
-    const message = pipe(createTransactionMessage({ version: 0 }), (m) => setTransactionMessageFeePayer(feePayerAddress, m), (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m), (m) => appendTransactionMessageInstructions(instructions, m));
+    const message = deps.pipe(deps.createTransactionMessage({ version: 0 }), (m) => deps.setTransactionMessageFeePayer(feePayerAddress, m), (m) => deps.setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m), (m) => deps.appendTransactionMessageInstructions(instructions, m));
     // Partially sign — fills the payer's signature slot, leaves the fee payer's
     // slot empty for the facilitator to fill in at /settle time.
-    const partiallySigned = await partiallySignTransactionMessageWithSigners(message);
-    const base64Tx = getBase64EncodedWireTransaction(partiallySigned);
+    const partiallySigned = await deps.partiallySignTransactionMessageWithSigners(message);
+    const base64Tx = deps.getBase64EncodedWireTransaction(partiallySigned);
     const envelope = {
         x402Version: 1,
         scheme: "exact",
@@ -163,6 +201,7 @@ export async function signX402PaymentEvm(requirements, rawKey) {
     if (!/^0x[0-9a-fA-F]{64}$/.test(keyHex)) {
         throw new Error("MPP32_PRIVATE_KEY must be a 64-character hex EVM private key (0x-prefixed or bare).");
     }
+    const { privateKeyToAccount } = await loadEvmDeps();
     const account = privateKeyToAccount(keyHex);
     const now = Math.floor(Date.now() / 1000);
     const validAfter = BigInt(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mpp32-mcp-server",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "mcpName": "io.github.MPP32/mpp32-mcp-server",
   "description": "Payment layer for AI agents. One MCP, five protocols, thousands of paid APIs your agent can call.",
   "type": "module",