@moonpay/cli 0.3.4 → 0.3.5

package/dist/chunk-SQTD2GMD.js

@@ -0,0 +1,1992 @@
+import { createRequire as __createRequire } from "module"; const require = __createRequire(import.meta.url);
+
+// src/auth.ts
+import { spawn } from "child_process";
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as http from "http";
+import * as os from "os";
+import * as path from "path";
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function generateCodeVerifier() {
+  return crypto.randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return crypto.createHash("sha256").update(verifier).digest("base64url");
+}
+var CONFIG_DIR = path.join(os.homedir(), ".config", "moonpay");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+var CREDENTIALS_PATH = path.join(CONFIG_DIR, "credentials.json");
+var LOCK_PATH = path.join(CONFIG_DIR, ".credentials.lock");
+var CALLBACK_PORT = 3847;
+var CALLBACK_URL = `http://localhost:${CALLBACK_PORT}/callback`;
+var DEFAULT_CONFIG = {
+  baseUrl: "https://agents.moonpay.com",
+  clientId: "mooniq_zin3s5jz3olzkdfxpmbeaogv"
+};
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function atomicWriteFileSync(filePath, data, mode) {
+  const tmp = filePath + `.tmp.${process.pid}`;
+  fs.writeFileSync(tmp, data, { encoding: "utf-8", mode });
+  fs.renameSync(tmp, filePath);
+}
+var LOCK_STALE_MS = 3e4;
+function acquireLock() {
+  ensureConfigDir();
+  try {
+    const fd = fs.openSync(LOCK_PATH, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY, 384);
+    fs.writeSync(fd, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs.closeSync(fd);
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+    try {
+      const lockData = JSON.parse(fs.readFileSync(LOCK_PATH, "utf-8"));
+      if (Date.now() - lockData.ts < LOCK_STALE_MS) {
+        return null;
+      }
+    } catch {
+    }
+    try {
+      fs.unlinkSync(LOCK_PATH);
+    } catch {
+    }
+    try {
+      const fd = fs.openSync(LOCK_PATH, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY, 384);
+      fs.writeSync(fd, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+      fs.closeSync(fd);
+    } catch {
+      return null;
+    }
+  }
+  return () => {
+    try {
+      fs.unlinkSync(LOCK_PATH);
+    } catch {
+    }
+  };
+}
+function getConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    if (!data.baseUrl || !data.clientId) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function getConfigOrDefault() {
+  const fromFile = getConfig();
+  if (fromFile) return fromFile;
+  saveConfig(DEFAULT_CONFIG);
+  return DEFAULT_CONFIG;
+}
+function getCredentials() {
+  if (!fs.existsSync(CREDENTIALS_PATH)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
+    if (!data.accessToken || !data.baseUrl) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(creds) {
+  ensureConfigDir();
+  atomicWriteFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), 384);
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  atomicWriteFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 384);
+}
+function clearCredentials() {
+  if (fs.existsSync(CREDENTIALS_PATH)) {
+    fs.unlinkSync(CREDENTIALS_PATH);
+  }
+}
+function resolveBaseUrl() {
+  const config = getConfig();
+  const creds = getCredentials();
+  return config?.baseUrl ?? creds?.baseUrl ?? DEFAULT_CONFIG.baseUrl;
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+}
+async function login(config) {
+  const state = crypto.randomUUID();
+  const usePkce = !config.clientSecret;
+  let codeVerifier;
+  if (usePkce) {
+    codeVerifier = generateCodeVerifier();
+  }
+  let resolveCallback;
+  const codePromise = new Promise((resolve2) => {
+    resolveCallback = resolve2;
+  });
+  const sockets = /* @__PURE__ */ new Set();
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${CALLBACK_PORT}`);
+    if (url.pathname === "/callback") {
+      const code2 = url.searchParams.get("code");
+      const returnedState = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      const errorDesc = url.searchParams.get("error_description");
+      if (returnedState !== state) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>OAuth Error</title></head><body style="font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#fef2f2"><h1 style="color:#b91c1c;margin:0 0 1rem">OAuth Error</h1><p style="color:#991b1b;margin:0">State mismatch \u2014 possible CSRF attack. Please try logging in again.</p></body></html>`
+        );
+        resolveCallback("");
+        setTimeout(() => server.close(), 2e3);
+      } else if (error) {
+        const safeError = escapeHtml(error);
+        const safeDesc = escapeHtml(errorDesc ?? "Unknown error");
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>OAuth Error</title></head><body style="font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#fef2f2"><h1 style="color:#b91c1c;margin:0 0 1rem">OAuth Error</h1><p style="color:#991b1b;margin:0">${safeError}: ${safeDesc}</p></body></html>`
+        );
+        resolveCallback("");
+        setTimeout(() => server.close(), 2e3);
+      } else if (code2) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>MoonPay Agents</title></head><body style="font-family:system-ui,-apple-system,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#0a0a0a;color:#fafafa"><img src="https://agents.moonpay.com/logos/moonpay.jpg" alt="MoonPay" style="width:64px;height:64px;border-radius:16px;margin-bottom:1.5rem" /><h1 style="margin:0 0 0.5rem;font-size:1.5rem;font-weight:600">Your agent has money now.</h1><p style="color:#a1a1aa;margin:0;font-size:1rem">You can close this tab and return to the terminal.</p></body></html>`
+        );
+        resolveCallback(code2);
+      } else {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Error</title></head><body style="font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#fef2f2"><h1 style="color:#b91c1c;margin:0 0 1rem">Error</h1><p style="color:#991b1b;margin:0">No authorization code received.</p></body></html>`
+        );
+        resolveCallback("");
+        setTimeout(() => server.close(), 2e3);
+      }
+    } else {
+      res.writeHead(204);
+      res.end();
+    }
+  });
+  await new Promise((resolve2, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(
+          new Error(
+            `Port ${CALLBACK_PORT} is in use. Close the other process or run: lsof -i :${CALLBACK_PORT}`
+          )
+        );
+      } else {
+        reject(err);
+      }
+    });
+    server.on("connection", (socket) => {
+      sockets.add(socket);
+      socket.on("close", () => sockets.delete(socket));
+    });
+    server.listen(CALLBACK_PORT, "127.0.0.1", () => resolve2());
+  });
+  console.log(
+    `Waiting for callback at http://localhost:${CALLBACK_PORT}/callback`
+  );
+  const authorizeParams = new URLSearchParams({
+    client_id: config.clientId,
+    redirect_uri: CALLBACK_URL,
+    response_type: "code",
+    scope: "profile email",
+    state
+  });
+  if (usePkce && codeVerifier) {
+    authorizeParams.set("code_challenge", generateCodeChallenge(codeVerifier));
+    authorizeParams.set("code_challenge_method", "S256");
+  }
+  const authorizeUrl = `${config.baseUrl}/authorize?${authorizeParams.toString()}`;
+  console.log("Opening browser for authorization...");
+  console.log("(Make sure you're logged in to MoonPay in your browser)\n");
+  openBrowser(authorizeUrl);
+  const code = await codePromise;
+  if (!code) {
+    throw new Error("No authorization code received");
+  }
+  const tokenParams = {
+    grant_type: "authorization_code",
+    code,
+    client_id: config.clientId,
+    redirect_uri: CALLBACK_URL
+  };
+  if (config.clientSecret) {
+    tokenParams.client_secret = config.clientSecret;
+  }
+  if (usePkce && codeVerifier) {
+    tokenParams.code_verifier = codeVerifier;
+  }
+  const tokenResponse = await fetch(`${config.baseUrl}/api/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(tokenParams)
+  });
+  if (!tokenResponse.ok) {
+    const err = await tokenResponse.json().catch(() => ({}));
+    const msg = err.error_description ?? err.error ?? tokenResponse.statusText;
+    throw new Error(`Token exchange failed: ${msg}`);
+  }
+  const tokens = await tokenResponse.json();
+  const expiresAt = Date.now() + (tokens.expires_in ?? 3600) * 1e3;
+  const creds = {
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token ?? null,
+    expiresAt,
+    baseUrl: config.baseUrl
+  };
+  saveCredentials(creds);
+  await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+  server.close();
+  for (const socket of sockets) {
+    if ("destroy" in socket && typeof socket.destroy === "function") {
+      socket.destroy();
+    }
+  }
+  sockets.clear();
+  return creds;
+}
+async function refreshCredentials(creds, config) {
+  if (!creds.refreshToken) {
+    throw new Error("No refresh token available");
+  }
+  const unlock = acquireLock();
+  if (!unlock) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    const fresh = getCredentials();
+    if (fresh && fresh.expiresAt > Date.now()) {
+      return fresh;
+    }
+    throw new Error("Token refresh failed (concurrent refresh in progress)");
+  }
+  try {
+    const latest = getCredentials();
+    if (latest && latest.expiresAt > Date.now() + 6e4) {
+      return latest;
+    }
+    const refreshParams = {
+      grant_type: "refresh_token",
+      refresh_token: creds.refreshToken,
+      client_id: config.clientId
+    };
+    if (config.clientSecret) {
+      refreshParams.client_secret = config.clientSecret;
+    }
+    const tokenResponse = await fetch(`${config.baseUrl}/api/oauth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams(refreshParams)
+    });
+    if (!tokenResponse.ok) {
+      throw new Error("Token refresh failed");
+    }
+    const tokens = await tokenResponse.json();
+    const expiresAt = Date.now() + (tokens.expires_in ?? 3600) * 1e3;
+    const newCreds = {
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token ?? creds.refreshToken,
+      expiresAt,
+      baseUrl: config.baseUrl
+    };
+    saveCredentials(newCreds);
+    return newCreds;
+  } finally {
+    unlock();
+  }
+}
+var TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+async function getValidToken() {
+  const creds = getCredentials();
+  if (!creds) return null;
+  const config = getConfig();
+  if (!config || config.baseUrl !== creds.baseUrl) return null;
+  if (Date.now() >= creds.expiresAt - TOKEN_EXPIRY_BUFFER_MS) {
+    if (creds.refreshToken) {
+      try {
+        const newCreds = await refreshCredentials(creds, config);
+        return newCreds.accessToken;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  return creds.accessToken;
+}
+
+// src/client.ts
+async function callTool(baseUrl, toolName, params) {
+  const token = await getValidToken();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  let res = await fetch(`${baseUrl}/api/tools/${toolName}`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(params)
+  });
+  if (res.status === 401 && token) {
+    const creds = getCredentials();
+    const config = getConfig();
+    if (creds?.refreshToken && config && config.baseUrl === creds.baseUrl) {
+      try {
+        const newCreds = await refreshCredentials(creds, config);
+        res = await fetch(`${baseUrl}/api/tools/${toolName}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${newCreds.accessToken}`
+          },
+          body: JSON.stringify(params)
+        });
+      } catch {
+      }
+    }
+  }
+  const data = await res.json();
+  if (res.status === 401) {
+    throw new Error("This command requires a MoonPay Agents account. Run `moonpay login` first.");
+  }
+  if (res.status < 200 || res.status >= 300) {
+    const err = data;
+    throw new Error(err?.error ?? `Tool call failed (${res.status})`);
+  }
+  return data;
+}
+
+// src/generated/schemas.json
+var schemas_default = [
+  {
+    name: "buy",
+    description: "Buy crypto with fiat via MoonPay. Returns a checkout URL to complete the purchase.",
+    inputSchema: {
+      $ref: "#/definitions/buy_input",
+      definitions: {
+        buy_input: {
+          type: "object",
+          properties: {
+            token: {
+              type: "string",
+              enum: [
+                "sol",
+                "usdc",
+                "usdc_arbitrum",
+                "usdc_base",
+                "usdc_optimism",
+                "usdc_sol",
+                "usdc_polygon",
+                "eth",
+                "eth_polygon",
+                "eth_optimism",
+                "eth_base",
+                "eth_arbitrum"
+              ],
+              description: "MoonPay currency code: sol (Solana), usdc_sol (USDC on Solana), eth (Ethereum), usdc (USDC on Ethereum), usdc_base (USDC on Base), etc."
+            },
+            amount: {
+              type: "number",
+              description: "Amount of token to buy (e.g. 1.5 for 1.5 SOL)"
+            },
+            wallet: {
+              type: "string",
+              description: "Destination wallet address to receive the tokens"
+            },
+            email: {
+              type: [
+                "string",
+                "null"
+              ],
+              description: "Buyer email to pre-fill on the checkout page"
+            }
+          },
+          required: [
+            "token",
+            "amount",
+            "wallet",
+            "email"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "token_balance_list",
+    description: "List all token balances held in a wallet, including amount owned, current value in USD, and token details. Shows the complete token portfolio.",
+    inputSchema: {
+      $ref: "#/definitions/token_balance_list_input",
+      definitions: {
+        token_balance_list_input: {
+          type: "object",
+          properties: {
+            wallet: {
+              type: "string",
+              description: "Wallet address to check token balances for"
+            },
+            chain: {
+              type: "string",
+              enum: [
+                "solana",
+                "ethereum",
+                "base",
+                "polygon",
+                "arbitrum",
+                "optimism"
+              ],
+              description: "Blockchain to check balances on (e.g. 'solana', 'ethereum', 'base')"
+            }
+          },
+          required: [
+            "wallet",
+            "chain"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "token_retrieve",
+    description: "Get detailed token information including market data, price changes, volume, trades, and holder statistics by token address",
+    inputSchema: {
+      $ref: "#/definitions/token_retrieve_input",
+      definitions: {
+        token_retrieve_input: {
+          type: "object",
+          properties: {
+            token: {
+              type: "string",
+              description: "Address of the token to retrieve"
+            },
+            chain: {
+              type: "string",
+              enum: [
+                "solana",
+                "ethereum",
+                "base",
+                "polygon",
+                "arbitrum",
+                "optimism"
+              ],
+              description: "Blockchain network where the token exists"
+            }
+          },
+          required: [
+            "token",
+            "chain"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "token_search",
+    description: "Search for tokens by name, symbol, or address. Returns matching tokens with their market data including price, volume, and liquidity.",
+    inputSchema: {
+      $ref: "#/definitions/token_search_input",
+      definitions: {
+        token_search_input: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search term - can be token name (e.g. 'Bitcoin'), symbol (e.g. 'BTC'), or partial match"
+            },
+            chain: {
+              type: "string",
+              enum: [
+                "solana",
+                "ethereum",
+                "base",
+                "polygon",
+                "arbitrum",
+                "optimism"
+              ],
+              description: "Blockchain to search on (e.g. 'solana', 'ethereum', 'base')"
+            },
+            limit: {
+              type: [
+                "number",
+                "null"
+              ],
+              description: "Maximum number of results to return (optional, defaults to 5)"
+            }
+          },
+          required: [
+            "query",
+            "chain",
+            "limit"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "token_swap_build",
+    description: "Build an unsigned swap transaction. Returns a base64-encoded transaction ready for signing.",
+    inputSchema: {
+      $ref: "#/definitions/token_swap_build_input",
+      definitions: {
+        token_swap_build_input: {
+          type: "object",
+          properties: {
+            input: {
+              type: "string",
+              description: "Mint address of the input token"
+            },
+            output: {
+              type: "string",
+              description: "Mint address of the output token"
+            },
+            amount: {
+              type: "number",
+              description: "Amount of the input token to swap"
+            },
+            wallet: {
+              type: "string",
+              description: "Wallet address that will execute the swap"
+            }
+          },
+          required: [
+            "input",
+            "output",
+            "amount",
+            "wallet"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "token_swap_execute",
+    description: "Execute a signed swap transaction. Pass the signed transaction and requestId from token_swap_build.",
+    inputSchema: {
+      $ref: "#/definitions/token_swap_execute_input",
+      definitions: {
+        token_swap_execute_input: {
+          type: "object",
+          properties: {
+            transaction: {
+              type: "string",
+              description: "Base64-encoded signed transaction"
+            },
+            requestId: {
+              type: "string",
+              description: "Request ID from token_swap_build"
+            }
+          },
+          required: [
+            "transaction",
+            "requestId"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "token_trending_list",
+    description: "Get currently trending tokens on a blockchain. Perfect for discovering what's hot right now.",
+    inputSchema: {
+      $ref: "#/definitions/token_trending_list_input",
+      definitions: {
+        token_trending_list_input: {
+          type: "object",
+          properties: {
+            chain: {
+              type: "string",
+              enum: [
+                "solana",
+                "ethereum",
+                "base",
+                "polygon",
+                "arbitrum",
+                "optimism"
+              ],
+              description: "Blockchain to get trending tokens from (e.g. 'solana', 'ethereum', 'base')"
+            },
+            limit: {
+              type: "number",
+              description: "Number of results per page"
+            },
+            page: {
+              type: "number",
+              description: "The page number of results"
+            }
+          },
+          required: [
+            "chain",
+            "limit",
+            "page"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "transaction_send",
+    description: "Broadcast a signed transaction to Solana. Simulates first, then sends and confirms.",
+    inputSchema: {
+      $ref: "#/definitions/transaction_send_input",
+      definitions: {
+        transaction_send_input: {
+          type: "object",
+          properties: {
+            transaction: {
+              type: "string",
+              description: "Base64-encoded signed transaction"
+            },
+            message: {
+              type: "string",
+              description: "Human-readable message describing the transaction"
+            }
+          },
+          required: [
+            "transaction",
+            "message"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "user_retrieve",
+    description: "Get the currently authenticated user",
+    inputSchema: {
+      $ref: "#/definitions/user_retrieve_input",
+      definitions: {
+        user_retrieve_input: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_bank-account_delete",
+    description: "Delete a bank account",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_bank-account_delete_input",
+      definitions: {
+        "virtual-account_bank-account_delete_input": {
+          type: "object",
+          properties: {
+            bankAccountId: {
+              type: "string",
+              format: "uuid",
+              description: "The ID of the bank account to delete"
+            }
+          },
+          required: [
+            "bankAccountId"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_bank-account_eur_register",
+    description: "Register a EUR bank account for offramp payouts",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_bank-account_eur_register_input",
+      definitions: {
+        "virtual-account_bank-account_eur_register_input": {
+          type: "object",
+          properties: {
+            iban: {
+              type: "string",
+              description: "IBAN for SEPA bank account"
+            },
+            address: {
+              type: "object",
+              properties: {
+                street: {
+                  type: "string",
+                  description: "Street address"
+                },
+                city: {
+                  type: "string",
+                  description: "City"
+                },
+                state: {
+                  type: "string",
+                  description: "State or province"
+                },
+                country: {
+                  type: "string",
+                  enum: [
+                    "US",
+                    "GB",
+                    "CA",
+                    "AU",
+                    "DE",
+                    "FR",
+                    "IT",
+                    "ES",
+                    "NL",
+                    "BE",
+                    "AT",
+                    "CH",
+                    "SE",
+                    "NO",
+                    "DK",
+                    "FI",
+                    "IE",
+                    "PT",
+                    "PL",
+                    "CZ",
+                    "GR",
+                    "JP",
+                    "KR",
+                    "CN",
+                    "IN",
+                    "BR",
+                    "MX",
+                    "AR",
+                    "ZA",
+                    "NZ",
+                    "SG",
+                    "HK",
+                    "AE"
+                  ],
+                  description: "ISO 3166-1 Alpha-2 country code"
+                },
+                postalCode: {
+                  type: "string",
+                  description: "Postal or ZIP code"
+                }
+              },
+              required: [
+                "street",
+                "city",
+                "state",
+                "country",
+                "postalCode"
+              ],
+              additionalProperties: false,
+              description: "Address of the user that owns the bank account"
+            },
+            email: {
+              type: "string",
+              description: "Email address of the user that owns the bank account"
+            },
+            phoneNumber: {
+              type: "string",
+              description: "Phone number of the user"
+            },
+            providerCountry: {
+              type: "string",
+              enum: [
+                "US",
+                "GB",
+                "CA",
+                "AU",
+                "DE",
+                "FR",
+                "IT",
+                "ES",
+                "NL",
+                "BE",
+                "AT",
+                "CH",
+                "SE",
+                "NO",
+                "DK",
+                "FI",
+                "IE",
+                "PT",
+                "PL",
+                "CZ",
+                "GR",
+                "JP",
+                "KR",
+                "CN",
+                "IN",
+                "BR",
+                "MX",
+                "AR",
+                "ZA",
+                "NZ",
+                "SG",
+                "HK",
+                "AE"
+              ],
+              description: "ISO 3166-1 Alpha-2 country code where the bank is located"
+            },
+            providerName: {
+              type: "string",
+              description: "Name of the bank"
+            },
+            givenName: {
+              type: "string",
+              description: "First/given name of the account holder"
+            },
+            familyName: {
+              type: "string",
+              description: "Last/family name of the account holder"
+            }
+          },
+          required: [
+            "iban",
+            "address",
+            "email",
+            "phoneNumber",
+            "providerCountry",
+            "providerName",
+            "givenName",
+            "familyName"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_bank-account_list",
+    description: "List registered bank accounts",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_bank-account_list_input",
+      definitions: {
+        "virtual-account_bank-account_list_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_bank-account_retrieve",
+    description: "Get a bank account by currency",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_bank-account_retrieve_input",
+      definitions: {
+        "virtual-account_bank-account_retrieve_input": {
+          type: "object",
+          properties: {
+            currency: {
+              type: "string",
+              enum: [
+                "USD",
+                "EUR"
+              ],
+              description: "The fiat currency code (USD or EUR)"
+            }
+          },
+          required: [
+            "currency"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_bank-account_usd_register",
+    description: "Register a USD bank account for offramp payouts",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_bank-account_usd_register_input",
+      definitions: {
+        "virtual-account_bank-account_usd_register_input": {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: [
+                "ACH",
+                "Wire"
+              ],
+              description: "Type of bank account (ACH or Wire)"
+            },
+            accountNumber: {
+              type: "string",
+              description: "Account number"
+            },
+            routingNumber: {
+              type: "string",
+              description: "Routing number"
+            },
+            address: {
+              type: "object",
+              properties: {
+                street: {
+                  type: "string",
+                  description: "Street address"
+                },
+                city: {
+                  type: "string",
+                  description: "City"
+                },
+                state: {
+                  type: "string",
+                  description: "State or province"
+                },
+                country: {
+                  type: "string",
+                  enum: [
+                    "US",
+                    "GB",
+                    "CA",
+                    "AU",
+                    "DE",
+                    "FR",
+                    "IT",
+                    "ES",
+                    "NL",
+                    "BE",
+                    "AT",
+                    "CH",
+                    "SE",
+                    "NO",
+                    "DK",
+                    "FI",
+                    "IE",
+                    "PT",
+                    "PL",
+                    "CZ",
+                    "GR",
+                    "JP",
+                    "KR",
+                    "CN",
+                    "IN",
+                    "BR",
+                    "MX",
+                    "AR",
+                    "ZA",
+                    "NZ",
+                    "SG",
+                    "HK",
+                    "AE"
+                  ],
+                  description: "ISO 3166-1 Alpha-2 country code"
+                },
+                postalCode: {
+                  type: "string",
+                  description: "Postal or ZIP code"
+                }
+              },
+              required: [
+                "street",
+                "city",
+                "state",
+                "country",
+                "postalCode"
+              ],
+              additionalProperties: false,
+              description: "Address of the user that owns the bank account"
+            },
+            email: {
+              type: "string",
+              description: "Email address of the user that owns the bank account"
+            },
+            phoneNumber: {
+              type: "string",
+              description: "Phone number of the user"
+            },
+            providerCountry: {
+              type: "string",
+              enum: [
+                "US",
+                "GB",
+                "CA",
+                "AU",
+                "DE",
+                "FR",
+                "IT",
+                "ES",
+                "NL",
+                "BE",
+                "AT",
+                "CH",
+                "SE",
+                "NO",
+                "DK",
+                "FI",
+                "IE",
+                "PT",
+                "PL",
+                "CZ",
+                "GR",
+                "JP",
+                "KR",
+                "CN",
+                "IN",
+                "BR",
+                "MX",
+                "AR",
+                "ZA",
+                "NZ",
+                "SG",
+                "HK",
+                "AE"
+              ],
+              description: "ISO 3166-1 Alpha-2 country code where the bank is located"
+            },
+            providerName: {
+              type: "string",
+              description: "Name of the bank"
+            },
+            givenName: {
+              type: "string",
+              description: "First/given name of the account holder"
+            },
+            familyName: {
+              type: "string",
+              description: "Last/family name of the account holder"
+            }
+          },
+          required: [
+            "type",
+            "accountNumber",
+            "routingNumber",
+            "address",
+            "email",
+            "phoneNumber",
+            "providerCountry",
+            "providerName",
+            "givenName",
+            "familyName"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_create",
+    description: "Create a virtual account and start KYC verification",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_create_input",
+      definitions: {
+        "virtual-account_create_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_delete",
+    description: "Delete your virtual account",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_delete_input",
+      definitions: {
+        "virtual-account_delete_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_identification_create",
+    description: "Create a KYC verification link to complete identity verification",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_identification_create_input",
+      definitions: {
+        "virtual-account_identification_create_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_identification_list",
+    description: "List all KYC identifications",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_identification_list_input",
+      definitions: {
+        "virtual-account_identification_list_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_identification_retrieve",
+    description: "Get the status of a KYC identification",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_identification_retrieve_input",
+      definitions: {
+        "virtual-account_identification_retrieve_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_offramp_create",
+    description: "Create an offramp to convert stablecoin to fiat",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_offramp_create_input",
+      definitions: {
+        "virtual-account_offramp_create_input": {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "The name of the offramp"
+            },
+            fiat: {
+              type: "string",
+              enum: [
+                "USD",
+                "EUR"
+              ],
+              description: "The fiat currency to convert to"
+            },
+            stablecoin: {
+              type: "string",
+              enum: [
+                "USDC",
+                "USDT",
+                "EURC"
+              ],
+              description: "The stablecoin token to convert from"
+            }
+          },
+          required: [
+            "name",
+            "fiat",
+            "stablecoin"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_offramp_delete",
+    description: "Cancel an offramp",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_offramp_delete_input",
+      definitions: {
+        "virtual-account_offramp_delete_input": {
+          type: "object",
+          properties: {
+            offrampId: {
+              type: "string",
+              format: "uuid",
+              description: "The ID of the offramp to cancel"
+            }
+          },
+          required: [
+            "offrampId"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_offramp_initiate",
+    description: "Build an unsigned transaction to send stablecoin to an offramp deposit address",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_offramp_initiate_input",
+      definitions: {
+        "virtual-account_offramp_initiate_input": {
+          type: "object",
+          properties: {
+            wallet: {
+              type: "string",
+              description: "The wallet address to send from"
+            },
+            offrampId: {
+              type: "string",
+              description: "The ID of the offramp to initiate"
+            },
+            amount: {
+              type: "number",
+              minimum: 0,
+              description: "The amount of stablecoin to send (in human-readable units, e.g., 100.5)"
+            }
+          },
+          required: [
+            "wallet",
+            "offrampId",
+            "amount"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_offramp_list",
+    description: "List all offramps",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_offramp_list_input",
+      definitions: {
+        "virtual-account_offramp_list_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_offramp_retrieve",
+    description: "Get offramp details",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_offramp_retrieve_input",
+      definitions: {
+        "virtual-account_offramp_retrieve_input": {
+          type: "object",
+          properties: {
+            offrampId: {
+              type: "string",
+              format: "uuid",
+              description: "The ID of the offramp to retrieve"
+            }
+          },
+          required: [
+            "offrampId"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_onramp_create",
+    description: "Create an onramp to convert fiat to stablecoin",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_onramp_create_input",
+      definitions: {
+        "virtual-account_onramp_create_input": {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "The name of the onramp"
+            },
+            fiat: {
+              type: "string",
+              enum: [
+                "USD",
+                "EUR"
+              ],
+              description: "The fiat currency to convert from"
+            },
+            stablecoin: {
+              type: "string",
+              enum: [
+                "USDC",
+                "USDT",
+                "EURC"
+              ],
+              description: "The stablecoin token to convert to"
+            }
+          },
+          required: [
+            "name",
+            "fiat",
+            "stablecoin"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_onramp_delete",
+    description: "Cancel an onramp",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_onramp_delete_input",
+      definitions: {
+        "virtual-account_onramp_delete_input": {
+          type: "object",
+          properties: {
+            onrampId: {
+              type: "string",
+              format: "uuid",
+              description: "The ID of the onramp to cancel"
+            }
+          },
+          required: [
+            "onrampId"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_onramp_list",
+    description: "List all onramps",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_onramp_list_input",
+      definitions: {
+        "virtual-account_onramp_list_input": {
+          type: "object",
+          properties: {
+            status: {
+              type: "string",
+              enum: [
+                "Created",
+                "Authorized",
+                "DepositAccountAdded",
+                "Approved",
+                "Rejected",
+                "Cancelled"
+              ],
+              description: "Status of the onramps to get"
+            }
+          },
+          required: [
+            "status"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_onramp_payment_create",
+    description: "Create an open banking payment link for an onramp",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_onramp_payment_create_input",
+      definitions: {
+        "virtual-account_onramp_payment_create_input": {
+          type: "object",
+          properties: {
+            onrampId: {
+              type: "string",
+              format: "uuid",
+              description: "The ID of the onramp"
+            },
+            amount: {
+              type: "string",
+              description: "The amount to pay"
+            },
+            fiat: {
+              type: "string",
+              enum: [
+                "USD",
+                "EUR"
+              ],
+              description: "The fiat currency (USD or EUR)"
+            }
+          },
+          required: [
+            "onrampId",
+            "amount",
+            "fiat"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_onramp_payment_retrieve",
+    description: "Get the status of an open banking payment",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_onramp_payment_retrieve_input",
+      definitions: {
+        "virtual-account_onramp_payment_retrieve_input": {
+          type: "object",
+          properties: {
+            onrampId: {
+              type: "string",
+              format: "uuid",
+              description: "The ID of the onramp this payment belongs to"
+            },
+            paymentId: {
+              type: "string",
+              format: "uuid",
+              description: "The ID of the payment to retrieve"
+            }
+          },
+          required: [
+            "onrampId",
+            "paymentId"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_onramp_retrieve",
+    description: "Get onramp details and banking info",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_onramp_retrieve_input",
+      definitions: {
+        "virtual-account_onramp_retrieve_input": {
+          type: "object",
+          properties: {
+            onrampId: {
+              type: "string",
+              format: "uuid",
+              description: "The ID of the onramp to retrieve"
+            }
+          },
+          required: [
+            "onrampId"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_retrieve",
+    description: "Get your virtual account status",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_retrieve_input",
+      definitions: {
+        "virtual-account_retrieve_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_signing_create",
+    description: "Sign a required document for your virtual account",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_signing_create_input",
+      definitions: {
+        "virtual-account_signing_create_input": {
+          type: "object",
+          properties: {
+            contentId: {
+              type: "string",
+              description: "The unique ID of the content to sign"
+            }
+          },
+          required: [
+            "contentId"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_signing_list",
+    description: "List all signed documents",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_signing_list_input",
+      definitions: {
+        "virtual-account_signing_list_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_signing_required_list",
+    description: "List documents that require your signature",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_signing_required_list_input",
+      definitions: {
+        "virtual-account_signing_required_list_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_transaction_list",
+    description: "List virtual account transactions",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_transaction_list_input",
+      definitions: {
+        "virtual-account_transaction_list_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_wallet_list",
+    description: "List registered wallets",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_wallet_list_input",
+      definitions: {
+        "virtual-account_wallet_list_input": {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_wallet_register",
+    description: "Register a wallet using a signed verification message",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_wallet_register_input",
+      definitions: {
+        "virtual-account_wallet_register_input": {
+          type: "object",
+          properties: {
+            wallet: {
+              type: "string",
+              description: "The wallet address to register"
+            },
+            message: {
+              type: "string",
+              description: "The verification message (from virtual-account_wallet_registration-message_create)"
+            },
+            signature: {
+              type: "string",
+              description: "Base58-encoded signature of the message"
+            }
+          },
+          required: [
+            "wallet",
+            "message",
+            "signature"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  },
+  {
+    name: "virtual-account_wallet_registration-message_create",
+    description: "Create the verification message to register a wallet",
+    inputSchema: {
+      $ref: "#/definitions/virtual-account_wallet_registration-message_create_input",
+      definitions: {
+        "virtual-account_wallet_registration-message_create_input": {
+          type: "object",
+          properties: {
+            wallet: {
+              type: "string",
+              description: "The wallet address to register"
+            }
+          },
+          required: [
+            "wallet"
+          ],
+          additionalProperties: false
+        }
+      },
+      $schema: "http://json-schema.org/draft-07/schema#"
+    }
+  }
+];
+
+// src/tools/wallet/create/tool.ts
+import { Keypair } from "@solana/web3.js";
+import bs58 from "bs58";
+
+// src/tools/shared.ts
+var defineToolSchema = (config) => config;
+var createTool = (schema, handler) => ({
+  schema,
+  handler: async (params) => {
+    const parsedInput = schema.input.parse(params);
+    const result = await handler(parsedInput);
+    return schema.output.parse(result);
+  }
+});
+
+// src/tools/wallet/server.ts
+import {
+  readFileSync as readFileSync2,
+  readdirSync,
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync2,
+  renameSync as renameSync2
+} from "fs";
+import { join as join2, resolve } from "path";
+import { homedir as homedir2 } from "os";
+import { randomBytes as randomBytes2 } from "crypto";
+
+// src/tools/wallet/models.ts
+import { z } from "zod";
+var walletSchema = z.object({
+  name: z.string(),
+  address: z.string(),
+  secretKey: z.string(),
+  chain: z.literal("solana"),
+  createdAt: z.string()
+});
+var walletInfoSchema = walletSchema.omit({ secretKey: true });
+
+// src/tools/wallet/server.ts
+var CONFIG_DIR2 = join2(homedir2(), ".config", "moonpay");
+var WALLETS_DIR = join2(CONFIG_DIR2, "wallets");
+function validateWalletName(name) {
+  if (!name || /[/\\]/.test(name) || name.includes("..") || name.includes("\0")) {
+    throw new Error(`Invalid wallet name: "${name}"`);
+  }
+  const resolved = resolve(WALLETS_DIR, `${name}.json`);
+  if (!resolved.startsWith(WALLETS_DIR + "/")) {
+    throw new Error(`Invalid wallet name: "${name}"`);
+  }
+}
+function ensureWalletsDir() {
+  mkdirSync2(WALLETS_DIR, { recursive: true, mode: 448 });
+}
+function getWalletPath(name) {
+  validateWalletName(name);
+  return join2(WALLETS_DIR, `${name}.json`);
+}
+function getWalletsDir() {
+  return WALLETS_DIR;
+}
+function saveWallet(wallet) {
+  ensureWalletsDir();
+  const filePath = getWalletPath(wallet.name);
+  if (existsSync2(filePath)) {
+    throw new Error(`Wallet "${wallet.name}" already exists`);
+  }
+  const safeName = wallet.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+  const tmpPath = join2(
+    WALLETS_DIR,
+    `.${safeName}.${randomBytes2(4).toString("hex")}.tmp`
+  );
+  writeFileSync2(tmpPath, JSON.stringify(wallet, null, 2), { mode: 384 });
+  renameSync2(tmpPath, filePath);
+}
+function loadWallet(nameOrAddress) {
+  ensureWalletsDir();
+  const files = readdirSync(WALLETS_DIR).filter((f) => f.endsWith(".json"));
+  for (const file of files) {
+    const raw = JSON.parse(readFileSync2(join2(WALLETS_DIR, file), "utf-8"));
+    const result = walletSchema.safeParse(raw);
+    if (!result.success) continue;
+    const wallet = result.data;
+    if (wallet.name === nameOrAddress || wallet.address === nameOrAddress)
+      return wallet;
+  }
+  throw new Error(`Wallet "${nameOrAddress}" not found`);
+}
+
+// src/tools/wallet/create/schema.ts
+import { z as z2 } from "zod";
+var walletCreateSchema = defineToolSchema({
+  name: "wallet_create",
+  description: "Generate a new Solana keypair and store it locally",
+  input: z2.object({
+    name: z2.string().describe("Wallet name")
+  }),
+  output: z2.object({
+    name: z2.string().describe("Wallet name"),
+    address: z2.string().describe("Solana wallet address (base58)")
+  })
+});
+
+// src/tools/wallet/create/tool.ts
+var walletCreate = createTool(walletCreateSchema, async (params) => {
+  const keypair = Keypair.generate();
+  const wallet = {
+    name: params.name,
+    address: keypair.publicKey.toBase58(),
+    secretKey: bs58.encode(keypair.secretKey),
+    chain: "solana",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveWallet(wallet);
+  return { name: wallet.name, address: wallet.address };
+});
+
+// src/tools/wallet/import/tool.ts
+import { Keypair as Keypair2 } from "@solana/web3.js";
+import bs582 from "bs58";
+import { createInterface } from "readline";
+
+// src/tools/wallet/import/schema.ts
+import { z as z3 } from "zod";
+var walletImportSchema = defineToolSchema({
+  name: "wallet_import",
+  description: "Import a Solana wallet from a base58 private key",
+  input: z3.object({
+    name: z3.string().describe("Wallet name"),
+    key: z3.string().nullable().describe("Base58-encoded private key (prompted interactively if not provided)")
+  }),
+  output: z3.object({
+    name: z3.string().describe("Wallet name"),
+    address: z3.string().describe("Solana wallet address (base58)")
+  })
+});
+
+// src/tools/wallet/import/tool.ts
+async function promptSecret(prompt) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve2) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+var walletImport = createTool(walletImportSchema, async (params) => {
+  const secretKeyBase58 = params.key !== null ? params.key : await promptSecret("Enter private key (base58): ");
+  let keypair;
+  try {
+    const secretKeyBytes = bs582.decode(secretKeyBase58);
+    keypair = Keypair2.fromSecretKey(secretKeyBytes);
+  } catch {
+    throw new Error(
+      "Invalid private key. Expected a base58-encoded Solana secret key."
+    );
+  }
+  const wallet = {
+    name: params.name,
+    address: keypair.publicKey.toBase58(),
+    secretKey: secretKeyBase58,
+    chain: "solana",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveWallet(wallet);
+  return { name: wallet.name, address: wallet.address };
+});
+
+// src/tools/wallet/list/tool.ts
+import { readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/tools/wallet/list/schema.ts
+import { z as z4 } from "zod";
+var walletListSchema = defineToolSchema({
+  name: "wallet_list",
+  description: "List all local wallets",
+  input: z4.object({}),
+  output: z4.array(walletInfoSchema)
+});
+
+// src/tools/wallet/list/tool.ts
+var walletList = createTool(walletListSchema, async () => {
+  ensureWalletsDir();
+  const dir = getWalletsDir();
+  const files = readdirSync2(dir).filter(
+    (f) => f.endsWith(".json") && !f.startsWith(".")
+  );
+  return files.map((f) => {
+    const wallet = JSON.parse(readFileSync3(join3(dir, f), "utf-8"));
+    return {
+      name: wallet.name,
+      address: wallet.address,
+      chain: wallet.chain,
+      createdAt: wallet.createdAt
+    };
+  });
+});
+
+// src/tools/wallet/retrieve/schema.ts
+import { z as z5 } from "zod";
+var walletRetrieveSchema = defineToolSchema({
+  name: "wallet_retrieve",
+  description: "Get details of a specific wallet",
+  input: z5.object({
+    wallet: z5.string().describe("Wallet name or address")
+  }),
+  output: walletInfoSchema
+});
+
+// src/tools/wallet/retrieve/tool.ts
+var walletRetrieve = createTool(
+  walletRetrieveSchema,
+  async (params) => {
+    const wallet = loadWallet(params.wallet);
+    return {
+      name: wallet.name,
+      address: wallet.address,
+      chain: wallet.chain,
+      createdAt: wallet.createdAt
+    };
+  }
+);
+
+// src/tools/wallet/delete/tool.ts
+import { unlinkSync as unlinkSync2 } from "fs";
+
+// src/tools/wallet/delete/schema.ts
+import { z as z6 } from "zod";
+var walletDeleteSchema = defineToolSchema({
+  name: "wallet_delete",
+  description: "Permanently delete a local wallet. This removes the private key file and cannot be undone.",
+  input: z6.object({
+    wallet: z6.string().describe("Name or address of the wallet to delete"),
+    confirm: z6.boolean().describe("Must be true to confirm deletion")
+  }),
+  output: z6.object({
+    name: z6.string().describe("Name of the deleted wallet"),
+    deleted: z6.literal(true)
+  })
+});
+
+// src/tools/wallet/delete/tool.ts
+var walletDelete = createTool(walletDeleteSchema, async (params) => {
+  if (!params.confirm) {
+    throw new Error(
+      "Deletion not confirmed. Pass --confirm to permanently delete this wallet."
+    );
+  }
+  const wallet = await walletRetrieve.handler({ wallet: params.wallet });
+  unlinkSync2(getWalletPath(wallet.name));
+  return { name: wallet.name, deleted: true };
+});
+
+// src/tools/transaction/sign/tool.ts
+import { Keypair as Keypair3, VersionedTransaction } from "@solana/web3.js";
+import bs583 from "bs58";
+
+// src/tools/transaction/sign/schema.ts
+import { z as z7 } from "zod";
+var transactionSignSchema = defineToolSchema({
+  name: "transaction_sign",
+  description: "Sign a base64-encoded Solana transaction with a local wallet",
+  input: z7.object({
+    wallet: z7.string().describe("Wallet address"),
+    transaction: z7.string().describe("Base64-encoded unsigned transaction")
+  }),
+  output: z7.object({
+    transaction: z7.string().describe("Base64-encoded signed transaction")
+  })
+});
+
+// src/tools/transaction/sign/tool.ts
+var transactionSign = createTool(
+  transactionSignSchema,
+  async (params) => {
+    const storedWallet = loadWallet(params.wallet);
+    const txBytes = Buffer.from(params.transaction.trim(), "base64");
+    const tx = VersionedTransaction.deserialize(txBytes);
+    const secretKeyBytes = bs583.decode(storedWallet.secretKey);
+    const keypair = Keypair3.fromSecretKey(secretKeyBytes);
+    tx.sign([keypair]);
+    return {
+      transaction: Buffer.from(tx.serialize()).toString("base64")
+    };
+  }
+);
+
+// src/tools/message/sign/tool.ts
+import { Keypair as Keypair4 } from "@solana/web3.js";
+import bs584 from "bs58";
+import nacl from "tweetnacl";
+
+// src/tools/message/sign/schema.ts
+import { z as z8 } from "zod";
+var messageSignSchema = defineToolSchema({
+  name: "message_sign",
+  description: "Sign a message with a local wallet. Produces a base58-encoded ed25519 signature compatible with Solana's signMessage.",
+  input: z8.object({
+    wallet: z8.string().describe("Wallet address to sign with"),
+    message: z8.string().describe("Message text to sign")
+  }),
+  output: z8.object({
+    signature: z8.string().describe("Base58-encoded ed25519 signature")
+  })
+});
+
+// src/tools/message/sign/tool.ts
+var messageSign = createTool(messageSignSchema, async (params) => {
+  const storedWallet = loadWallet(params.wallet);
+  const secretKeyBytes = bs584.decode(storedWallet.secretKey);
+  const keypair = Keypair4.fromSecretKey(secretKeyBytes);
+  const messageBytes = Buffer.from(params.message, "utf8");
+  const signatureBytes = nacl.sign.detached(messageBytes, keypair.secretKey);
+  return { signature: bs584.encode(signatureBytes) };
+});
+
+export {
+  getConfigOrDefault,
+  clearCredentials,
+  resolveBaseUrl,
+  login,
+  callTool,
+  schemas_default,
+  defineToolSchema,
+  createTool,
+  loadWallet,
+  walletCreate,
+  walletImport,
+  walletList,
+  walletRetrieve,
+  walletDelete,
+  transactionSign,
+  messageSign
+};
+//# sourceMappingURL=chunk-SQTD2GMD.js.map