@moonpay/cli 0.4.2 → 0.5.0

package/dist/chunk-DAQDHLPY.js

@@ -1,2444 +0,0 @@
-import { createRequire as __createRequire } from "module"; const require = __createRequire(import.meta.url);
-import {
-  KEY_CHAIN_MAP,
-  chainSchema,
-  deleteWalletFile,
-  keyChainSchema,
-  loadAllWallets,
-  loadWallet,
-  lockedVaultDataSchema,
-  saveWalletMetadata,
-  vaultDataSchema,
-  walletInfoSchema
-} from "./chunk-AGDVU2O5.js";
-import {
-  deriveAllAddresses,
-  deriveKeyForChain
-} from "./chunk-Z33PSOPD.js";
-import {
-  __require
-} from "./chunk-EEBB5MQP.js";
-
-// src/auth.ts
-import { spawn } from "child_process";
-import * as crypto from "crypto";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { createInterface } from "readline";
-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 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];
-  try {
-    spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
-    return true;
-  } catch {
-    return false;
-  }
-}
-function promptLine(prompt) {
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve) => {
-    rl.question(prompt, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-var LOGIN_STATE_PATH = path.join(CONFIG_DIR, ".login-state.json");
-async function login(config, options = {}) {
-  const callbackUrl = `${config.baseUrl}/callback`;
-  if (options.code) {
-    const stateData = loadLoginState();
-    if (!stateData) {
-      throw new Error("No pending login found. Run `mp login --no-browser` first.");
-    }
-    return exchangeCode(config, options.code, callbackUrl, stateData.codeVerifier);
-  }
-  const state = crypto.randomUUID();
-  const usePkce = !config.clientSecret;
-  let codeVerifier;
-  if (usePkce) {
-    codeVerifier = generateCodeVerifier();
-  }
-  const authorizeParams = new URLSearchParams({
-    client_id: config.clientId,
-    redirect_uri: callbackUrl,
-    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()}`;
-  saveLoginState({ state, codeVerifier: codeVerifier ?? null });
-  const opened = options.noBrowser ? false : openBrowser(authorizeUrl);
-  console.log("Open this URL in your browser to log in:\n");
-  console.log(`  ${authorizeUrl}
-`);
-  if (options.noBrowser) {
-    console.log("Tip: you can run `open <url>` to open it directly.");
-    console.log("After authorizing, copy the code and run:\n");
-    console.log("  mp login --code <paste-code-here>\n");
-    process.exit(0);
-  }
-  const code = await promptLine("Paste code: ");
-  if (!code) {
-    throw new Error("No authorization code provided.");
-  }
-  return exchangeCode(config, code, callbackUrl, codeVerifier ?? null);
-}
-function saveLoginState(state) {
-  ensureConfigDir();
-  atomicWriteFileSync(LOGIN_STATE_PATH, JSON.stringify(state), 384);
-}
-function loadLoginState() {
-  if (!fs.existsSync(LOGIN_STATE_PATH)) return null;
-  try {
-    const data = JSON.parse(fs.readFileSync(LOGIN_STATE_PATH, "utf-8"));
-    fs.unlinkSync(LOGIN_STATE_PATH);
-    return data;
-  } catch {
-    return null;
-  }
-}
-async function exchangeCode(config, code, callbackUrl, codeVerifier) {
-  const tokenParams = {
-    grant_type: "authorization_code",
-    code,
-    client_id: config.clientId,
-    redirect_uri: callbackUrl
-  };
-  if (config.clientSecret) {
-    tokenParams.client_secret = config.clientSecret;
-  }
-  if (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);
-  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 the token to buy, in token units \u2014 not fiat. For example, 1.5 means 1.5 SOL, not $1.50."
-            },
-            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_transfer_build",
-    description: "Build an unsigned transfer transaction. Returns a base64-encoded transaction ready for signing. Handles both native SOL and SPL tokens.",
-    inputSchema: {
-      $ref: "#/definitions/token_transfer_build_input",
-      definitions: {
-        token_transfer_build_input: {
-          type: "object",
-          properties: {
-            wallet: {
-              type: "string",
-              description: "Wallet address to transfer from"
-            },
-            token: {
-              type: "string",
-              description: "Mint address of the token to transfer"
-            },
-            to: {
-              type: "string",
-              description: "Recipient wallet address"
-            },
-            amount: {
-              type: "number",
-              description: "Amount to transfer in human-readable units (e.g. 1.5)"
-            }
-          },
-          required: [
-            "wallet",
-            "token",
-            "to",
-            "amount"
-          ],
-          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 { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
-import { generateMnemonic } from "@scure/bip39";
-import { wordlist as english } from "@scure/bip39/wordlists/english";
-
-// 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/vault.ts
-import {
-  readFileSync as readFileSync2,
-  writeFileSync as writeFileSync2,
-  existsSync as existsSync2,
-  renameSync as renameSync2,
-  mkdirSync as mkdirSync2
-} from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
-import {
-  randomBytes as randomBytes2,
-  randomUUID as randomUUID2,
-  scryptSync,
-  createCipheriv,
-  createDecipheriv
-} from "crypto";
-var CONFIG_DIR2 = join2(homedir2(), ".config", "moonpay");
-var VAULT_PATH = join2(CONFIG_DIR2, "vault.json");
-function ensureConfigDir2() {
-  mkdirSync2(CONFIG_DIR2, { recursive: true, mode: 448 });
-}
-function loadVault() {
-  if (!existsSync2(VAULT_PATH)) {
-    const empty = { version: 1, entries: {} };
-    saveVault(empty);
-    return empty;
-  }
-  const raw = JSON.parse(readFileSync2(VAULT_PATH, "utf-8"));
-  const locked = lockedVaultDataSchema.safeParse(raw);
-  if (locked.success) {
-    throw new Error(
-      "Vault is locked. Run `mp wallet unlock` to decrypt it first."
-    );
-  }
-  const result = vaultDataSchema.safeParse(raw);
-  if (!result.success) {
-    throw new Error("Vault file is corrupted or has an unknown format.");
-  }
-  return result.data;
-}
-function saveVault(vault) {
-  ensureConfigDir2();
-  const tmpPath = join2(
-    CONFIG_DIR2,
-    `.vault.${randomBytes2(4).toString("hex")}.tmp`
-  );
-  writeFileSync2(tmpPath, JSON.stringify(vault, null, 2), { mode: 384 });
-  renameSync2(tmpPath, VAULT_PATH);
-}
-function isVaultLocked() {
-  if (!existsSync2(VAULT_PATH)) return false;
-  const raw = JSON.parse(readFileSync2(VAULT_PATH, "utf-8"));
-  return lockedVaultDataSchema.safeParse(raw).success;
-}
-function addHdEntry(mnemonic) {
-  const vault = loadVault();
-  const id = randomUUID2();
-  const entry = { id, type: "hd", mnemonic };
-  vault.entries[id] = entry;
-  saveVault(vault);
-  return id;
-}
-function addImportedEntry(chain, privateKey) {
-  const vault = loadVault();
-  const id = randomUUID2();
-  const entry = { id, type: "imported", chain, privateKey };
-  vault.entries[id] = entry;
-  saveVault(vault);
-  return id;
-}
-function removeVaultEntry(id) {
-  const vault = loadVault();
-  delete vault.entries[id];
-  saveVault(vault);
-}
-function resolveSigningKey(wallet, chain) {
-  const vault = loadVault();
-  const entry = vault.entries[wallet.vaultRef];
-  if (!entry) {
-    throw new Error(
-      `Vault entry not found for wallet "${wallet.name}". The vault may be out of sync.`
-    );
-  }
-  const keyChain = KEY_CHAIN_MAP[chain];
-  if (entry.type === "imported") {
-    if (entry.chain !== keyChain) {
-      throw new Error(
-        `Wallet "${wallet.name}" was imported for ${entry.chain}, cannot sign for ${chain}.`
-      );
-    }
-    return {
-      privateKey: decodePrivateKey(entry.privateKey, keyChain),
-      address: wallet.addresses[keyChain]
-    };
-  }
-  const derived = deriveKeyForChain(entry.mnemonic, keyChain, wallet.account ?? 0);
-  return {
-    privateKey: derived.privateKey,
-    address: derived.address
-  };
-}
-function decodePrivateKey(key, chain) {
-  if (chain === "solana") {
-    const bs583 = __require("bs58");
-    return bs583.default.decode(key);
-  }
-  return Uint8Array.from(Buffer.from(key, "hex"));
-}
-var SCRYPT_N = 2 ** 14;
-var SCRYPT_R = 8;
-var SCRYPT_P = 1;
-var KEY_LENGTH = 32;
-function deriveEncryptionKey(password, salt) {
-  return scryptSync(password, salt, KEY_LENGTH, {
-    N: SCRYPT_N,
-    r: SCRYPT_R,
-    p: SCRYPT_P
-  });
-}
-function lockVault(password) {
-  const vault = loadVault();
-  const salt = randomBytes2(32);
-  const key = deriveEncryptionKey(password, salt);
-  const iv = randomBytes2(12);
-  const cipher = createCipheriv("aes-256-gcm", key, iv);
-  const plaintext = JSON.stringify(vault);
-  const encrypted = Buffer.concat([
-    cipher.update(plaintext, "utf8"),
-    cipher.final()
-  ]);
-  const tag = cipher.getAuthTag();
-  const locked = {
-    version: 1,
-    locked: true,
-    ciphertext: encrypted.toString("base64"),
-    iv: iv.toString("base64"),
-    salt: salt.toString("base64"),
-    tag: tag.toString("base64")
-  };
-  ensureConfigDir2();
-  const tmpPath = join2(
-    CONFIG_DIR2,
-    `.vault.${randomBytes2(4).toString("hex")}.tmp`
-  );
-  writeFileSync2(tmpPath, JSON.stringify(locked, null, 2), { mode: 384 });
-  renameSync2(tmpPath, VAULT_PATH);
-}
-function unlockVault(password) {
-  if (!existsSync2(VAULT_PATH)) {
-    throw new Error("No vault found. Create a wallet first.");
-  }
-  const raw = JSON.parse(readFileSync2(VAULT_PATH, "utf-8"));
-  const locked = lockedVaultDataSchema.safeParse(raw);
-  if (!locked.success) {
-    throw new Error("Vault is not locked.");
-  }
-  const { ciphertext, iv, salt, tag } = locked.data;
-  const saltBuf = Buffer.from(salt, "base64");
-  const key = deriveEncryptionKey(password, saltBuf);
-  const ivBuf = Buffer.from(iv, "base64");
-  const tagBuf = Buffer.from(tag, "base64");
-  const ciphertextBuf = Buffer.from(ciphertext, "base64");
-  const decipher = createDecipheriv("aes-256-gcm", key, ivBuf, { authTagLength: 16 });
-  decipher.setAuthTag(tagBuf);
-  let decrypted;
-  try {
-    decrypted = Buffer.concat([
-      decipher.update(ciphertextBuf),
-      decipher.final()
-    ]);
-  } catch {
-    throw new Error("Wrong password.");
-  }
-  const vault = vaultDataSchema.parse(JSON.parse(decrypted.toString("utf8")));
-  saveVault(vault);
-}
-
-// src/tools/wallet/create/schema.ts
-import { z } from "zod";
-var walletCreateSchema = defineToolSchema({
-  name: "wallet_create",
-  description: "Create a new multi-chain HD wallet. Generates a BIP39 mnemonic seed phrase and derives addresses for Solana, Ethereum (shared by Base, Arbitrum, Polygon, Optimism, BNB, Avalanche), Bitcoin, and Tron. The mnemonic is saved to a local backup file (path returned in output) \u2014 it is never printed or returned in the response. To derive additional accounts from the same mnemonic, pass --from with an existing wallet name and --account with the desired index.",
-  input: z.object({
-    name: z.string().describe("Wallet name"),
-    from: z.string().nullable().describe("Name of an existing HD wallet to derive from. Uses the same mnemonic but a different account index. Omit to generate a new mnemonic."),
-    account: z.number().int().min(0).nullable().describe("BIP44 account index (0, 1, 2, ...). Required when using --from. Omit for new wallets (defaults to 0).")
-  }),
-  output: z.object({
-    name: z.string().describe("Wallet name"),
-    account: z.number().describe("BIP44 account index used for derivation"),
-    addresses: z.record(keyChainSchema, z.string()).describe("Derived addresses per chain (solana, ethereum, bitcoin, tron)"),
-    backupPath: z.string().nullable().describe("Path to the mnemonic backup file (0o600 permissions). Null when derived from an existing wallet.")
-  })
-});
-
-// src/tools/wallet/create/tool.ts
-var walletCreate = createTool(walletCreateSchema, async (params) => {
-  if (params.from) {
-    if (params.account === null) {
-      throw new Error("--account is required when using --from.");
-    }
-    return deriveFromExisting(params.name, params.from, params.account);
-  }
-  return createNew(params.name);
-});
-function createNew(name) {
-  const mnemonic = generateMnemonic(english, 128);
-  const addresses = deriveAllAddresses(mnemonic);
-  const vaultRef = addHdEntry(mnemonic);
-  const metadata = {
-    name,
-    type: "hd",
-    vaultRef,
-    account: 0,
-    addresses,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  saveWalletMetadata(metadata);
-  const backupDir = join3(homedir3(), ".config", "moonpay", "backups");
-  mkdirSync3(backupDir, { recursive: true, mode: 448 });
-  const backupPath = join3(backupDir, `${name}.mnemonic`);
-  writeFileSync3(backupPath, mnemonic + "\n", { mode: 384 });
-  return { name, account: 0, addresses, backupPath };
-}
-function deriveFromExisting(name, from, account) {
-  const source = loadWallet(from);
-  if (source.type !== "hd") {
-    throw new Error(
-      `Wallet "${from}" is an imported single-key wallet. Only HD wallets support account derivation.`
-    );
-  }
-  const vault = loadVault();
-  const entry = vault.entries[source.vaultRef];
-  if (!entry || entry.type !== "hd") {
-    throw new Error(`Vault entry for wallet "${from}" not found or is not HD.`);
-  }
-  const addresses = deriveAllAddresses(entry.mnemonic, account);
-  const metadata = {
-    name,
-    type: "hd",
-    vaultRef: source.vaultRef,
-    account,
-    addresses,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  saveWalletMetadata(metadata);
-  return { name, account, addresses, backupPath: null };
-}
-
-// src/tools/wallet/import/tool.ts
-import { validateMnemonic } from "@scure/bip39";
-import { wordlist as english2 } from "@scure/bip39/wordlists/english";
-import { Keypair } from "@solana/web3.js";
-import bs58 from "bs58";
-import { createInterface as createInterface2 } from "readline";
-
-// src/tools/wallet/import/schema.ts
-import { z as z2 } from "zod";
-var walletImportSchema = defineToolSchema({
-  name: "wallet_import",
-  description: "Import a wallet from a BIP39 mnemonic (HD, all chains) or a single private key (one chain). Provide either --mnemonic or --key, not both.",
-  input: z2.object({
-    name: z2.string().describe("Wallet name"),
-    mnemonic: z2.string().nullable().describe("BIP39 mnemonic seed phrase (for HD wallet import)"),
-    key: z2.string().nullable().describe(
-      "Private key: base58 for Solana, hex for EVM/Bitcoin (for single-chain import)"
-    ),
-    chain: chainSchema.nullable().describe(
-      "Chain for single-key import: solana, ethereum, base, arbitrum, or bitcoin (default solana)"
-    )
-  }),
-  output: z2.object({
-    name: z2.string().describe("Wallet name"),
-    type: z2.enum(["hd", "imported"]).describe("Wallet type"),
-    addresses: z2.record(keyChainSchema, z2.string()).describe("Wallet addresses per chain")
-  })
-});
-
-// src/tools/wallet/import/tool.ts
-async function promptSecret(prompt) {
-  const rl = createInterface2({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve) => {
-    rl.question(prompt, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-var walletImport = createTool(walletImportSchema, async (params) => {
-  if (params.mnemonic && params.key) {
-    throw new Error("Provide either --mnemonic or --key, not both.");
-  }
-  if (params.mnemonic) {
-    return importMnemonic(params.name, params.mnemonic);
-  }
-  const chain = params.chain ? KEY_CHAIN_MAP[params.chain] : "solana";
-  const key = params.key !== null ? params.key : await promptSecret("Enter private key: ");
-  return importKey(params.name, chain, key);
-});
-async function importMnemonic(name, mnemonic) {
-  const trimmed = mnemonic.trim().toLowerCase();
-  if (!validateMnemonic(trimmed, english2)) {
-    throw new Error("Invalid BIP39 mnemonic.");
-  }
-  const addresses = deriveAllAddresses(trimmed);
-  const vaultRef = addHdEntry(trimmed);
-  const metadata = {
-    name,
-    type: "hd",
-    vaultRef,
-    account: 0,
-    addresses,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  saveWalletMetadata(metadata);
-  return { name, type: "hd", addresses };
-}
-async function importKey(name, chain, key) {
-  let address;
-  if (chain === "solana") {
-    try {
-      const secretKeyBytes = bs58.decode(key);
-      const keypair = Keypair.fromSecretKey(secretKeyBytes);
-      address = keypair.publicKey.toBase58();
-    } catch {
-      throw new Error(
-        "Invalid private key. Expected a base58-encoded Solana secret key."
-      );
-    }
-  } else if (chain === "ethereum") {
-    const cleanKey = key.startsWith("0x") ? key.slice(2) : key;
-    if (!/^[0-9a-fA-F]{64}$/.test(cleanKey)) {
-      throw new Error(
-        "Invalid private key. Expected a 64-character hex string for EVM."
-      );
-    }
-    const { deriveKeyForChain: deriveKeyForChain2 } = await import("./chains-R754DQM5.js");
-    const { HDKey } = await import("@scure/bip32");
-    const ecc2 = await import("tiny-secp256k1");
-    const { createHash: createHash3 } = await import("crypto");
-    const privKeyBytes = Buffer.from(cleanKey, "hex");
-    const pubKey = ecc2.pointFromScalar(privKeyBytes);
-    if (!pubKey) throw new Error("Invalid private key.");
-    const uncompressed = ecc2.pointCompress(pubKey, false);
-    const hash = createHash3("sha3-256").update(uncompressed.slice(1)).digest();
-    address = "0x" + hash.slice(-20).toString("hex");
-    key = cleanKey;
-  } else {
-    const cleanKey = key.startsWith("0x") ? key.slice(2) : key;
-    if (!/^[0-9a-fA-F]{64}$/.test(cleanKey)) {
-      throw new Error(
-        "Invalid private key. Expected a 64-character hex string for Bitcoin."
-      );
-    }
-    const bitcoin = await import("bitcoinjs-lib");
-    const ECPairFactory = (await import("ecpair")).default;
-    const ecc2 = await import("tiny-secp256k1");
-    const ECPair = ECPairFactory(ecc2);
-    const keyPair = ECPair.fromPrivateKey(Buffer.from(cleanKey, "hex"));
-    const { address: btcAddress } = bitcoin.payments.p2wpkh({
-      pubkey: Buffer.from(keyPair.publicKey)
-    });
-    if (!btcAddress) throw new Error("Failed to derive Bitcoin address.");
-    address = btcAddress;
-    key = cleanKey;
-  }
-  const vaultRef = addImportedEntry(chain, key);
-  const metadata = {
-    name,
-    type: "imported",
-    vaultRef,
-    account: 0,
-    addresses: { [chain]: address },
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  saveWalletMetadata(metadata);
-  return { name, type: "imported", addresses: { [chain]: address } };
-}
-
-// src/tools/wallet/list/schema.ts
-import { z as z3 } from "zod";
-var walletListSchema = defineToolSchema({
-  name: "wallet_list",
-  description: "List all local wallets",
-  input: z3.object({}),
-  output: z3.array(walletInfoSchema)
-});
-
-// src/tools/wallet/list/tool.ts
-var walletList = createTool(walletListSchema, async () => {
-  return loadAllWallets();
-});
-
-// src/tools/wallet/retrieve/schema.ts
-import { z as z4 } from "zod";
-var walletRetrieveSchema = defineToolSchema({
-  name: "wallet_retrieve",
-  description: "Get details of a specific wallet",
-  input: z4.object({
-    wallet: z4.string().describe("Wallet name or address")
-  }),
-  output: walletInfoSchema
-});
-
-// src/tools/wallet/retrieve/tool.ts
-var walletRetrieve = createTool(
-  walletRetrieveSchema,
-  async (params) => {
-    return loadWallet(params.wallet);
-  }
-);
-
-// src/tools/wallet/delete/schema.ts
-import { z as z5 } 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: z5.object({
-    wallet: z5.string().describe("Name or address of the wallet to delete"),
-    confirm: z5.boolean().describe("Must be true to confirm deletion")
-  }),
-  output: z5.object({
-    name: z5.string().describe("Name of the deleted wallet"),
-    deleted: z5.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 = loadWallet(params.wallet);
-  removeVaultEntry(wallet.vaultRef);
-  deleteWalletFile(wallet.name);
-  return { name: wallet.name, deleted: true };
-});
-
-// src/tools/transaction/sign/tool.ts
-import { Keypair as Keypair2, VersionedTransaction } from "@solana/web3.js";
-
-// src/tools/transaction/sign/schema.ts
-import { z as z6 } from "zod";
-var transactionSignSchema = defineToolSchema({
-  name: "transaction_sign",
-  description: "Sign a transaction with a local wallet. Supports Solana (VersionedTransaction), EVM (RLP-encoded), and Bitcoin (PSBT) transactions.",
-  input: z6.object({
-    wallet: z6.string().describe("Wallet name or address"),
-    chain: chainSchema.describe(
-      "Chain: solana, ethereum, base, arbitrum, or bitcoin"
-    ),
-    transaction: z6.string().describe("Base64-encoded unsigned transaction")
-  }),
-  output: z6.object({
-    transaction: z6.string().describe("Base64-encoded signed transaction")
-  })
-});
-
-// src/tools/transaction/sign/tool.ts
-var transactionSign = createTool(
-  transactionSignSchema,
-  async (params) => {
-    const wallet = loadWallet(params.wallet);
-    const chain = params.chain;
-    const keyChain = KEY_CHAIN_MAP[chain];
-    const { privateKey } = resolveSigningKey(wallet, chain);
-    const txBytes = Buffer.from(params.transaction.trim(), "base64");
-    switch (keyChain) {
-      case "solana":
-        return signSolana(privateKey, txBytes);
-      case "ethereum":
-        return signEvm(privateKey, txBytes);
-      case "bitcoin":
-        return signBitcoin(privateKey, txBytes);
-      case "tron":
-        return signEvm(privateKey, txBytes);
-    }
-  }
-);
-function signSolana(privateKey, txBytes) {
-  const tx = VersionedTransaction.deserialize(txBytes);
-  const keypair = Keypair2.fromSecretKey(privateKey);
-  tx.sign([keypair]);
-  return { transaction: Buffer.from(tx.serialize()).toString("base64") };
-}
-async function signEvm(privateKey, txBytes) {
-  const { createHash: createHash3 } = await import("crypto");
-  const ecc2 = await import("tiny-secp256k1");
-  const hash = createHash3("sha3-256").update(txBytes).digest();
-  const sig = ecc2.sign(hash, privateKey);
-  if (!sig) throw new Error("EVM signing failed");
-  const signed = Buffer.concat([txBytes, Buffer.from(sig)]);
-  return { transaction: signed.toString("base64") };
-}
-async function signBitcoin(privateKey, txBytes) {
-  const bitcoin = await import("bitcoinjs-lib");
-  const ECPairFactory = (await import("ecpair")).default;
-  const ecc2 = await import("tiny-secp256k1");
-  const ECPair = ECPairFactory(ecc2);
-  const keyPair = ECPair.fromPrivateKey(Buffer.from(privateKey));
-  const psbt = bitcoin.Psbt.fromBase64(txBytes.toString("base64"));
-  psbt.signAllInputs(keyPair);
-  return { transaction: psbt.toBase64() };
-}
-
-// src/tools/message/sign/tool.ts
-import { createHash as createHash2 } from "crypto";
-import { Keypair as Keypair3 } from "@solana/web3.js";
-import bs582 from "bs58";
-import nacl from "tweetnacl";
-import * as ecc from "tiny-secp256k1";
-
-// src/tools/message/sign/schema.ts
-import { z as z7 } from "zod";
-var messageSignSchema = defineToolSchema({
-  name: "message_sign",
-  description: "Sign a message with a local wallet. Supports Solana (ed25519), EVM (EIP-191 personal sign), and Bitcoin (secp256k1 ECDSA).",
-  input: z7.object({
-    wallet: z7.string().describe("Wallet address or name to sign with"),
-    chain: chainSchema.describe(
-      "Chain: solana, ethereum, base, arbitrum, or bitcoin"
-    ),
-    message: z7.string().describe("Message text to sign")
-  }),
-  output: z7.object({
-    signature: z7.string().describe(
-      "Signature: base58 for Solana, hex (0x-prefixed) for EVM/Bitcoin"
-    )
-  })
-});
-
-// src/tools/message/sign/tool.ts
-var messageSign = createTool(messageSignSchema, async (params) => {
-  const wallet = loadWallet(params.wallet);
-  const chain = params.chain;
-  const keyChain = KEY_CHAIN_MAP[chain];
-  const { privateKey } = resolveSigningKey(wallet, chain);
-  const messageBytes = Buffer.from(params.message, "utf8");
-  switch (keyChain) {
-    case "solana":
-      return signSolana2(privateKey, messageBytes);
-    case "ethereum":
-      return signEvm2(privateKey, messageBytes);
-    case "bitcoin":
-      return signBitcoin2(privateKey, messageBytes);
-    case "tron":
-      return signEvm2(privateKey, messageBytes);
-  }
-});
-function signSolana2(privateKey, messageBytes) {
-  const keypair = Keypair3.fromSecretKey(privateKey);
-  const signatureBytes = nacl.sign.detached(messageBytes, keypair.secretKey);
-  return { signature: bs582.encode(signatureBytes) };
-}
-function signEvm2(privateKey, messageBytes) {
-  const prefix = Buffer.from(
-    `Ethereum Signed Message:
-${messageBytes.length}`,
-    "utf8"
-  );
-  const prefixed = Buffer.concat([prefix, messageBytes]);
-  const hash = createHash2("sha3-256").update(prefixed).digest();
-  const sig = ecc.sign(hash, privateKey);
-  if (!sig) throw new Error("EVM message signing failed");
-  return { signature: "0x" + Buffer.from(sig).toString("hex") };
-}
-function signBitcoin2(privateKey, messageBytes) {
-  const hash1 = createHash2("sha256").update(messageBytes).digest();
-  const hash2 = createHash2("sha256").update(hash1).digest();
-  const sig = ecc.sign(hash2, privateKey);
-  if (!sig) throw new Error("Bitcoin message signing failed");
-  return { signature: "0x" + Buffer.from(sig).toString("hex") };
-}
-
-// src/tools/wallet/lock/tool.ts
-import { createInterface as createInterface3 } from "readline";
-
-// src/tools/wallet/lock/schema.ts
-import { z as z8 } from "zod";
-var walletLockSchema = defineToolSchema({
-  name: "wallet_lock",
-  description: "Encrypt the vault with a password. All signing operations will fail until `wallet unlock` is called. Password is prompted interactively.",
-  input: z8.object({}),
-  output: z8.object({
-    locked: z8.literal(true)
-  })
-});
-
-// src/tools/wallet/lock/tool.ts
-async function promptPassword(prompt) {
-  const rl = createInterface3({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve) => {
-    rl.question(prompt, (answer) => {
-      rl.close();
-      resolve(answer);
-    });
-  });
-}
-var walletLock = createTool(walletLockSchema, async () => {
-  if (isVaultLocked()) {
-    throw new Error("Vault is already locked.");
-  }
-  const password = await promptPassword("Enter password to encrypt vault: ");
-  if (!password) {
-    throw new Error("Password cannot be empty.");
-  }
-  const confirm = await promptPassword("Confirm password: ");
-  if (password !== confirm) {
-    throw new Error("Passwords do not match.");
-  }
-  lockVault(password);
-  return { locked: true };
-});
-
-// src/tools/wallet/unlock/tool.ts
-import { createInterface as createInterface4 } from "readline";
-
-// src/tools/wallet/unlock/schema.ts
-import { z as z9 } from "zod";
-var walletUnlockSchema = defineToolSchema({
-  name: "wallet_unlock",
-  description: "Decrypt the vault with a password. Restores access to all signing operations. Password is prompted interactively.",
-  input: z9.object({}),
-  output: z9.object({
-    unlocked: z9.literal(true)
-  })
-});
-
-// src/tools/wallet/unlock/tool.ts
-async function promptPassword2(prompt) {
-  const rl = createInterface4({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve) => {
-    rl.question(prompt, (answer) => {
-      rl.close();
-      resolve(answer);
-    });
-  });
-}
-var walletUnlock = createTool(walletUnlockSchema, async () => {
-  if (!isVaultLocked()) {
-    throw new Error("Vault is not locked.");
-  }
-  const password = await promptPassword2("Enter password to decrypt vault: ");
-  unlockVault(password);
-  return { unlocked: true };
-});
-
-// src/tools/bitcoin/balance/tool.ts
-import https from "https";
-
-// src/tools/bitcoin/balance/schema.ts
-import { z as z10 } from "zod";
-var bitcoinBalanceRetrieveSchema = defineToolSchema({
-  name: "bitcoin_balance_retrieve",
-  description: "Get the BTC balance of a Bitcoin address. Returns confirmed and unconfirmed balances in BTC and satoshis.",
-  input: z10.object({
-    wallet: z10.string().describe("Bitcoin address (bc1...) or wallet name")
-  }),
-  output: z10.object({
-    address: z10.string().describe("Bitcoin address"),
-    confirmed: z10.object({
-      btc: z10.string().describe("Confirmed balance in BTC"),
-      sats: z10.number().describe("Confirmed balance in satoshis")
-    }),
-    unconfirmed: z10.object({
-      btc: z10.string().describe("Unconfirmed (pending) balance in BTC"),
-      sats: z10.number().describe("Unconfirmed (pending) balance in satoshis")
-    }),
-    total: z10.object({
-      btc: z10.string().describe("Total balance in BTC"),
-      sats: z10.number().describe("Total balance in satoshis")
-    })
-  })
-});
-
-// src/tools/bitcoin/balance/tool.ts
-var SATS_PER_BTC = 1e8;
-function satsToBtc(sats) {
-  return (sats / SATS_PER_BTC).toFixed(8);
-}
-function fetchJson(url) {
-  return new Promise((resolve, reject) => {
-    https.get(url, { headers: { "User-Agent": "moonpay-cli" } }, (res) => {
-      if (res.statusCode !== 200) {
-        reject(new Error(`HTTP ${res.statusCode} from ${url}`));
-        res.resume();
-        return;
-      }
-      let data = "";
-      res.on("data", (chunk) => data += chunk);
-      res.on("end", () => {
-        try {
-          resolve(JSON.parse(data));
-        } catch {
-          reject(new Error("Invalid JSON response"));
-        }
-      });
-    }).on("error", reject);
-  });
-}
-var bitcoinBalanceRetrieve = createTool(
-  bitcoinBalanceRetrieveSchema,
-  async (params) => {
-    let address = params.wallet;
-    if (!address.startsWith("bc1") && !address.startsWith("1") && !address.startsWith("3")) {
-      const { loadWallet: loadWallet2 } = await import("./server-IUOCZFT7.js");
-      const wallet = loadWallet2(address);
-      const btcAddress = wallet.addresses.bitcoin;
-      if (!btcAddress) {
-        throw new Error(
-          `Wallet "${address}" has no Bitcoin address. It may be an imported single-chain wallet.`
-        );
-      }
-      address = btcAddress;
-    }
-    const data = await fetchJson(
-      `https://mempool.space/api/address/${address}`
-    );
-    const confirmedSats = data.chain_stats.funded_txo_sum - data.chain_stats.spent_txo_sum;
-    const unconfirmedSats = data.mempool_stats.funded_txo_sum - data.mempool_stats.spent_txo_sum;
-    const totalSats = confirmedSats + unconfirmedSats;
-    return {
-      address,
-      confirmed: { btc: satsToBtc(confirmedSats), sats: confirmedSats },
-      unconfirmed: { btc: satsToBtc(unconfirmedSats), sats: unconfirmedSats },
-      total: { btc: satsToBtc(totalSats), sats: totalSats }
-    };
-  }
-);
-
-export {
-  getConfigOrDefault,
-  clearCredentials,
-  resolveBaseUrl,
-  login,
-  callTool,
-  schemas_default,
-  defineToolSchema,
-  createTool,
-  resolveSigningKey,
-  walletCreate,
-  walletImport,
-  walletList,
-  walletRetrieve,
-  walletDelete,
-  transactionSign,
-  messageSign,
-  walletLock,
-  walletUnlock,
-  bitcoinBalanceRetrieve
-};
-//# sourceMappingURL=chunk-DAQDHLPY.js.map