midnight-wallet-cli 0.1.0

package/dist/wallet.js

@@ -0,0 +1,3557 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/lib/argv.ts
+function parseArgs(argv) {
+  const args = argv ?? process.argv.slice(2);
+  const positionals = [];
+  const flags = {};
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        flags[key] = next;
+        i += 2;
+      } else {
+        flags[key] = true;
+        i += 1;
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      const next = args[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        flags[key] = next;
+        i += 2;
+      } else {
+        flags[key] = true;
+        i += 1;
+      }
+    } else {
+      positionals.push(arg);
+      i += 1;
+    }
+  }
+  return {
+    command: positionals[0],
+    subcommand: positionals[1],
+    positionals: positionals.slice(2),
+    flags
+  };
+}
+function getFlag(args, name) {
+  const value = args.flags[name];
+  if (value === undefined || value === true)
+    return;
+  return value;
+}
+function hasFlag(args, name) {
+  return name in args.flags;
+}
+function requireFlag(args, name, description) {
+  const value = getFlag(args, name);
+  if (value === undefined) {
+    throw new Error(`Missing required flag: --${name} <${description}>`);
+  }
+  return value;
+}
+
+// src/lib/constants.ts
+var GENESIS_SEED = "0000000000000000000000000000000000000000000000000000000000000001", NATIVE_TOKEN_TYPE = "0000000000000000000000000000000000000000000000000000000000000000", TOKEN_DECIMALS = 6, TOKEN_MULTIPLIER = 1e6, DUST_COST_OVERHEAD = 1000000000000n, DUST_FEE_BLOCKS_MARGIN = 5, SYNC_TIMEOUT_MS = 300000, PRE_SEND_SYNC_TIMEOUT_MS = 1e4, DUST_TIMEOUT_MS = 120000, PROOF_TIMEOUT_MS = 300000, BALANCE_CHECK_TIMEOUT_MS = 60000, TX_TTL_MINUTES = 10, MAX_RETRY_ATTEMPTS = 3, STALE_UTXO_ERROR_CODE = 115, MIDNIGHT_DIR = ".midnight", DEFAULT_WALLET_FILENAME = "wallet.json", DEFAULT_CONFIG_FILENAME = "config.json", DIR_MODE = 448, FILE_MODE = 384, LOCALNET_DIR_NAME = "localnet";
+
+// src/ui/colors.ts
+function isColorEnabled() {
+  return !("NO_COLOR" in process.env);
+}
+function fg(text, code) {
+  if (!isColorEnabled())
+    return text;
+  return `${ESC}38;5;${code}m${text}${RESET}`;
+}
+function bold(text) {
+  if (!isColorEnabled())
+    return text;
+  return `${ESC}1m${text}${RESET}`;
+}
+function dim(text) {
+  if (!isColorEnabled())
+    return text;
+  return `${ESC}2m${text}${RESET}`;
+}
+function teal(text) {
+  return fg(text, TEAL);
+}
+function red(text) {
+  return fg(text, RED_CODE);
+}
+function green(text) {
+  return fg(text, GREEN_CODE);
+}
+function yellow(text) {
+  return fg(text, YELLOW_CODE);
+}
+function gray(text) {
+  return fg(text, DIM_GRAY);
+}
+var ESC = "\x1B[", RESET = "\x1B[0m", TEAL = 38, DIM_GRAY = 245, RED_CODE = 196, GREEN_CODE = 40, YELLOW_CODE = 226;
+
+// src/ui/format.ts
+function header(title, width = DEFAULT_WIDTH) {
+  const paddedTitle = ` ${title} `;
+  const remaining = width - paddedTitle.length;
+  if (remaining <= 0)
+    return bold(paddedTitle);
+  const left = Math.floor(remaining / 2);
+  const right = remaining - left;
+  return bold("═".repeat(left) + paddedTitle + "═".repeat(right));
+}
+function divider(width = DEFAULT_WIDTH) {
+  return dim("─".repeat(width));
+}
+function keyValue(key, value, padWidth = 16) {
+  const paddedKey = (key + ":").padEnd(padWidth);
+  return `  ${gray(paddedKey)}${value}`;
+}
+function toNight(microNight) {
+  const isNegative = microNight < 0n;
+  const abs = isNegative ? -microNight : microNight;
+  const multiplier = BigInt(10 ** TOKEN_DECIMALS);
+  const whole = abs / multiplier;
+  const frac = abs % multiplier;
+  const fracStr = frac.toString().padStart(TOKEN_DECIMALS, "0");
+  const sign = isNegative ? "-" : "";
+  return `${sign}${whole}.${fracStr}`;
+}
+function formatNight(microNight) {
+  return `${toNight(microNight)} NIGHT`;
+}
+function toDust(specks) {
+  const isNegative = specks < 0n;
+  const abs = isNegative ? -specks : specks;
+  const multiplier = 10n ** BigInt(DUST_DECIMALS);
+  const whole = abs / multiplier;
+  const frac = abs % multiplier;
+  const fracStr = frac.toString().padStart(DUST_DECIMALS, "0");
+  const trimmed = fracStr.replace(/0+$/, "").padEnd(6, "0");
+  const sign = isNegative ? "-" : "";
+  return `${sign}${whole}.${trimmed}`;
+}
+function formatDust(specks) {
+  return `${toDust(specks)} DUST`;
+}
+function formatAddress(address, truncate = false) {
+  const display = truncate && address.length > 20 ? address.slice(0, 10) + "…" + address.slice(-8) : address;
+  return teal(display);
+}
+function wrapLine(line, maxWidth) {
+  const visible = stripAnsi(line);
+  if (visible.length <= maxWidth)
+    return [line];
+  const words = line.split(/(\s+)/);
+  const result = [];
+  let currentLine = "";
+  let currentLen = 0;
+  for (const word of words) {
+    const wordLen = stripAnsi(word).length;
+    if (currentLen + wordLen > maxWidth && currentLen > 0) {
+      result.push(currentLine);
+      currentLine = word.trimStart();
+      currentLen = stripAnsi(currentLine).length;
+    } else {
+      currentLine += word;
+      currentLen += wordLen;
+    }
+  }
+  if (currentLine.length > 0)
+    result.push(currentLine);
+  return result;
+}
+function box(lines, style = "light", maxWidth = 70) {
+  const chars = style === "heavy" ? { tl: "╔", tr: "╗", bl: "╚", br: "╝", h: "═", v: "║" } : { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│" };
+  const contentMaxWidth = maxWidth - 4;
+  const expanded = [];
+  for (const line of lines) {
+    const subLines = line.split(`
+`);
+    for (const sub of subLines) {
+      expanded.push(...wrapLine(sub, contentMaxWidth));
+    }
+  }
+  const maxLen = Math.max(...expanded.map((l) => stripAnsi(l).length));
+  const innerWidth = Math.max(maxLen + 2, 20);
+  const top = chars.tl + chars.h.repeat(innerWidth) + chars.tr;
+  const bottom = chars.bl + chars.h.repeat(innerWidth) + chars.br;
+  const body = expanded.map((line) => {
+    const visibleLen = stripAnsi(line).length;
+    const padding = innerWidth - visibleLen - 2;
+    return `${chars.v} ${line}${" ".repeat(Math.max(0, padding))} ${chars.v}`;
+  });
+  return [top, ...body, bottom].join(`
+`);
+}
+function errorBox(error, suggestion) {
+  const errorLines = error.split(`
+`);
+  const lines = errorLines.map((line, i) => i === 0 ? red(bold("Error: ")) + red(line) : red(line));
+  if (suggestion) {
+    lines.push("");
+    lines.push(dim("Suggestion: ") + suggestion);
+  }
+  const output = box(lines, "heavy");
+  if (isColorEnabled()) {
+    return output.replace(/[╔╗╚╝═║]/g, (match) => red(match));
+  }
+  return output;
+}
+function successMessage(msg, txHash) {
+  const check = green("✓");
+  const parts = [`${check} ${msg}`];
+  if (txHash) {
+    parts.push(keyValue("Transaction", teal(txHash)));
+  }
+  return parts.join(`
+`);
+}
+var DEFAULT_WIDTH = 60, DUST_DECIMALS = 15, stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+var init_format = () => {
+};
+
+// src/lib/exit-codes.ts
+function classifyError(err) {
+  const msg = (err.message ?? "").toLowerCase();
+  if (msg.includes("operation cancelled") || msg.includes("operation aborted") || msg === "cancelled" || msg === "aborted") {
+    return { exitCode: EXIT_CANCELLED, errorCode: ERROR_CODES.CANCELLED };
+  }
+  if (msg.includes("wallet file not found") || msg.includes("wallet") && msg.includes("not found")) {
+    return { exitCode: EXIT_WALLET_NOT_FOUND, errorCode: ERROR_CODES.WALLET_NOT_FOUND };
+  }
+  if (msg.includes("missing required flag") || msg.includes("missing amount") || msg.includes("missing recipient") || msg.includes("missing config key") || msg.includes("missing or invalid subcommand") || msg.includes("unknown command") || msg.includes("cannot specify both") || msg.includes("invalid bip-39") || msg.includes("seed must be") || msg.includes("key index must be") || msg.includes("usage:")) {
+    return { exitCode: EXIT_INVALID_ARGS, errorCode: ERROR_CODES.INVALID_ARGS };
+  }
+  if (msg.includes("proof") && msg.includes("timeout")) {
+    return { exitCode: EXIT_TX_REJECTED, errorCode: ERROR_CODES.PROOF_TIMEOUT };
+  }
+  if (msg.includes("stale utxo") || msg.includes("error code 115") || msg.includes("errorcode: 115")) {
+    return { exitCode: EXIT_TX_REJECTED, errorCode: ERROR_CODES.STALE_UTXO };
+  }
+  if (msg.includes("no dust") || msg.includes("dust") && (msg.includes("required") || msg.includes("available") || msg.includes("insufficient"))) {
+    return { exitCode: EXIT_INSUFFICIENT_BALANCE, errorCode: ERROR_CODES.DUST_REQUIRED };
+  }
+  if (msg.includes("insufficient") || msg.includes("not enough")) {
+    return { exitCode: EXIT_INSUFFICIENT_BALANCE, errorCode: ERROR_CODES.INSUFFICIENT_BALANCE };
+  }
+  if (msg.includes("rejected") || msg.includes("transaction failed")) {
+    return { exitCode: EXIT_TX_REJECTED, errorCode: ERROR_CODES.TX_REJECTED };
+  }
+  if (msg.includes("econnrefused") || msg.includes("enotfound") || msg.includes("etimedout") || msg.includes("websocket") || msg.includes("connection refused") || msg.includes("network") && msg.includes("error")) {
+    return { exitCode: EXIT_NETWORK_ERROR, errorCode: ERROR_CODES.NETWORK_ERROR };
+  }
+  return { exitCode: EXIT_GENERAL_ERROR, errorCode: ERROR_CODES.UNKNOWN };
+}
+var EXIT_GENERAL_ERROR = 1, EXIT_INVALID_ARGS = 2, EXIT_WALLET_NOT_FOUND = 3, EXIT_NETWORK_ERROR = 4, EXIT_INSUFFICIENT_BALANCE = 5, EXIT_TX_REJECTED = 6, EXIT_CANCELLED = 7, ERROR_CODES;
+var init_exit_codes = __esm(() => {
+  ERROR_CODES = {
+    INVALID_ARGS: "INVALID_ARGS",
+    WALLET_NOT_FOUND: "WALLET_NOT_FOUND",
+    NETWORK_ERROR: "NETWORK_ERROR",
+    INSUFFICIENT_BALANCE: "INSUFFICIENT_BALANCE",
+    TX_REJECTED: "TX_REJECTED",
+    STALE_UTXO: "STALE_UTXO",
+    PROOF_TIMEOUT: "PROOF_TIMEOUT",
+    DUST_REQUIRED: "DUST_REQUIRED",
+    CANCELLED: "CANCELLED",
+    UNKNOWN: "UNKNOWN"
+  };
+});
+
+// src/lib/json-output.ts
+function suppressStderr() {
+  const original = process.stderr.write;
+  process.stderr.write = () => true;
+  return () => {
+    process.stderr.write = original;
+  };
+}
+function setCaptureTarget(fn) {
+  captureTarget = fn;
+}
+function writeJsonResult(data) {
+  const json = JSON.stringify(data) + `
+`;
+  if (captureTarget) {
+    captureTarget(json);
+  } else {
+    process.stdout.write(json);
+  }
+}
+function writeJsonError(err, errorCode, exitCode) {
+  process.stdout.write(JSON.stringify({
+    error: true,
+    code: errorCode,
+    message: err.message,
+    exitCode
+  }) + `
+`);
+}
+var captureTarget = null;
+
+// src/lib/run-command.ts
+async function captureCommand(handler, args, signal) {
+  const chunks = [];
+  setCaptureTarget((json) => chunks.push(json));
+  const originalStderr = process.stderr.write;
+  process.stderr.write = () => true;
+  try {
+    args.flags.json = true;
+    await handler(args, signal);
+    const raw = chunks.join("").trim();
+    if (!raw)
+      return {};
+    return JSON.parse(raw);
+  } finally {
+    setCaptureTarget(null);
+    process.stderr.write = originalStderr;
+  }
+}
+var init_run_command = () => {
+};
+
+// src/lib/derive-address.ts
+import { HDWallet, Roles } from "@midnight-ntwrk/wallet-sdk-hd";
+import { createKeystore, PublicKey } from "@midnight-ntwrk/wallet-sdk-unshielded-wallet";
+import { NetworkId } from "@midnight-ntwrk/wallet-sdk-abstractions";
+function deriveUnshieldedAddress(seedBuffer, networkName, keyIndex = 0) {
+  const networkId = NETWORK_ID_MAP[networkName];
+  const hdResult = HDWallet.fromSeed(seedBuffer);
+  if (hdResult.type !== "seedOk") {
+    throw new Error("Invalid seed for HD wallet");
+  }
+  const derivation = hdResult.hdWallet.selectAccount(0).selectRole(Roles.NightExternal).deriveKeyAt(keyIndex);
+  if (derivation.type === "keyOutOfBounds") {
+    throw new Error(`Key index ${keyIndex} out of bounds`);
+  }
+  const keystore = createKeystore(derivation.key, networkId);
+  const publicKey = PublicKey.fromKeyStore(keystore);
+  return publicKey.address;
+}
+var NETWORK_ID_MAP;
+var init_derive_address = __esm(() => {
+  NETWORK_ID_MAP = {
+    preprod: NetworkId.NetworkId.PreProd,
+    preview: NetworkId.NetworkId.Preview,
+    undeployed: NetworkId.NetworkId.Undeployed
+  };
+});
+
+// src/lib/network.ts
+import { execSync } from "child_process";
+function isValidNetworkName(name) {
+  return VALID_NETWORK_NAMES.includes(name);
+}
+function getNetworkConfig(name) {
+  return { ...NETWORK_CONFIGS[name] };
+}
+function getValidNetworkNames() {
+  return VALID_NETWORK_NAMES;
+}
+function detectNetworkFromAddress(address) {
+  if (address.startsWith("mn_addr_preprod1"))
+    return "preprod";
+  if (address.startsWith("mn_addr_preview1"))
+    return "preview";
+  if (address.startsWith("mn_addr_undeployed1"))
+    return "undeployed";
+  return null;
+}
+function detectTestcontainerPorts() {
+  try {
+    const output = execSync('docker ps --format "{{.Image}}|{{.Ports}}"', { encoding: "utf-8", timeout: 5000 });
+    const result = {};
+    for (const line of output.trim().split(`
+`)) {
+      if (!line)
+        continue;
+      const [image, ports] = line.split("|");
+      const extractHostPort = (containerPort) => {
+        const regex = new RegExp(`0\\.0\\.0\\.0:(\\d+)->${containerPort}/tcp`);
+        const match = ports?.match(regex);
+        return match ? parseInt(match[1], 10) : undefined;
+      };
+      if (image.includes("indexer-standalone") || image.includes("indexer")) {
+        const port = extractHostPort(8088);
+        if (port)
+          result.indexerPort = port;
+      }
+      if (image.includes("midnight-node")) {
+        const port = extractHostPort(9944);
+        if (port)
+          result.nodePort = port;
+      }
+      if (image.includes("proof-server")) {
+        const port = extractHostPort(6300);
+        if (port)
+          result.proofServerPort = port;
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function resolveNetworkConfig(name) {
+  const config = getNetworkConfig(name);
+  if (name === "undeployed") {
+    const detected = detectTestcontainerPorts();
+    if (detected.indexerPort) {
+      config.indexer = `http://localhost:${detected.indexerPort}/api/v3/graphql`;
+      config.indexerWS = `ws://localhost:${detected.indexerPort}/api/v3/graphql/ws`;
+    }
+    if (detected.nodePort) {
+      config.node = `ws://localhost:${detected.nodePort}`;
+    }
+    if (detected.proofServerPort) {
+      config.proofServer = `http://localhost:${detected.proofServerPort}`;
+    }
+  }
+  return config;
+}
+var NETWORK_CONFIGS, VALID_NETWORK_NAMES;
+var init_network = __esm(() => {
+  NETWORK_CONFIGS = {
+    preprod: {
+      indexer: "https://indexer.preprod.midnight.network/api/v3/graphql",
+      indexerWS: "wss://indexer.preprod.midnight.network/api/v3/graphql/ws",
+      node: "wss://rpc.preprod.midnight.network",
+      proofServer: "http://localhost:6300",
+      networkId: "PreProd"
+    },
+    preview: {
+      indexer: "https://indexer.preview.midnight.network/api/v3/graphql",
+      indexerWS: "wss://indexer.preview.midnight.network/api/v3/graphql/ws",
+      node: "wss://rpc.preview.midnight.network",
+      proofServer: "http://localhost:6300",
+      networkId: "Preview"
+    },
+    undeployed: {
+      indexer: "http://localhost:8088/api/v3/graphql",
+      indexerWS: "ws://localhost:8088/api/v3/graphql/ws",
+      node: "ws://localhost:9944",
+      proofServer: "http://localhost:6300",
+      networkId: "Undeployed"
+    }
+  };
+  VALID_NETWORK_NAMES = ["preprod", "preview", "undeployed"];
+});
+
+// src/lib/cli-config.ts
+import * as fs from "fs";
+import * as path from "path";
+import { homedir } from "os";
+function getConfigDir(configDir) {
+  return configDir ?? path.join(homedir(), MIDNIGHT_DIR);
+}
+function getConfigPath(configDir) {
+  return path.join(getConfigDir(configDir), DEFAULT_CONFIG_FILENAME);
+}
+function ensureConfigDir(configDir) {
+  const dir = getConfigDir(configDir);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: DIR_MODE });
+  }
+}
+function loadCliConfig(configDir) {
+  const configPath = getConfigPath(configDir);
+  if (!fs.existsSync(configPath)) {
+    return { ...DEFAULT_CLI_CONFIG };
+  }
+  let content;
+  try {
+    content = fs.readFileSync(configPath, "utf-8");
+  } catch {
+    return { ...DEFAULT_CLI_CONFIG };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return { ...DEFAULT_CLI_CONFIG };
+  }
+  return {
+    network: parsed.network && isValidNetworkName(parsed.network) ? parsed.network : DEFAULT_CLI_CONFIG.network
+  };
+}
+function saveCliConfig(config, configDir) {
+  ensureConfigDir(configDir);
+  const configPath = getConfigPath(configDir);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + `
+`, { mode: FILE_MODE });
+}
+function getConfigValue(key, configDir) {
+  const config = loadCliConfig(configDir);
+  if (key === "network")
+    return config.network;
+  throw new Error(`Unknown config key: "${key}"
+Valid keys: ${VALID_CONFIG_KEYS.join(", ")}`);
+}
+function setConfigValue(key, value, configDir) {
+  const config = loadCliConfig(configDir);
+  if (key === "network") {
+    if (!isValidNetworkName(value)) {
+      throw new Error(`Invalid network: "${value}"
+Valid networks: preprod, preview, undeployed`);
+    }
+    config.network = value;
+  } else {
+    throw new Error(`Unknown config key: "${key}"
+Valid keys: ${VALID_CONFIG_KEYS.join(", ")}`);
+  }
+  saveCliConfig(config, configDir);
+}
+function getValidConfigKeys() {
+  return VALID_CONFIG_KEYS;
+}
+var DEFAULT_CLI_CONFIG, VALID_CONFIG_KEYS;
+var init_cli_config = __esm(() => {
+  init_network();
+  DEFAULT_CLI_CONFIG = {
+    network: "undeployed"
+  };
+  VALID_CONFIG_KEYS = ["network"];
+});
+
+// src/lib/resolve-network.ts
+function resolveNetworkName(ctx) {
+  const flagValue = getFlag(ctx.args, "network");
+  if (flagValue !== undefined) {
+    if (!isValidNetworkName(flagValue)) {
+      throw new Error(`Invalid network: "${flagValue}"
+` + `Valid networks: ${getValidNetworkNames().join(", ")}`);
+    }
+    return flagValue;
+  }
+  if (ctx.walletNetwork && isValidNetworkName(ctx.walletNetwork)) {
+    return ctx.walletNetwork;
+  }
+  if (ctx.address) {
+    const detected = detectNetworkFromAddress(ctx.address);
+    if (detected)
+      return detected;
+  }
+  const cliConfig = loadCliConfig(ctx.configDir);
+  if (cliConfig.network && isValidNetworkName(cliConfig.network)) {
+    return cliConfig.network;
+  }
+  return "undeployed";
+}
+function resolveNetwork(ctx) {
+  const name = resolveNetworkName(ctx);
+  const config = resolveNetworkConfig(name);
+  return { name, config };
+}
+var init_resolve_network = __esm(() => {
+  init_network();
+  init_cli_config();
+});
+
+// src/lib/wallet-config.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { homedir as homedir2 } from "os";
+function getMidnightDir() {
+  return path2.join(homedir2(), MIDNIGHT_DIR);
+}
+function getDefaultWalletPath() {
+  return path2.join(getMidnightDir(), DEFAULT_WALLET_FILENAME);
+}
+function ensureMidnightDir() {
+  const dir = getMidnightDir();
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true, mode: DIR_MODE });
+  }
+}
+function loadWalletConfig(walletPath) {
+  const resolvedPath = walletPath ? path2.resolve(walletPath) : getDefaultWalletPath();
+  if (!fs2.existsSync(resolvedPath)) {
+    throw new Error(`Wallet file not found: ${resolvedPath}
+` + `Generate a wallet first: midnight generate --network <name>`);
+  }
+  let content;
+  try {
+    content = fs2.readFileSync(resolvedPath, "utf-8");
+  } catch (err) {
+    throw new Error(`Failed to read wallet file: ${resolvedPath}
+${err.message}`);
+  }
+  let config;
+  try {
+    config = JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid JSON in wallet file: ${resolvedPath}`);
+  }
+  if (!config.seed || !config.network || !config.address || !config.createdAt) {
+    const missing = ["seed", "network", "address", "createdAt"].filter((f) => !config[f]);
+    throw new Error(`Wallet file is missing required fields (${missing.join(", ")}): ${resolvedPath}`);
+  }
+  if (!/^[0-9a-fA-F]+$/.test(config.seed)) {
+    throw new Error(`Invalid seed format in wallet file (expected hex string): ${resolvedPath}`);
+  }
+  if (!isValidNetworkName(config.network)) {
+    throw new Error(`Invalid network "${config.network}" in wallet file: ${resolvedPath}
+` + `Valid networks: preprod, preview, undeployed`);
+  }
+  return config;
+}
+function saveWalletConfig(config, walletPath) {
+  const resolvedPath = walletPath ? path2.resolve(walletPath) : getDefaultWalletPath();
+  if (!walletPath) {
+    ensureMidnightDir();
+  } else {
+    const dir = path2.dirname(resolvedPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true, mode: DIR_MODE });
+    }
+  }
+  fs2.writeFileSync(resolvedPath, JSON.stringify(config, null, 2) + `
+`, { mode: FILE_MODE });
+  return resolvedPath;
+}
+var init_wallet_config = __esm(() => {
+  init_network();
+});
+
+// src/commands/generate.ts
+var exports_generate = {};
+__export(exports_generate, {
+  default: () => generateCommand
+});
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { homedir as homedir3 } from "os";
+import { generateMnemonic, mnemonicToSeedSync, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+async function generateCommand(args) {
+  const networkName = resolveNetworkName({ args });
+  const outputPath = getFlag(args, "output");
+  const seedHex = getFlag(args, "seed");
+  const mnemonicStr = getFlag(args, "mnemonic");
+  if (seedHex !== undefined && mnemonicStr !== undefined) {
+    throw new Error("Cannot specify both --seed and --mnemonic. Use one or the other.");
+  }
+  const targetPath = outputPath ? path3.resolve(outputPath) : path3.join(homedir3(), MIDNIGHT_DIR, DEFAULT_WALLET_FILENAME);
+  if (fs3.existsSync(targetPath) && !hasFlag(args, "force")) {
+    throw new Error(`Wallet file already exists: ${targetPath}
+` + `Use --force to overwrite, or --output <file> to save to a different path.`);
+  }
+  let seedBuffer;
+  let mnemonic;
+  if (seedHex !== undefined) {
+    const cleaned = seedHex.replace(/^0x/, "");
+    if (cleaned.length !== 64 || !/^[0-9a-fA-F]+$/.test(cleaned)) {
+      throw new Error("Seed must be a 64-character hex string (32 bytes)");
+    }
+    seedBuffer = Buffer.from(cleaned, "hex");
+  } else if (mnemonicStr !== undefined) {
+    if (!validateMnemonic(mnemonicStr, wordlist)) {
+      throw new Error("Invalid BIP-39 mnemonic. Expected 12 or 24 words from the English wordlist.");
+    }
+    mnemonic = mnemonicStr;
+    seedBuffer = Buffer.from(mnemonicToSeedSync(mnemonic).slice(0, 32));
+  } else {
+    mnemonic = generateMnemonic(wordlist, 256);
+    seedBuffer = Buffer.from(mnemonicToSeedSync(mnemonic).slice(0, 32));
+  }
+  const address = deriveUnshieldedAddress(seedBuffer, networkName);
+  const config = {
+    seed: seedBuffer.toString("hex"),
+    network: networkName,
+    address,
+    createdAt: new Date().toISOString()
+  };
+  if (mnemonic) {
+    config.mnemonic = mnemonic;
+  }
+  const savedPath = saveWalletConfig(config, outputPath);
+  if (hasFlag(args, "json")) {
+    const result = {
+      address,
+      network: networkName,
+      seed: seedBuffer.toString("hex"),
+      file: savedPath,
+      createdAt: config.createdAt
+    };
+    if (mnemonic)
+      result.mnemonic = mnemonic;
+    writeJsonResult(result);
+    return;
+  }
+  process.stdout.write(address + `
+`);
+  process.stderr.write(`
+` + header("Wallet Generated") + `
+
+`);
+  process.stderr.write(keyValue("Network", networkName) + `
+`);
+  process.stderr.write(keyValue("Address", formatAddress(address)) + `
+`);
+  process.stderr.write(keyValue("File", savedPath) + `
+`);
+  process.stderr.write(`
+`);
+  if (mnemonic) {
+    process.stderr.write(yellow(bold("  MNEMONIC (save securely!):")) + `
+`);
+    process.stderr.write(`  ${mnemonic}
+
+`);
+  }
+  process.stderr.write(yellow(bold("  SEED (hex):")) + `
+`);
+  process.stderr.write(`  ${seedBuffer.toString("hex")}
+
+`);
+  process.stderr.write(divider() + `
+`);
+  process.stderr.write(dim("  Next: midnight info | midnight balance") + `
+
+`);
+  process.stderr.write(green("✓") + ` Wallet saved
+`);
+}
+var init_generate = __esm(() => {
+  init_derive_address();
+  init_resolve_network();
+  init_wallet_config();
+  init_format();
+});
+
+// src/commands/info.ts
+var exports_info = {};
+__export(exports_info, {
+  default: () => infoCommand
+});
+import * as path4 from "path";
+import { homedir as homedir4 } from "os";
+async function infoCommand(args) {
+  const walletPath = getFlag(args, "wallet");
+  const config = loadWalletConfig(walletPath);
+  const resolvedPath = walletPath ? path4.resolve(walletPath) : path4.join(homedir4(), MIDNIGHT_DIR, DEFAULT_WALLET_FILENAME);
+  if (hasFlag(args, "json")) {
+    writeJsonResult({
+      address: config.address,
+      network: config.network,
+      createdAt: config.createdAt,
+      file: resolvedPath
+    });
+    return;
+  }
+  process.stdout.write(config.address + `
+`);
+  process.stderr.write(`
+` + header("Wallet Info") + `
+
+`);
+  process.stderr.write(keyValue("Address", formatAddress(config.address)) + `
+`);
+  process.stderr.write(keyValue("Network", config.network) + `
+`);
+  process.stderr.write(keyValue("Created", config.createdAt) + `
+`);
+  process.stderr.write(keyValue("File", resolvedPath) + `
+`);
+  process.stderr.write(`
+` + divider() + `
+
+`);
+}
+var init_info = __esm(() => {
+  init_wallet_config();
+  init_format();
+  init_format();
+});
+
+// src/lib/balance-subscription.ts
+import WebSocket from "ws";
+function checkBalance(address, indexerWS, onProgress) {
+  return new Promise((resolve4, reject) => {
+    const ws = new WebSocket(indexerWS, ["graphql-transport-ws"]);
+    const utxos = new Map;
+    let txCount = 0;
+    let highestTxId = 0;
+    let lastSeenTxId = 0;
+    let progressReceived = false;
+    let settled = false;
+    let timeoutId;
+    const buildResult = () => {
+      const balances = new Map;
+      let utxoCount = 0;
+      for (const utxo of utxos.values()) {
+        if (!utxo.spent) {
+          utxoCount++;
+          const current = balances.get(utxo.tokenType) ?? 0n;
+          balances.set(utxo.tokenType, current + utxo.value);
+        }
+      }
+      return { balances, utxoCount, txCount, highestTxId };
+    };
+    const settle = () => {
+      clearTimeout(timeoutId);
+    };
+    const checkComplete = () => {
+      if (!settled && progressReceived && (highestTxId === 0 || lastSeenTxId >= highestTxId)) {
+        settled = true;
+        settle();
+        ws.send(JSON.stringify({ id: "1", type: "complete" }));
+        ws.close();
+        resolve4(buildResult());
+      }
+    };
+    ws.on("open", () => {
+      ws.send(JSON.stringify({ type: "connection_init" }));
+    });
+    ws.on("message", (data) => {
+      const message = JSON.parse(data.toString());
+      switch (message.type) {
+        case "connection_ack":
+          ws.send(JSON.stringify({
+            id: "1",
+            type: "subscribe",
+            payload: {
+              query: SUBSCRIPTION_QUERY,
+              variables: { address }
+            }
+          }));
+          break;
+        case "next": {
+          if (message.payload?.errors) {
+            const errMsg = message.payload.errors[0]?.message || "Unknown GraphQL error";
+            if (!settled) {
+              settled = true;
+              settle();
+              ws.close();
+              reject(new Error(`GraphQL error: ${errMsg}`));
+            }
+            return;
+          }
+          const event = message.payload?.data?.unshieldedTransactions;
+          if (!event)
+            return;
+          if (event.__typename === "UnshieldedTransaction") {
+            txCount++;
+            const tx = event;
+            lastSeenTxId = Math.max(lastSeenTxId, tx.transaction.id);
+            for (const utxo of tx.createdUtxos) {
+              const key = `${utxo.intentHash}:${utxo.outputIndex}`;
+              utxos.set(key, {
+                value: BigInt(utxo.value),
+                tokenType: utxo.tokenType,
+                spent: false
+              });
+            }
+            for (const utxo of tx.spentUtxos) {
+              const key = `${utxo.intentHash}:${utxo.outputIndex}`;
+              const existing = utxos.get(key);
+              if (existing) {
+                existing.spent = true;
+              }
+            }
+            if (onProgress) {
+              onProgress(lastSeenTxId, highestTxId);
+            }
+            checkComplete();
+          } else if (event.__typename === "UnshieldedTransactionsProgress") {
+            const progress = event;
+            highestTxId = progress.highestTransactionId;
+            progressReceived = true;
+            checkComplete();
+          }
+          break;
+        }
+        case "error":
+          if (!settled) {
+            settled = true;
+            settle();
+            ws.close();
+            reject(new Error(`GraphQL subscription error: ${JSON.stringify(message.payload)}`));
+          }
+          break;
+        case "complete":
+          break;
+      }
+    });
+    ws.on("error", (error) => {
+      if (!settled) {
+        settled = true;
+        settle();
+        reject(new Error(`WebSocket connection failed: ${error.message}`));
+      }
+    });
+    ws.on("close", () => {
+      if (!settled) {
+        settled = true;
+        settle();
+        reject(new Error(`Indexer closed the connection before balance sync completed. ` + `Indexer: ${indexerWS}`));
+      }
+    });
+    timeoutId = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        ws.close();
+        reject(new Error(`Balance check timed out after ${BALANCE_CHECK_TIMEOUT_MS / 1000}s. ` + `Indexer: ${indexerWS}`));
+      }
+    }, BALANCE_CHECK_TIMEOUT_MS);
+  });
+}
+function isNativeToken(tokenType) {
+  return tokenType === NATIVE_TOKEN_TYPE;
+}
+var SUBSCRIPTION_QUERY = `
+  subscription UnshieldedTransactions($address: UnshieldedAddress!) {
+    unshieldedTransactions(address: $address) {
+      __typename
+      ... on UnshieldedTransaction {
+        transaction { id hash }
+        createdUtxos { value owner tokenType intentHash outputIndex }
+        spentUtxos { value owner tokenType intentHash outputIndex }
+      }
+      ... on UnshieldedTransactionsProgress {
+        highestTransactionId
+      }
+    }
+  }
+`;
+var init_balance_subscription = () => {
+};
+
+// src/ui/spinner.ts
+function start(message) {
+  if (!isColorEnabled()) {
+    process.stderr.write(`⠋ ${message}`);
+    return {
+      update(msg) {
+        process.stderr.write(`\r⠋ ${msg}`);
+      },
+      stop(finalMessage) {
+        const final = finalMessage ?? message;
+        process.stderr.write(`\r✓ ${final}
+`);
+      }
+    };
+  }
+  let frameIndex = 0;
+  let currentMessage = message;
+  const render = () => {
+    const frame = teal(BRAILLE_FRAMES[frameIndex]);
+    process.stderr.write(`\r${frame} ${currentMessage}\x1B[K`);
+    frameIndex = (frameIndex + 1) % BRAILLE_FRAMES.length;
+  };
+  render();
+  const timer = setInterval(render, FRAME_INTERVAL_MS);
+  return {
+    update(msg) {
+      currentMessage = msg;
+    },
+    stop(finalMessage) {
+      clearInterval(timer);
+      const final = finalMessage ?? currentMessage;
+      process.stderr.write(`\r\x1B[32m✓\x1B[0m ${final}\x1B[K
+`);
+    }
+  };
+}
+var BRAILLE_FRAMES, FRAME_INTERVAL_MS = 80;
+var init_spinner = __esm(() => {
+  BRAILLE_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+});
+
+// src/commands/balance.ts
+var exports_balance = {};
+__export(exports_balance, {
+  default: () => balanceCommand
+});
+async function balanceCommand(args) {
+  let address;
+  let walletNetwork;
+  if (args.subcommand) {
+    address = args.subcommand;
+  } else {
+    const walletPath = getFlag(args, "wallet");
+    const config = loadWalletConfig(walletPath);
+    address = config.address;
+    walletNetwork = config.network;
+  }
+  if (!address) {
+    throw new Error("No address provided and no wallet file found.");
+  }
+  const { name: networkName, config: networkConfig } = resolveNetwork({
+    args,
+    walletNetwork,
+    address
+  });
+  const indexerWsOverride = getFlag(args, "indexer-ws");
+  const indexerWS = indexerWsOverride ?? networkConfig.indexerWS;
+  const spinner = start(`Checking balance on ${networkName}...`);
+  try {
+    const result = await checkBalance(address, indexerWS, (current, highest) => {
+      if (highest > 0) {
+        const pct = Math.round(current / highest * 100);
+        spinner.update(`Syncing transactions... ${pct}%`);
+      }
+    });
+    spinner.stop(`Synced ${result.txCount} transactions`);
+    if (hasFlag(args, "json")) {
+      const balances = {};
+      for (const [tokenType, amount] of result.balances) {
+        const key = isNativeToken(tokenType) ? "NIGHT" : tokenType;
+        balances[key] = isNativeToken(tokenType) ? toNight(amount) : amount.toString();
+      }
+      writeJsonResult({
+        address,
+        network: networkName,
+        balances,
+        utxoCount: result.utxoCount,
+        txCount: result.txCount
+      });
+      return;
+    }
+    if (result.balances.size === 0) {
+      process.stdout.write(`0
+`);
+    } else {
+      for (const [tokenType, amount] of result.balances) {
+        if (isNativeToken(tokenType)) {
+          process.stdout.write(`NIGHT=${amount}
+`);
+        } else {
+          process.stdout.write(`${tokenType}=${amount}
+`);
+        }
+      }
+    }
+    process.stderr.write(`
+` + header("Balance") + `
+
+`);
+    process.stderr.write(keyValue("Address", formatAddress(address)) + `
+`);
+    process.stderr.write(keyValue("Network", networkName) + `
+`);
+    process.stderr.write(keyValue("UTXOs", result.utxoCount.toString()) + `
+`);
+    process.stderr.write(keyValue("Transactions", result.txCount.toString()) + `
+`);
+    process.stderr.write(`
+`);
+    if (result.balances.size === 0) {
+      process.stderr.write(`  ${dim("No balance found")}
+`);
+    } else {
+      for (const [tokenType, amount] of result.balances) {
+        if (isNativeToken(tokenType)) {
+          process.stderr.write(keyValue("NIGHT", bold(formatNight(amount))) + `
+`);
+        } else {
+          const shortType = tokenType.slice(0, 8) + "…" + tokenType.slice(-8);
+          process.stderr.write(keyValue(`Token ${shortType}`, bold(amount.toString())) + `
+`);
+        }
+      }
+    }
+    process.stderr.write(`
+` + divider() + `
+
+`);
+  } catch (err) {
+    spinner.stop("Failed");
+    throw err;
+  }
+}
+var init_balance = __esm(() => {
+  init_wallet_config();
+  init_resolve_network();
+  init_balance_subscription();
+  init_format();
+  init_spinner();
+});
+
+// src/commands/address.ts
+var exports_address = {};
+__export(exports_address, {
+  default: () => addressCommand
+});
+async function addressCommand(args) {
+  const seedHex = requireFlag(args, "seed", "hex").replace(/^0x/, "");
+  if (seedHex.length !== 64 || !/^[0-9a-fA-F]+$/.test(seedHex)) {
+    throw new Error("Seed must be a 64-character hex string (32 bytes)");
+  }
+  const indexStr = getFlag(args, "index");
+  const keyIndex = indexStr !== undefined ? parseInt(indexStr, 10) : 0;
+  if (isNaN(keyIndex) || keyIndex < 0 || !Number.isInteger(Number(indexStr ?? "0"))) {
+    throw new Error("Key index must be a non-negative integer");
+  }
+  const seedBuffer = Buffer.from(seedHex, "hex");
+  const networkName = resolveNetworkName({ args });
+  const address = deriveUnshieldedAddress(seedBuffer, networkName, keyIndex);
+  const derivationPath = `m/44'/2400'/0'/NightExternal/${keyIndex}`;
+  if (hasFlag(args, "json")) {
+    writeJsonResult({
+      address,
+      network: networkName,
+      index: keyIndex,
+      path: derivationPath
+    });
+    return;
+  }
+  process.stdout.write(address + `
+`);
+  process.stderr.write(`
+`);
+  process.stderr.write(keyValue("Network", networkName) + `
+`);
+  process.stderr.write(keyValue("Index", keyIndex.toString()) + `
+`);
+  process.stderr.write(keyValue("Address", formatAddress(address)) + `
+`);
+  process.stderr.write(keyValue("Path", dim(derivationPath)) + `
+`);
+  process.stderr.write(divider() + `
+
+`);
+}
+var init_address = __esm(() => {
+  init_derive_address();
+  init_resolve_network();
+  init_format();
+});
+
+// src/commands/genesis-address.ts
+var exports_genesis_address = {};
+__export(exports_genesis_address, {
+  default: () => genesisAddressCommand
+});
+async function genesisAddressCommand(args) {
+  const networkName = resolveNetworkName({ args });
+  const seedBuffer = Buffer.from(GENESIS_SEED, "hex");
+  const address = deriveUnshieldedAddress(seedBuffer, networkName);
+  if (hasFlag(args, "json")) {
+    writeJsonResult({ address, network: networkName });
+    return;
+  }
+  process.stdout.write(address + `
+`);
+  process.stderr.write(`
+`);
+  process.stderr.write(keyValue("Network", networkName) + `
+`);
+  process.stderr.write(keyValue("Address", formatAddress(address)) + `
+`);
+  process.stderr.write(keyValue("Seed", dim("0x01 (genesis)")) + `
+`);
+  process.stderr.write(divider() + `
+
+`);
+}
+var init_genesis_address = __esm(() => {
+  init_derive_address();
+  init_resolve_network();
+  init_format();
+});
+
+// src/commands/inspect-cost.ts
+var exports_inspect_cost = {};
+__export(exports_inspect_cost, {
+  default: () => inspectCostCommand
+});
+import * as ledger from "@midnight-ntwrk/ledger-v7";
+function probeDimension(params, dimension, probeValue) {
+  const cost = {
+    readTime: 0n,
+    computeTime: 0n,
+    blockUsage: 0n,
+    bytesWritten: 0n,
+    bytesChurned: 0n
+  };
+  cost[dimension] = probeValue;
+  const normalized = params.normalizeFullness(cost);
+  const normalizedValue = normalized[dimension];
+  return Math.round(Number(probeValue) / normalizedValue);
+}
+function deriveBlockLimits(params) {
+  return {
+    readTime: probeDimension(params, "readTime", 1000000000n),
+    computeTime: probeDimension(params, "computeTime", 1000000000n),
+    blockUsage: probeDimension(params, "blockUsage", 10000n),
+    bytesWritten: probeDimension(params, "bytesWritten", 10000n),
+    bytesChurned: probeDimension(params, "bytesChurned", 1000000n)
+  };
+}
+async function inspectCostCommand(args) {
+  const params = ledger.LedgerParameters.initialParameters();
+  const limits = deriveBlockLimits(params);
+  if (hasFlag(args, "json")) {
+    writeJsonResult(limits);
+    return;
+  }
+  for (const [dimension, value] of Object.entries(limits)) {
+    process.stdout.write(`${dimension}=${value}
+`);
+  }
+  process.stderr.write(`
+` + header("Block Limits") + `
+
+`);
+  process.stderr.write(dim("  Derived from LedgerParameters.initialParameters()") + `
+
+`);
+  for (const [dimension, value] of Object.entries(limits)) {
+    const unit = UNITS[dimension] ?? "";
+    process.stderr.write(keyValue(dimension, `${bold(value.toLocaleString())} ${dim(unit)}`) + `
+`);
+  }
+  process.stderr.write(`
+` + divider() + `
+`);
+  process.stderr.write(dim("  bytesWritten is typically the tightest constraint") + `
+`);
+  process.stderr.write(dim("  for large contract deployments.") + `
+
+`);
+}
+var UNITS;
+var init_inspect_cost = __esm(() => {
+  init_format();
+  UNITS = {
+    readTime: "picoseconds",
+    computeTime: "picoseconds",
+    blockUsage: "bytes",
+    bytesWritten: "bytes",
+    bytesChurned: "bytes"
+  };
+});
+
+// src/lib/derivation.ts
+import { HDWallet as HDWallet2, Roles as Roles2 } from "@midnight-ntwrk/wallet-sdk-hd";
+function deriveKey(seedBuffer, role) {
+  const hdResult = HDWallet2.fromSeed(seedBuffer);
+  if (hdResult.type !== "seedOk") {
+    throw new Error("Invalid seed for HD wallet");
+  }
+  const derivation = hdResult.hdWallet.selectAccount(0).selectRole(role).deriveKeyAt(0);
+  if (derivation.type === "keyOutOfBounds") {
+    throw new Error("Key derivation out of bounds");
+  }
+  return derivation.key;
+}
+function deriveShieldedSeed(seedBuffer) {
+  return deriveKey(seedBuffer, Roles2.Zswap);
+}
+function deriveUnshieldedSeed(seedBuffer) {
+  return deriveKey(seedBuffer, Roles2.NightExternal);
+}
+function deriveDustSeed(seedBuffer) {
+  return deriveKey(seedBuffer, Roles2.Dust);
+}
+var init_derivation = () => {
+};
+
+// src/lib/facade.ts
+import { ShieldedWallet } from "@midnight-ntwrk/wallet-sdk-shielded";
+import {
+  UnshieldedWallet,
+  createKeystore as createKeystore2,
+  PublicKey as PublicKey2,
+  InMemoryTransactionHistoryStorage
+} from "@midnight-ntwrk/wallet-sdk-unshielded-wallet";
+import { DustWallet } from "@midnight-ntwrk/wallet-sdk-dust-wallet";
+import { WalletFacade } from "@midnight-ntwrk/wallet-sdk-facade";
+import * as ledger2 from "@midnight-ntwrk/ledger-v7";
+import { NetworkId as NetworkId2 } from "@midnight-ntwrk/wallet-sdk-abstractions";
+import * as rx from "rxjs";
+function buildFacade(seedBuffer, networkConfig) {
+  const networkId = NETWORK_ID_MAP2[networkConfig.networkId];
+  if (networkId === undefined) {
+    throw new Error(`Unknown networkId: ${networkConfig.networkId}`);
+  }
+  const shieldedSeed = deriveShieldedSeed(seedBuffer);
+  const unshieldedSeed = deriveUnshieldedSeed(seedBuffer);
+  const dustSeed = deriveDustSeed(seedBuffer);
+  const zswapSecretKeys = ledger2.ZswapSecretKeys.fromSeed(shieldedSeed);
+  const dustSecretKey = ledger2.DustSecretKey.fromSeed(dustSeed);
+  const keystore = createKeystore2(unshieldedSeed, networkId);
+  const shieldedConfig = {
+    networkId,
+    indexerClientConnection: {
+      indexerHttpUrl: networkConfig.indexer,
+      indexerWsUrl: networkConfig.indexerWS
+    },
+    provingServerUrl: new URL(networkConfig.proofServer),
+    relayURL: new URL(networkConfig.node)
+  };
+  const unshieldedConfig = {
+    networkId,
+    indexerClientConnection: {
+      indexerHttpUrl: networkConfig.indexer,
+      indexerWsUrl: networkConfig.indexerWS
+    },
+    txHistoryStorage: new InMemoryTransactionHistoryStorage
+  };
+  const dustConfig = {
+    networkId,
+    costParameters: {
+      additionalFeeOverhead: DUST_COST_OVERHEAD,
+      feeBlocksMargin: DUST_FEE_BLOCKS_MARGIN
+    },
+    indexerClientConnection: {
+      indexerHttpUrl: networkConfig.indexer,
+      indexerWsUrl: networkConfig.indexerWS
+    },
+    provingServerUrl: new URL(networkConfig.proofServer),
+    relayURL: new URL(networkConfig.node)
+  };
+  const shieldedWallet = ShieldedWallet(shieldedConfig).startWithSecretKeys(zswapSecretKeys);
+  const unshieldedWallet = UnshieldedWallet(unshieldedConfig).startWithPublicKey(PublicKey2.fromKeyStore(keystore));
+  const dustWallet = DustWallet(dustConfig).startWithSecretKey(dustSecretKey, ledger2.LedgerParameters.initialParameters().dust);
+  const facade = new WalletFacade(shieldedWallet, unshieldedWallet, dustWallet);
+  return { facade, keystore, zswapSecretKeys, dustSecretKey };
+}
+async function startAndSyncFacade(bundle, onProgress) {
+  const { facade, zswapSecretKeys, dustSecretKey } = bundle;
+  await facade.start(zswapSecretKeys, dustSecretKey);
+  return rx.firstValueFrom(facade.state().pipe(rx.tap((state) => {
+    if (onProgress) {
+      const progress = state.unshielded.progress;
+      if (progress) {
+        onProgress(Number(progress.appliedId), Number(progress.highestTransactionId));
+      }
+    }
+  }), rx.filter((state) => state.isSynced), rx.timeout(SYNC_TIMEOUT_MS)));
+}
+async function quickSync(bundle) {
+  return rx.firstValueFrom(bundle.facade.state().pipe(rx.filter((state) => state.isSynced), rx.timeout(PRE_SEND_SYNC_TIMEOUT_MS)));
+}
+async function stopFacade(bundle) {
+  await bundle.facade.stop();
+}
+function suppressSdkTransientErrors(onWarning) {
+  const rejectionHandler = (reason) => {
+    const tag = reason?._tag;
+    if (typeof tag === "string" && tag.startsWith("Wallet.")) {
+      const msg = reason?.message ?? "transient error";
+      onWarning?.(tag, msg);
+      return;
+    }
+    originalConsoleError("Unhandled rejection:", reason);
+    process.exit(1);
+  };
+  const originalConsoleError = console.error;
+  console.error = (...args) => {
+    const firstArg = args[0];
+    if (typeof firstArg === "object" && firstArg?._tag?.startsWith("Wallet.")) {
+      onWarning?.(firstArg._tag, firstArg?.message ?? "transient error");
+      return;
+    }
+    if (typeof firstArg === "string" && firstArg.startsWith("Wallet.")) {
+      onWarning?.("Wallet.Sync", "transient error");
+      return;
+    }
+    originalConsoleError(...args);
+  };
+  process.on("unhandledRejection", rejectionHandler);
+  return () => {
+    process.removeListener("unhandledRejection", rejectionHandler);
+    console.error = originalConsoleError;
+  };
+}
+var NETWORK_ID_MAP2;
+var init_facade = __esm(() => {
+  init_derivation();
+  NETWORK_ID_MAP2 = {
+    PreProd: NetworkId2.NetworkId.PreProd,
+    Preview: NetworkId2.NetworkId.Preview,
+    Undeployed: NetworkId2.NetworkId.Undeployed
+  };
+});
+
+// src/lib/transfer.ts
+import * as ledger3 from "@midnight-ntwrk/ledger-v7";
+import { MidnightBech32m, UnshieldedAddress } from "@midnight-ntwrk/wallet-sdk-address-format";
+import { NetworkId as NetworkId3 } from "@midnight-ntwrk/wallet-sdk-abstractions";
+import * as rx2 from "rxjs";
+function nightToMicro(amountNight) {
+  if (amountNight <= 0) {
+    throw new Error("Amount must be greater than 0");
+  }
+  if (!Number.isFinite(amountNight)) {
+    throw new Error("Amount must be a finite number");
+  }
+  const str = amountNight.toFixed(6);
+  const [whole, frac] = str.split(".");
+  const microStr = whole + (frac ?? "").padEnd(6, "0");
+  const micro = BigInt(microStr);
+  if (micro <= 0n) {
+    throw new Error("Amount too small — minimum is 0.000001 NIGHT");
+  }
+  return micro;
+}
+function parseAmount(amountStr) {
+  const amount = Number(amountStr);
+  if (Number.isNaN(amount) || !Number.isFinite(amount)) {
+    throw new Error(`Invalid amount: "${amountStr}" — must be a positive number`);
+  }
+  if (amount <= 0) {
+    throw new Error(`Invalid amount: "${amountStr}" — must be greater than 0`);
+  }
+  return amount;
+}
+function validateRecipientAddress(address, networkConfig) {
+  const networkId = NETWORK_ID_MAP3[networkConfig.networkId];
+  if (networkId === undefined) {
+    throw new Error(`Unknown networkId: ${networkConfig.networkId}`);
+  }
+  try {
+    MidnightBech32m.parse(address).decode(UnshieldedAddress, networkId);
+  } catch (err) {
+    throw new Error(`Invalid recipient address: ${err.message}
+` + `Expected a bech32m address for network "${networkConfig.networkId}"`);
+  }
+}
+async function ensureDust(bundle, onDust) {
+  const state = await rx2.firstValueFrom(bundle.facade.state().pipe(rx2.filter((s) => s.isSynced)));
+  const nightUtxos = state.unshielded.availableCoins.filter((coin) => coin.meta?.registeredForDustGeneration !== true);
+  if (nightUtxos.length > 0) {
+    onDust?.(`Registering ${nightUtxos.length} UTXO(s) for dust generation...`);
+    const ttl = new Date(Date.now() + TX_TTL_MINUTES * 60 * 1000);
+    const dustReceiverAddress = state.dust.dustAddress;
+    const dustUtxos = nightUtxos.map((coin) => ({
+      ...coin.utxo,
+      ctime: new Date(coin.meta.ctime)
+    }));
+    await bundle.facade.dust.waitForSyncedState();
+    const unprovenTx = await bundle.facade.dust.createDustGenerationTransaction(new Date, ttl, dustUtxos, bundle.keystore.getPublicKey(), dustReceiverAddress);
+    const intent = unprovenTx.intents?.get(1);
+    if (!intent) {
+      throw new Error("Dust generation intent not found on transaction");
+    }
+    const signature = bundle.keystore.signData(intent.signatureData(1));
+    const signedTx = await bundle.facade.dust.addDustGenerationSignature(unprovenTx, signature);
+    const finalized = await bundle.facade.finalizeTransaction(signedTx);
+    await bundle.facade.submitTransaction(finalized);
+  } else if (state.dust.availableCoins.length > 0) {
+    onDust?.("Dust available");
+    return;
+  } else {
+    onDust?.("UTXOs already registered, waiting for dust generation...");
+  }
+  onDust?.("Waiting for dust tokens...");
+  await rx2.firstValueFrom(bundle.facade.state().pipe(rx2.throttleTime(5000), rx2.filter((s) => s.isSynced), rx2.filter((s) => s.dust.walletBalance(new Date) > 0n), rx2.timeout(DUST_TIMEOUT_MS)));
+  onDust?.("Dust available");
+}
+async function buildAndSubmitTransfer(bundle, recipientAddress, amount, onProving, onSubmitting) {
+  let lastError;
+  for (let attempt = 1;attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
+    try {
+      if (attempt > 1) {
+        await quickSync(bundle);
+      }
+      const ttl = new Date(Date.now() + TX_TTL_MINUTES * 60 * 1000);
+      const unprovenRecipe = await bundle.facade.transferTransaction([
+        {
+          type: "unshielded",
+          outputs: [
+            {
+              amount,
+              receiverAddress: recipientAddress,
+              type: ledger3.unshieldedToken().raw
+            }
+          ]
+        }
+      ], { shieldedSecretKeys: bundle.zswapSecretKeys, dustSecretKey: bundle.dustSecretKey }, { ttl, payFees: true });
+      const signedRecipe = await bundle.facade.signRecipe(unprovenRecipe, (payload) => bundle.keystore.signData(payload));
+      onProving?.();
+      const finalizedTx = await Promise.race([
+        bundle.facade.finalizeRecipe(signedRecipe),
+        new Promise((_, reject) => {
+          setTimeout(() => reject(new Error("ZK proof generation timed out")), PROOF_TIMEOUT_MS);
+        })
+      ]);
+      onSubmitting?.();
+      const txHash = await bundle.facade.submitTransaction(finalizedTx);
+      return txHash;
+    } catch (err) {
+      lastError = err;
+      const isStaleUtxo = err?.code === STALE_UTXO_ERROR_CODE || err?.message?.includes("115") || err?.message?.toLowerCase().includes("stale");
+      if (isStaleUtxo && attempt < MAX_RETRY_ATTEMPTS) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastError ?? new Error("Transfer failed after retries");
+}
+async function executeTransfer(params) {
+  const {
+    seedBuffer,
+    networkConfig,
+    recipientAddress,
+    amountNight,
+    signal,
+    onSync,
+    onDust,
+    onProving,
+    onSubmitting,
+    onSyncWarning
+  } = params;
+  const amount = nightToMicro(amountNight);
+  validateRecipientAddress(recipientAddress, networkConfig);
+  const unsuppress = suppressSdkTransientErrors(onSyncWarning);
+  const bundle = buildFacade(seedBuffer, networkConfig);
+  let shutdownComplete = false;
+  const cleanup = async () => {
+    if (!shutdownComplete) {
+      shutdownComplete = true;
+      try {
+        await stopFacade(bundle);
+      } catch {
+      }
+    }
+  };
+  const onAbort = () => {
+    cleanup();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const syncedState = await startAndSyncFacade(bundle, onSync);
+    if (signal?.aborted)
+      throw new Error("Operation cancelled");
+    const unshieldedBalance = syncedState.unshielded.balances[ledger3.unshieldedToken().raw] ?? 0n;
+    if (unshieldedBalance < amount) {
+      const haveNight = Number(unshieldedBalance) / TOKEN_MULTIPLIER;
+      throw new Error(`Insufficient balance: ${haveNight.toFixed(6)} NIGHT available, ` + `${amountNight} NIGHT requested`);
+    }
+    if (signal?.aborted)
+      throw new Error("Operation cancelled");
+    await ensureDust(bundle, onDust);
+    if (signal?.aborted)
+      throw new Error("Operation cancelled");
+    const txHash = await buildAndSubmitTransfer(bundle, recipientAddress, amount, onProving, onSubmitting);
+    return { txHash, amountMicroNight: amount };
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    unsuppress();
+    await cleanup();
+  }
+}
+var NETWORK_ID_MAP3;
+var init_transfer = __esm(() => {
+  init_facade();
+  NETWORK_ID_MAP3 = {
+    PreProd: NetworkId3.NetworkId.PreProd,
+    Preview: NetworkId3.NetworkId.Preview,
+    Undeployed: NetworkId3.NetworkId.Undeployed
+  };
+});
+
+// src/commands/airdrop.ts
+var exports_airdrop = {};
+__export(exports_airdrop, {
+  default: () => airdropCommand
+});
+async function airdropCommand(args, signal) {
+  const amountStr = args.subcommand;
+  if (!amountStr) {
+    throw new Error(`Missing amount.
+` + `Usage: midnight airdrop <amount>
+` + "Example: midnight airdrop 1000");
+  }
+  const amountNight = parseAmount(amountStr);
+  const walletPath = getFlag(args, "wallet");
+  const config = loadWalletConfig(walletPath);
+  const { name: networkName, config: networkConfig } = resolveNetwork({
+    args,
+    walletNetwork: config.network,
+    address: config.address
+  });
+  if (networkName !== "undeployed") {
+    throw new Error(`Airdrop is only available on the "undeployed" network (local devnet).
+` + `Current network: "${networkName}"
+` + `On preprod/preview, use a faucet or transfer from another wallet.`);
+  }
+  const recipientAddress = config.address;
+  const genesisSeedBuffer = Buffer.from(GENESIS_SEED, "hex");
+  process.stderr.write(`
+` + header("Airdrop") + `
+
+`);
+  process.stderr.write(keyValue("Network", networkName) + `
+`);
+  process.stderr.write(keyValue("From", dim("genesis (seed 0x01)")) + `
+`);
+  process.stderr.write(keyValue("To", formatAddress(recipientAddress, true)) + `
+`);
+  process.stderr.write(keyValue("Amount", bold(amountNight + " NIGHT")) + `
+`);
+  process.stderr.write(`
+`);
+  const spinner = start("Starting genesis wallet...");
+  try {
+    const result = await executeTransfer({
+      seedBuffer: genesisSeedBuffer,
+      networkConfig,
+      recipientAddress,
+      amountNight,
+      signal,
+      onSync(applied, highest) {
+        if (highest > 0) {
+          const pct = Math.round(applied / highest * 100);
+          spinner.update(`Syncing genesis wallet... ${pct}%`);
+        }
+      },
+      onDust(status) {
+        spinner.update(`Dust: ${status}`);
+      },
+      onProving() {
+        spinner.update("Generating ZK proof (this may take a few minutes)...");
+      },
+      onSubmitting() {
+        spinner.update("Submitting transaction...");
+      },
+      onSyncWarning(_tag, msg) {
+        spinner.update(`Syncing genesis wallet... (${msg}, retrying)`);
+      }
+    });
+    spinner.stop("Transaction submitted");
+    if (hasFlag(args, "json")) {
+      writeJsonResult({
+        txHash: result.txHash,
+        amount: amountNight,
+        recipient: recipientAddress,
+        network: networkName
+      });
+      return;
+    }
+    process.stdout.write(result.txHash + `
+`);
+    process.stderr.write(`
+` + successMessage(`Airdropped ${amountNight} NIGHT to your wallet`, result.txHash) + `
+`);
+    process.stderr.write(`
+` + divider() + `
+`);
+    process.stderr.write(dim("  Verify: midnight balance") + `
+
+`);
+  } catch (err) {
+    spinner.stop("Failed");
+    if (err instanceof Error && err.message.toLowerCase().includes("dust")) {
+      throw new Error(`${err.message}
+
+` + `On a fresh localnet, the minimum airdrop is ~1 NIGHT.
+` + `Try: midnight airdrop 1`);
+    }
+    throw err;
+  }
+}
+var init_airdrop = __esm(() => {
+  init_wallet_config();
+  init_resolve_network();
+  init_transfer();
+  init_format();
+  init_spinner();
+});
+
+// src/commands/transfer.ts
+var exports_transfer = {};
+__export(exports_transfer, {
+  default: () => transferCommand
+});
+async function transferCommand(args, signal) {
+  const recipientAddress = args.subcommand;
+  const amountStr = args.positionals[0];
+  if (!recipientAddress) {
+    throw new Error(`Missing recipient address.
+` + `Usage: midnight transfer <to> <amount>
+` + "Example: midnight transfer mn_addr_undeployed1... 100");
+  }
+  if (!amountStr) {
+    throw new Error(`Missing amount.
+` + `Usage: midnight transfer <to> <amount>
+` + "Example: midnight transfer mn_addr_undeployed1... 100");
+  }
+  const amountNight = parseAmount(amountStr);
+  const walletPath = getFlag(args, "wallet");
+  const config = loadWalletConfig(walletPath);
+  const seedBuffer = Buffer.from(config.seed, "hex");
+  const { name: networkName, config: networkConfig } = resolveNetwork({
+    args,
+    walletNetwork: config.network,
+    address: config.address
+  });
+  process.stderr.write(`
+` + header("Transfer") + `
+
+`);
+  process.stderr.write(keyValue("Network", networkName) + `
+`);
+  process.stderr.write(keyValue("From", formatAddress(config.address, true)) + `
+`);
+  process.stderr.write(keyValue("To", formatAddress(recipientAddress, true)) + `
+`);
+  process.stderr.write(keyValue("Amount", bold(amountNight + " NIGHT")) + `
+`);
+  process.stderr.write(`
+`);
+  const spinner = start("Starting wallet...");
+  try {
+    const result = await executeTransfer({
+      seedBuffer,
+      networkConfig,
+      recipientAddress,
+      amountNight,
+      signal,
+      onSync(applied, highest) {
+        if (highest > 0) {
+          const pct = Math.round(applied / highest * 100);
+          spinner.update(`Syncing wallet... ${pct}%`);
+        }
+      },
+      onDust(status) {
+        spinner.update(`Dust: ${status}`);
+      },
+      onProving() {
+        spinner.update("Generating ZK proof (this may take a few minutes)...");
+      },
+      onSubmitting() {
+        spinner.update("Submitting transaction...");
+      },
+      onSyncWarning(_tag, msg) {
+        spinner.update(`Syncing wallet... (${msg}, retrying)`);
+      }
+    });
+    spinner.stop("Transaction submitted");
+    if (hasFlag(args, "json")) {
+      writeJsonResult({
+        txHash: result.txHash,
+        amount: amountNight,
+        recipient: recipientAddress,
+        network: networkName
+      });
+      return;
+    }
+    process.stdout.write(result.txHash + `
+`);
+    process.stderr.write(`
+` + successMessage(`Transferred ${amountNight} NIGHT`, result.txHash) + `
+`);
+    process.stderr.write(`
+` + divider() + `
+`);
+    process.stderr.write(dim("  Verify: midnight balance") + `
+
+`);
+  } catch (err) {
+    spinner.stop("Failed");
+    throw err;
+  }
+}
+var init_transfer2 = __esm(() => {
+  init_wallet_config();
+  init_resolve_network();
+  init_transfer();
+  init_format();
+  init_spinner();
+});
+
+// src/commands/dust.ts
+var exports_dust = {};
+__export(exports_dust, {
+  default: () => dustCommand
+});
+import * as ledger4 from "@midnight-ntwrk/ledger-v7";
+import * as rx3 from "rxjs";
+async function dustCommand(args, signal) {
+  const subcommand = args.subcommand;
+  if (!subcommand || subcommand !== "register" && subcommand !== "status") {
+    throw new Error(`Missing or invalid subcommand.
+` + `Usage:
+` + `  midnight dust register   Register NIGHT UTXOs for dust generation
+` + "  midnight dust status     Check dust registration status");
+  }
+  const walletPath = getFlag(args, "wallet");
+  const config = loadWalletConfig(walletPath);
+  const seedBuffer = Buffer.from(config.seed, "hex");
+  const { name: networkName, config: networkConfig } = resolveNetwork({
+    args,
+    walletNetwork: config.network,
+    address: config.address
+  });
+  const bundle = buildFacade(seedBuffer, networkConfig);
+  const cleanup = async () => {
+    try {
+      await stopFacade(bundle);
+    } catch {
+    }
+  };
+  const onAbort = () => {
+    cleanup();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const warningRef = {};
+  const unsuppress = suppressSdkTransientErrors((tag, msg) => {
+    warningRef.current?.(tag, msg);
+  });
+  const isJson = hasFlag(args, "json");
+  try {
+    if (subcommand === "register") {
+      await dustRegister(bundle, networkName, isJson, signal, warningRef);
+    } else {
+      await dustStatus(bundle, networkName, isJson, signal, warningRef);
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    unsuppress();
+    await cleanup();
+  }
+}
+async function dustRegister(bundle, networkName, jsonMode, signal, warningRef) {
+  process.stderr.write(`
+` + header("Dust Register") + `
+
+`);
+  process.stderr.write(keyValue("Network", networkName) + `
+
+`);
+  const spinner = start("Syncing wallet...");
+  if (warningRef) {
+    warningRef.current = (_tag, msg) => spinner.update(`Syncing wallet... (${msg}, retrying)`);
+  }
+  try {
+    await startAndSyncFacade(bundle, (applied, highest) => {
+      if (highest > 0) {
+        const pct = Math.round(applied / highest * 100);
+        spinner.update(`Syncing wallet... ${pct}%`);
+      }
+    });
+    if (signal?.aborted)
+      throw new Error("Operation cancelled");
+    spinner.update("Checking dust status...");
+    const state = await rx3.firstValueFrom(bundle.facade.state().pipe(rx3.filter((s) => s.isSynced)));
+    if (state.dust.availableCoins.length > 0) {
+      const dustBal2 = state.dust.walletBalance(new Date);
+      spinner.stop("Dust already available");
+      if (jsonMode) {
+        writeJsonResult({ subcommand: "register", dustBalance: toDust(dustBal2) });
+        return;
+      }
+      process.stdout.write(dustBal2.toString() + `
+`);
+      process.stderr.write(`
+` + successMessage(`Dust tokens already available: ${formatDust(dustBal2)}`) + `
+
+`);
+      return;
+    }
+    const nightUtxos = state.unshielded.availableCoins.filter((coin) => coin.meta?.registeredForDustGeneration !== true);
+    let txHash;
+    if (nightUtxos.length === 0) {
+      spinner.update("All UTXOs already registered, waiting for dust generation...");
+    } else {
+      spinner.update(`Registering ${nightUtxos.length} UTXO(s) for dust generation...`);
+      const ttl = new Date(Date.now() + TX_TTL_MINUTES * 60 * 1000);
+      const dustReceiverAddress = state.dust.dustAddress;
+      const dustUtxos = nightUtxos.map((coin) => ({
+        ...coin.utxo,
+        ctime: new Date(coin.meta.ctime)
+      }));
+      await bundle.facade.dust.waitForSyncedState();
+      const unprovenTx = await bundle.facade.dust.createDustGenerationTransaction(new Date, ttl, dustUtxos, bundle.keystore.getPublicKey(), dustReceiverAddress);
+      const intent = unprovenTx.intents?.get(1);
+      if (!intent) {
+        throw new Error("Dust generation intent not found on transaction");
+      }
+      const signature = bundle.keystore.signData(intent.signatureData(1));
+      const signedTx = await bundle.facade.dust.addDustGenerationSignature(unprovenTx, signature);
+      const finalized = await bundle.facade.finalizeTransaction(signedTx);
+      txHash = await bundle.facade.submitTransaction(finalized);
+      spinner.update(`Registration submitted (${txHash.slice(0, 12)}...), waiting for dust...`);
+    }
+    if (signal?.aborted)
+      throw new Error("Operation cancelled");
+    const dustState = await rx3.firstValueFrom(bundle.facade.state().pipe(rx3.throttleTime(5000), rx3.filter((s) => s.isSynced), rx3.filter((s) => s.dust.walletBalance(new Date) > 0n), rx3.timeout(DUST_TIMEOUT_MS)));
+    const dustBal = dustState.dust.walletBalance(new Date);
+    spinner.stop("Dust registration complete");
+    if (jsonMode) {
+      const result = { subcommand: "register", dustBalance: toDust(dustBal) };
+      if (txHash)
+        result.txHash = txHash;
+      writeJsonResult(result);
+      return;
+    }
+    process.stdout.write(dustBal.toString() + `
+`);
+    process.stderr.write(`
+` + successMessage(`Dust tokens available: ${formatDust(dustBal)}`) + `
+
+`);
+  } catch (err) {
+    spinner.stop("Failed");
+    throw err;
+  }
+}
+async function dustStatus(bundle, networkName, jsonMode, signal, warningRef) {
+  process.stderr.write(`
+` + header("Dust Status") + `
+
+`);
+  process.stderr.write(keyValue("Network", networkName) + `
+
+`);
+  const spinner = start("Syncing wallet...");
+  if (warningRef) {
+    warningRef.current = (_tag, msg) => spinner.update(`Syncing wallet... (${msg}, retrying)`);
+  }
+  try {
+    await startAndSyncFacade(bundle, (applied, highest) => {
+      if (highest > 0) {
+        const pct = Math.round(applied / highest * 100);
+        spinner.update(`Syncing wallet... ${pct}%`);
+      }
+    });
+    if (signal?.aborted)
+      throw new Error("Operation cancelled");
+    spinner.update("Checking dust status...");
+    const state = await rx3.firstValueFrom(bundle.facade.state().pipe(rx3.filter((s) => s.isSynced)));
+    const dustBalance = state.dust.walletBalance(new Date);
+    const hasAvailableDust = state.dust.availableCoins.length > 0;
+    const allUtxos = state.unshielded.availableCoins;
+    const unregisteredUtxos = allUtxos.filter((coin) => coin.meta?.registeredForDustGeneration !== true);
+    const registeredCount = allUtxos.length - unregisteredUtxos.length;
+    const unshieldedBalance = state.unshielded.balances[ledger4.unshieldedToken().raw] ?? 0n;
+    spinner.stop("Done");
+    if (jsonMode) {
+      writeJsonResult({
+        subcommand: "status",
+        dustBalance: toDust(dustBalance),
+        registered: registeredCount,
+        unregistered: unregisteredUtxos.length,
+        nightBalance: toNight(unshieldedBalance),
+        dustAvailable: hasAvailableDust
+      });
+      return;
+    }
+    process.stdout.write(`dust=${dustBalance}
+`);
+    process.stdout.write(`registered=${registeredCount}
+`);
+    process.stdout.write(`unregistered=${unregisteredUtxos.length}
+`);
+    process.stderr.write(keyValue("NIGHT Balance", bold(formatNight(unshieldedBalance))) + `
+`);
+    process.stderr.write(keyValue("Dust Balance", bold(formatDust(dustBalance))) + `
+`);
+    process.stderr.write(keyValue("Dust Available", hasAvailableDust ? "yes" : "no") + `
+`);
+    process.stderr.write(keyValue("Registered", registeredCount.toString() + " UTXO(s)") + `
+`);
+    process.stderr.write(keyValue("Unregistered", unregisteredUtxos.length.toString() + " UTXO(s)") + `
+`);
+    process.stderr.write(`
+` + divider() + `
+
+`);
+  } catch (err) {
+    spinner.stop("Failed");
+    throw err;
+  }
+}
+var init_dust = __esm(() => {
+  init_wallet_config();
+  init_resolve_network();
+  init_facade();
+  init_format();
+  init_spinner();
+});
+
+// src/commands/config.ts
+var exports_config = {};
+__export(exports_config, {
+  default: () => configCommand
+});
+async function configCommand(args) {
+  const action = args.subcommand;
+  if (!action || action !== "get" && action !== "set") {
+    throw new Error(`Usage: midnight config <get|set> <key> [value]
+` + `Valid keys: ${getValidConfigKeys().join(", ")}`);
+  }
+  const key = args.positionals[0];
+  if (!key) {
+    throw new Error(`Missing config key.
+` + `Valid keys: ${getValidConfigKeys().join(", ")}`);
+  }
+  if (action === "get") {
+    const value = getConfigValue(key);
+    if (hasFlag(args, "json")) {
+      writeJsonResult({ action: "get", key, value });
+      return;
+    }
+    process.stdout.write(value + `
+`);
+  } else {
+    const value = args.positionals[1];
+    if (value === undefined) {
+      throw new Error(`Missing value for config set.
+Usage: midnight config set ${key} <value>`);
+    }
+    setConfigValue(key, value);
+    if (hasFlag(args, "json")) {
+      writeJsonResult({ action: "set", key, value });
+      return;
+    }
+    process.stderr.write(green("✓") + ` ${key} = ${value}
+`);
+  }
+}
+var init_config = __esm(() => {
+  init_cli_config();
+});
+
+// src/lib/localnet.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+function checkDockerAvailable() {
+  try {
+    const output = execSync2("docker compose version", { ...EXEC_OPTIONS, timeout: 1e4 });
+    return output.trim();
+  } catch {
+    try {
+      execSync2("docker --version", { ...EXEC_OPTIONS, timeout: 5000 });
+      throw new Error(`Docker Compose v2 is required.
+` + "Install it from https://docs.docker.com/compose/install/");
+    } catch (innerErr) {
+      if (innerErr instanceof Error && innerErr.message.includes("Docker Compose v2")) {
+        throw innerErr;
+      }
+      throw new Error(`Docker is required but was not found.
+` + "Install Docker from https://docs.docker.com/get-docker/");
+    }
+  }
+}
+function ensureComposeFile() {
+  const versionMatches = existsSync4(VERSION_PATH) && existsSync4(COMPOSE_PATH) && readFileSync3(VERSION_PATH, "utf-8").trim() === COMPOSE_VERSION;
+  if (versionMatches)
+    return false;
+  mkdirSync3(LOCALNET_DIR, { recursive: true, mode: DIR_MODE });
+  writeFileSync3(COMPOSE_PATH, COMPOSE_YAML, "utf-8");
+  writeFileSync3(VERSION_PATH, COMPOSE_VERSION, "utf-8");
+  return true;
+}
+function dockerCompose(args) {
+  return execSync2(`docker compose -f "${COMPOSE_PATH}" ${args}`, EXEC_OPTIONS);
+}
+function getServiceStatus() {
+  try {
+    const output = dockerCompose("ps --format json");
+    if (!output.trim())
+      return [];
+    const lines = output.trim().split(`
+`);
+    const services = [];
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      try {
+        const obj = JSON.parse(line);
+        const name = obj.Service ?? "unknown";
+        services.push({
+          name,
+          state: obj.State ?? "unknown",
+          health: obj.Health ?? "",
+          port: PORT_MAP[name] ?? ""
+        });
+      } catch {
+      }
+    }
+    return services;
+  } catch {
+    return [];
+  }
+}
+function waitForHealthy(timeoutMs = 120000, intervalMs = 3000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const services = getServiceStatus();
+    const allRunning = services.length === 3 && services.every((s) => s.state === "running");
+    if (allRunning) {
+      const healthyOrNoCheck = services.every((s) => s.health === "healthy" || s.health === "");
+      if (healthyOrNoCheck)
+        return true;
+    }
+    execSync2(`sleep ${intervalMs / 1000}`, { timeout: intervalMs + 1000 });
+  }
+  return false;
+}
+function getComposePath() {
+  return COMPOSE_PATH;
+}
+function removeConflictingContainers() {
+  const removed = [];
+  for (const name of CONTAINER_NAMES) {
+    try {
+      execSync2(`docker rm -f "${name}"`, { ...EXEC_OPTIONS, timeout: 1e4 });
+      removed.push(name);
+    } catch {
+    }
+  }
+  return removed;
+}
+var COMPOSE_VERSION = "1.4.0", LOCALNET_DIR, COMPOSE_PATH, VERSION_PATH, COMPOSE_YAML = `services:
+  proof-server:
+    image: 'nel349/proof-server:7.0.0'
+    container_name: "proof-server"
+    ports:
+      - "6300:6300"
+
+  indexer:
+    image: 'midnightntwrk/indexer-standalone:3.0.0'
+    container_name: "indexer"
+    ports:
+      - '8088:8088'
+    environment:
+      RUST_LOG: "indexer=info,chain_indexer=info,indexer_api=info,wallet_indexer=info,indexer_common=info,fastrace_opentelemetry=info,info"
+      # Random 32-byte hex-encoded secret used to make the standalone indexer run.
+      # Only needed to satisfy the config schema – not meant for secure use.
+      APP__INFRA__SECRET: "303132333435363738393031323334353637383930313233343536373839303132"
+      APP__INFRA__NODE__URL: "ws://node:9944"
+    healthcheck:
+      test: ["CMD-SHELL", "cat /var/run/indexer-standalone/running"]
+      start_interval: "5s"
+      interval: "5s"
+      timeout: "2s"
+      retries: 2
+      start_period: 5s
+    depends_on:
+      node:
+        condition: service_started
+
+  node:
+    image: 'midnightntwrk/midnight-node:0.20.1'
+    container_name: "node"
+    ports:
+      - "9944:9944"
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:9944/health"]
+      interval: 2s
+      timeout: 5s
+      retries: 5
+      start_period: 5s
+    environment:
+      CFG_PRESET: "dev"
+`, EXEC_OPTIONS, PORT_MAP, CONTAINER_NAMES;
+var init_localnet = __esm(() => {
+  LOCALNET_DIR = join5(homedir5(), MIDNIGHT_DIR, LOCALNET_DIR_NAME);
+  COMPOSE_PATH = join5(LOCALNET_DIR, "compose.yml");
+  VERSION_PATH = join5(LOCALNET_DIR, ".version");
+  EXEC_OPTIONS = {
+    encoding: "utf-8",
+    timeout: 30000
+  };
+  PORT_MAP = {
+    node: "9944",
+    indexer: "8088",
+    "proof-server": "6300"
+  };
+  CONTAINER_NAMES = ["node", "indexer", "proof-server"];
+});
+
+// src/commands/localnet.ts
+var exports_localnet = {};
+__export(exports_localnet, {
+  default: () => localnetCommand
+});
+import { spawn } from "child_process";
+function isValidSubcommand(s) {
+  return VALID_SUBCOMMANDS.includes(s);
+}
+function formatServiceTable(services) {
+  const lines = [];
+  for (const svc of services) {
+    const stateColor = svc.state === "running" ? green : red;
+    const healthStr = svc.health ? ` (${svc.health})` : "";
+    const portStr = svc.port ? `:${svc.port}` : "";
+    lines.push(`  ${svc.name.padEnd(16)}${stateColor(svc.state)}${dim(healthStr)}${dim(portStr)}`);
+  }
+  return lines.join(`
+`);
+}
+async function handleUp(jsonMode) {
+  const wrote = ensureComposeFile();
+  if (wrote) {
+    process.stderr.write(dim(`  Wrote compose.yml to ${getComposePath()}`) + `
+`);
+  }
+  const spinner = start("Starting local network...");
+  try {
+    dockerCompose("up -d");
+    spinner.update("Waiting for services to be healthy...");
+    const healthy = waitForHealthy(120000);
+    if (!healthy) {
+      spinner.stop(yellow("Services started but not all healthy yet"));
+      process.stderr.write(`
+` + dim("  Tip: run ") + bold("midnight localnet logs") + dim(" to check for errors") + `
+`);
+    } else {
+      spinner.stop("Local network is running");
+    }
+  } catch (err) {
+    spinner.stop(red("Failed to start local network"));
+    if (err instanceof Error) {
+      if (err.message.includes("is already in use by container")) {
+        throw new Error(`Container name conflict — containers with the same names already exist
+` + `(likely from a previous midnight-local-network setup).
+
+` + 'Run "midnight localnet clean" to remove them, then try again.');
+      }
+      if (err.message.includes("address already in use")) {
+        throw new Error(`Port conflict detected — another process is using a required port.
+` + "Check ports 9944, 8088, and 6300, then try again.");
+      }
+    }
+    throw err;
+  }
+  const services = getServiceStatus();
+  if (jsonMode) {
+    writeJsonResult({
+      subcommand: "up",
+      services: services.map((s) => ({ name: s.name, state: s.state, port: s.port, health: s.health }))
+    });
+    return;
+  }
+  if (services.length > 0) {
+    process.stderr.write(`
+` + formatServiceTable(services) + `
+`);
+  }
+  for (const svc of services) {
+    process.stdout.write(`${svc.name}=${svc.state}:${svc.port}
+`);
+  }
+  process.stderr.write(`
+` + dim("  Next: ") + bold("midnight generate --network undeployed") + `
+`);
+}
+async function handleStop(jsonMode) {
+  const spinner = start("Stopping local network...");
+  try {
+    dockerCompose("stop");
+    spinner.stop("Local network stopped (containers preserved)");
+    if (jsonMode) {
+      writeJsonResult({ subcommand: "stop", status: "stopped" });
+      return;
+    }
+  } catch (err) {
+    spinner.stop(red("Failed to stop local network"));
+    throw err;
+  }
+}
+async function handleDown(jsonMode) {
+  const spinner = start("Tearing down local network...");
+  try {
+    dockerCompose("down --volumes");
+    spinner.stop("Local network removed (containers, networks, volumes)");
+    if (jsonMode) {
+      writeJsonResult({ subcommand: "down", status: "removed" });
+      return;
+    }
+  } catch (err) {
+    spinner.stop(red("Failed to tear down local network"));
+    throw err;
+  }
+}
+async function handleStatus(jsonMode) {
+  const services = getServiceStatus();
+  if (jsonMode) {
+    writeJsonResult({
+      subcommand: "status",
+      services: services.map((s) => ({ name: s.name, state: s.state, port: s.port, health: s.health }))
+    });
+    return;
+  }
+  if (services.length === 0) {
+    process.stderr.write(`
+` + header("Localnet Status") + `
+
+`);
+    process.stderr.write(dim("  No services running.") + `
+`);
+    process.stderr.write(dim("  Run ") + bold("midnight localnet up") + dim(" to start.") + `
+
+`);
+    return;
+  }
+  process.stderr.write(`
+` + header("Localnet Status") + `
+
+`);
+  process.stderr.write(formatServiceTable(services) + `
+`);
+  process.stderr.write(`
+` + divider() + `
+
+`);
+  for (const svc of services) {
+    process.stdout.write(`${svc.name}=${svc.state}:${svc.port}
+`);
+  }
+}
+async function handleClean(jsonMode) {
+  const spinner = start("Removing conflicting containers...");
+  try {
+    try {
+      dockerCompose("down");
+    } catch {
+    }
+    const removed = removeConflictingContainers();
+    if (removed.length > 0) {
+      spinner.stop(`Removed ${removed.length} container${removed.length > 1 ? "s" : ""}: ${removed.join(", ")}`);
+    } else {
+      spinner.stop("No conflicting containers found");
+    }
+    if (jsonMode) {
+      writeJsonResult({ subcommand: "clean", status: "cleaned", removed });
+      return;
+    }
+  } catch (err) {
+    spinner.stop(red("Failed to clean up"));
+    throw err;
+  }
+}
+async function handleLogs() {
+  const composePath = getComposePath();
+  const child = spawn("docker", ["compose", "-f", composePath, "logs", "-f"], {
+    stdio: "inherit"
+  });
+  return new Promise((resolve4, reject) => {
+    child.on("close", (code) => {
+      if (code === 0 || code === 130 || code === null) {
+        resolve4();
+      } else {
+        reject(new Error(`docker compose logs exited with code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+async function localnetCommand(args) {
+  const subcommand = args.subcommand;
+  if (!subcommand || !isValidSubcommand(subcommand)) {
+    throw new Error(`Usage: midnight localnet <${VALID_SUBCOMMANDS.join("|")}>
+
+` + `Subcommands:
+` + `  up        Start the local network
+` + `  stop      Stop containers (preserves state)
+` + `  down      Remove containers, networks, volumes
+` + `  status    Show service status
+` + `  logs      Stream service logs
+` + `  clean     Remove conflicting containers
+
+` + `Example: midnight localnet up`);
+  }
+  checkDockerAvailable();
+  const jsonMode = hasFlag(args, "json");
+  process.stderr.write(`
+` + header("Localnet") + `
+
+`);
+  switch (subcommand) {
+    case "up":
+      return handleUp(jsonMode);
+    case "stop":
+      return handleStop(jsonMode);
+    case "down":
+      return handleDown(jsonMode);
+    case "status":
+      return handleStatus(jsonMode);
+    case "logs":
+      return handleLogs();
+    case "clean":
+      return handleClean(jsonMode);
+  }
+}
+var VALID_SUBCOMMANDS;
+var init_localnet2 = __esm(() => {
+  init_localnet();
+  init_format();
+  init_spinner();
+  VALID_SUBCOMMANDS = ["up", "stop", "down", "status", "logs", "clean"];
+});
+
+// src/mcp-server.ts
+var exports_mcp_server = {};
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { createRequire } from "node:module";
+function buildArgs(command, params, subcommand) {
+  const flags = { json: true };
+  const positionals = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined || value === null)
+      continue;
+    if (typeof value === "boolean") {
+      if (value)
+        flags[key] = true;
+    } else {
+      flags[key] = String(value);
+    }
+  }
+  return {
+    command,
+    subcommand,
+    positionals,
+    flags
+  };
+}
+async function importHandler(name) {
+  const loader = handlerLoaders[name];
+  if (!loader)
+    throw new Error(`Unknown command handler: ${name}`);
+  const mod = await loader();
+  return mod.default;
+}
+async function main() {
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+}
+var require2, pkg, handlerLoaders, TOOLS, server;
+var init_mcp_server = __esm(() => {
+  init_run_command();
+  init_exit_codes();
+  require2 = createRequire(import.meta.url);
+  pkg = require2("../package.json");
+  handlerLoaders = {
+    generate: () => Promise.resolve().then(() => (init_generate(), exports_generate)),
+    info: () => Promise.resolve().then(() => (init_info(), exports_info)),
+    balance: () => Promise.resolve().then(() => (init_balance(), exports_balance)),
+    address: () => Promise.resolve().then(() => (init_address(), exports_address)),
+    "genesis-address": () => Promise.resolve().then(() => (init_genesis_address(), exports_genesis_address)),
+    "inspect-cost": () => Promise.resolve().then(() => (init_inspect_cost(), exports_inspect_cost)),
+    airdrop: () => Promise.resolve().then(() => (init_airdrop(), exports_airdrop)),
+    transfer: () => Promise.resolve().then(() => (init_transfer2(), exports_transfer)),
+    dust: () => Promise.resolve().then(() => (init_dust(), exports_dust)),
+    config: () => Promise.resolve().then(() => (init_config(), exports_config)),
+    localnet: () => Promise.resolve().then(() => (init_localnet2(), exports_localnet))
+  };
+  TOOLS = [
+    {
+      name: "midnight_generate",
+      description: "Generate a new wallet (random mnemonic, or restore from seed/mnemonic)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          network: { type: "string", description: "Network: preprod, preview, undeployed", enum: ["preprod", "preview", "undeployed"] },
+          seed: { type: "string", description: "Restore from existing seed (64-char hex)" },
+          mnemonic: { type: "string", description: "Restore from BIP-39 mnemonic (24 words)" },
+          output: { type: "string", description: "Custom output path (default: ~/.midnight/wallet.json)" },
+          force: { type: "string", description: 'Set to "true" to overwrite existing wallet file' }
+        }
+      },
+      async handler(params) {
+        const args = buildArgs("generate", params);
+        if (params.force === "true" || params.force === true)
+          args.flags.force = true;
+        const handler = await importHandler("generate");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_info",
+      description: "Display wallet address, network, creation date (no secrets shown)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          wallet: { type: "string", description: "Custom wallet file path" }
+        }
+      },
+      async handler(params) {
+        const args = buildArgs("info", params);
+        const handler = await importHandler("info");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_balance",
+      description: "Check unshielded balance via indexer subscription",
+      inputSchema: {
+        type: "object",
+        properties: {
+          address: { type: "string", description: "Address to check (or reads from wallet file)" },
+          wallet: { type: "string", description: "Custom wallet file path" },
+          network: { type: "string", description: "Override network detection", enum: ["preprod", "preview", "undeployed"] },
+          "indexer-ws": { type: "string", description: "Custom indexer WebSocket URL" }
+        }
+      },
+      async handler(params) {
+        const address = params.address;
+        const args = buildArgs("balance", params, address);
+        delete args.flags.address;
+        const handler = await importHandler("balance");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_address",
+      description: "Derive and display an unshielded address from a seed",
+      inputSchema: {
+        type: "object",
+        properties: {
+          seed: { type: "string", description: "Seed to derive from (required, 64-char hex)" },
+          network: { type: "string", description: "Network for address prefix", enum: ["preprod", "preview", "undeployed"] },
+          index: { type: "string", description: "Key derivation index (default: 0)" }
+        },
+        required: ["seed"]
+      },
+      async handler(params) {
+        const args = buildArgs("address", params);
+        const handler = await importHandler("address");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_genesis_address",
+      description: "Display the genesis wallet address (seed 0x01) for a network",
+      inputSchema: {
+        type: "object",
+        properties: {
+          network: { type: "string", description: "Network for address prefix", enum: ["preprod", "preview", "undeployed"] }
+        }
+      },
+      async handler(params) {
+        const args = buildArgs("genesis-address", params);
+        const handler = await importHandler("genesis-address");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_inspect_cost",
+      description: "Display current block limits derived from LedgerParameters",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      async handler() {
+        const args = buildArgs("inspect-cost", {});
+        const handler = await importHandler("inspect-cost");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_airdrop",
+      description: "Fund your wallet from the genesis wallet (undeployed network only)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          amount: { type: "string", description: "Amount in NIGHT to airdrop" },
+          wallet: { type: "string", description: "Custom wallet file path" }
+        },
+        required: ["amount"]
+      },
+      async handler(params) {
+        const amount = params.amount;
+        const args = buildArgs("airdrop", params, amount);
+        delete args.flags.amount;
+        const handler = await importHandler("airdrop");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_transfer",
+      description: "Send NIGHT tokens to another address",
+      inputSchema: {
+        type: "object",
+        properties: {
+          to: { type: "string", description: "Recipient bech32m address" },
+          amount: { type: "string", description: "Amount in NIGHT to send" },
+          wallet: { type: "string", description: "Custom wallet file path" }
+        },
+        required: ["to", "amount"]
+      },
+      async handler(params) {
+        const to = params.to;
+        const amount = params.amount;
+        const args = buildArgs("transfer", params, to);
+        args.positionals = [amount];
+        delete args.flags.to;
+        delete args.flags.amount;
+        const handler = await importHandler("transfer");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_dust_register",
+      description: "Register NIGHT UTXOs for dust (fee token) generation",
+      inputSchema: {
+        type: "object",
+        properties: {
+          wallet: { type: "string", description: "Custom wallet file path" }
+        }
+      },
+      async handler(params) {
+        const args = buildArgs("dust", params, "register");
+        const handler = await importHandler("dust");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_dust_status",
+      description: "Check dust registration status and balance",
+      inputSchema: {
+        type: "object",
+        properties: {
+          wallet: { type: "string", description: "Custom wallet file path" }
+        }
+      },
+      async handler(params) {
+        const args = buildArgs("dust", params, "status");
+        const handler = await importHandler("dust");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_config_get",
+      description: "Read a persistent config value",
+      inputSchema: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: 'Config key to read (e.g. "network")' }
+        },
+        required: ["key"]
+      },
+      async handler(params) {
+        const key = params.key;
+        const args = {
+          command: "config",
+          subcommand: "get",
+          positionals: [key],
+          flags: { json: true }
+        };
+        const handler = await importHandler("config");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_config_set",
+      description: "Write a persistent config value",
+      inputSchema: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: 'Config key to set (e.g. "network")' },
+          value: { type: "string", description: "Config value to set" }
+        },
+        required: ["key", "value"]
+      },
+      async handler(params) {
+        const key = params.key;
+        const value = params.value;
+        const args = {
+          command: "config",
+          subcommand: "set",
+          positionals: [key, value],
+          flags: { json: true }
+        };
+        const handler = await importHandler("config");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_localnet_up",
+      description: "Start a local Midnight network via Docker Compose",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      async handler() {
+        const args = {
+          command: "localnet",
+          subcommand: "up",
+          positionals: [],
+          flags: { json: true }
+        };
+        const handler = await importHandler("localnet");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_localnet_stop",
+      description: "Stop local network containers (preserves state for fast restart)",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      async handler() {
+        const args = {
+          command: "localnet",
+          subcommand: "stop",
+          positionals: [],
+          flags: { json: true }
+        };
+        const handler = await importHandler("localnet");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_localnet_down",
+      description: "Remove local network containers, networks, and volumes (full teardown)",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      async handler() {
+        const args = {
+          command: "localnet",
+          subcommand: "down",
+          positionals: [],
+          flags: { json: true }
+        };
+        const handler = await importHandler("localnet");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_localnet_status",
+      description: "Show local network service status and ports",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      async handler() {
+        const args = {
+          command: "localnet",
+          subcommand: "status",
+          positionals: [],
+          flags: { json: true }
+        };
+        const handler = await importHandler("localnet");
+        return captureCommand(handler, args);
+      }
+    },
+    {
+      name: "midnight_localnet_clean",
+      description: "Remove conflicting containers from other setups",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      async handler() {
+        const args = {
+          command: "localnet",
+          subcommand: "clean",
+          positionals: [],
+          flags: { json: true }
+        };
+        const handler = await importHandler("localnet");
+        return captureCommand(handler, args);
+      }
+    }
+  ];
+  server = new Server({ name: "midnight-wallet-cli", version: pkg.version }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: TOOLS.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema
+      }))
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: params } = request.params;
+    const tool = TOOLS.find((t) => t.name === name);
+    if (!tool) {
+      return {
+        content: [{ type: "text", text: `Unknown tool: ${name}` }],
+        isError: true
+      };
+    }
+    try {
+      const result = await tool.handler(params ?? {});
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const { errorCode } = classifyError(error);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: true, code: errorCode, message: error.message })
+        }],
+        isError: true
+      };
+    }
+  });
+  main().catch((err) => {
+    process.stderr.write(`MCP server error: ${err.message}
+`);
+    process.exit(1);
+  });
+});
+
+// src/ui/art.ts
+function noiseChar(row, col, seed) {
+  const hash = (row * 131 + col * 997 + seed * 7919) % 65537 / 65537;
+  return NOISE_CHARS[Math.floor(hash * NOISE_CHARS.length)];
+}
+function getMaterializeFrame(progress) {
+  const clamped = Math.max(0, Math.min(1, progress));
+  const lines = MIDNIGHT_LOGO.split(`
+`);
+  const seed = Math.floor(progress * 100);
+  if (clamped >= 1)
+    return MIDNIGHT_LOGO;
+  if (clamped <= 0) {
+    return lines.map((line, row) => Array.from(line).map((_, col) => noiseChar(row, col, 0)).join("")).join(`
+`);
+  }
+  return lines.map((line, row) => Array.from(line).map((ch, col) => {
+    if (ch === " ")
+      return " ";
+    const threshold = (row * 131 + col * 997) % 100 / 100;
+    return clamped >= threshold ? ch : noiseChar(row, col, seed);
+  }).join("")).join(`
+`);
+}
+function getWordmarkFrame(progress) {
+  const clamped = Math.max(0, Math.min(1, progress));
+  const visibleChars = Math.floor(clamped * WORDMARK.length);
+  return WORDMARK.slice(0, visibleChars);
+}
+var MIDNIGHT_LOGO, WORDMARK = "m i d n i g h t", COMMAND_BRIEFS, NOISE_CHARS;
+var init_art = __esm(() => {
+  MIDNIGHT_LOGO = [
+    "        ██████████████        ",
+    "      ██              ██      ",
+    "    ██      ██████      ██    ",
+    "   ██       ██████       ██   ",
+    "   ██                    ██   ",
+    "   ██       ██████       ██   ",
+    "   ██       ██████       ██   ",
+    "    ██                  ██    ",
+    "      ██              ██      ",
+    "        ██████████████        "
+  ].join(`
+`);
+  COMMAND_BRIEFS = [
+    ["generate", "Generate or restore a wallet"],
+    ["info", "Display wallet metadata"],
+    ["balance", "Check unshielded balance"],
+    ["address", "Derive address from seed"],
+    ["genesis-address", "Show genesis address"],
+    ["inspect-cost", "Display block limits"],
+    ["airdrop", "Fund from genesis wallet"],
+    ["transfer", "Send NIGHT tokens"],
+    ["dust", "Manage dust (fee tokens)"],
+    ["config", "Manage CLI config"],
+    ["localnet", "Manage local network"],
+    ["help", "Show command usage"]
+  ];
+  NOISE_CHARS = ["░", "▒", "▓", "█", "·", " "];
+});
+
+// src/ui/animate.ts
+function sleep(ms, signal) {
+  return new Promise((resolve4, reject) => {
+    if (signal?.aborted) {
+      resolve4();
+      return;
+    }
+    const timer = setTimeout(resolve4, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      resolve4();
+    }, { once: true });
+  });
+}
+function writeLine(text) {
+  process.stderr.write(`\r${text}\x1B[K`);
+}
+async function animateMaterialize(signal, sideContent) {
+  const totalFrames = 20;
+  const logoLines = MIDNIGHT_LOGO.split(`
+`);
+  const logoLineCount = logoLines.length;
+  if (!isColorEnabled()) {
+    for (let j = 0;j < logoLineCount; j++) {
+      const left = logoLines[j].padEnd(30);
+      const right = sideContent?.[j] ?? "";
+      process.stderr.write((sideContent ? left + "    " + right : left) + `
+`);
+    }
+    const wordmarkLine = `       ${WORDMARK}`;
+    const footerSide2 = sideContent?.[logoLineCount] ?? "";
+    process.stderr.write((footerSide2 ? wordmarkLine.padEnd(34) + footerSide2 : wordmarkLine) + `
+`);
+    if (sideContent) {
+      for (let j = logoLineCount + 1;j < sideContent.length; j++) {
+        if (sideContent[j]) {
+          process.stderr.write(" ".repeat(34) + sideContent[j] + `
+`);
+        }
+      }
+    }
+    return;
+  }
+  for (let i = 0;i <= totalFrames; i++) {
+    if (signal?.aborted)
+      break;
+    const progress = i / totalFrames;
+    const frame = getMaterializeFrame(progress);
+    const frameLines = frame.split(`
+`);
+    if (i > 0) {
+      process.stderr.write(`\x1B[${logoLineCount}A`);
+    }
+    for (let j = 0;j < logoLineCount; j++) {
+      const left = teal(frameLines[j]);
+      const right = sideContent?.[j] ?? "";
+      const line = sideContent ? left + `\x1B[35G` + right : left;
+      process.stderr.write(line + `\x1B[K
+`);
+    }
+    await sleep(FRAME_MS, signal);
+  }
+  const wordmarkFrames = 15;
+  const footerSide = sideContent?.[logoLineCount] ?? "";
+  for (let i = 0;i <= wordmarkFrames; i++) {
+    if (signal?.aborted)
+      break;
+    const progress = i / wordmarkFrames;
+    const partial = getWordmarkFrame(progress);
+    if (footerSide) {
+      writeLine(`       ${bold(teal(partial))}\x1B[35G${footerSide}`);
+    } else {
+      writeLine(`       ${bold(teal(partial))}`);
+    }
+    await sleep(FRAME_MS, signal);
+  }
+  process.stderr.write(`
+`);
+  if (sideContent) {
+    for (let j = logoLineCount + 1;j < sideContent.length; j++) {
+      if (sideContent[j]) {
+        process.stderr.write(`\x1B[35G${sideContent[j]}\x1B[K
+`);
+      }
+    }
+  }
+}
+var FRAME_MS = 80;
+var init_animate = __esm(() => {
+  init_art();
+});
+
+// src/commands/help.ts
+var exports_help = {};
+__export(exports_help, {
+  default: () => helpCommand,
+  COMMAND_SPECS: () => COMMAND_SPECS
+});
+import { createRequire as createRequire2 } from "node:module";
+function buildSideContent() {
+  const lines = [];
+  lines.push(bold("Commands"));
+  for (const [name, brief] of COMMAND_BRIEFS) {
+    lines.push(`${teal(name.padEnd(18))}${brief}`);
+  }
+  lines.push("");
+  lines.push(dim(`midnight (or mn) help <command>`));
+  lines.push(dim(`--json flag available on all commands`));
+  lines.push(dim(`midnight help --agent`) + dim(`  AI & MCP reference`));
+  return lines;
+}
+function printPlainHelp() {
+  process.stderr.write(`
+Commands:
+
+`);
+  for (const [name, brief] of COMMAND_BRIEFS) {
+    process.stderr.write(`  ${name.padEnd(18)}${brief}
+`);
+  }
+  process.stderr.write(`
+  Usage: midnight <command> (or: mn <command>)
+`);
+  process.stderr.write(`  --json flag available on all commands
+`);
+  process.stderr.write(`  midnight help --agent   AI & MCP reference
+
+`);
+}
+function printCommandHelp(spec) {
+  process.stdout.write(`
+` + header(spec.name) + `
+
+`);
+  process.stdout.write(`  ${spec.description}
+
+`);
+  process.stdout.write(gray("Usage:") + `
+`);
+  process.stdout.write(`  ${spec.usage}
+
+`);
+  if (spec.flags && spec.flags.length > 0) {
+    process.stdout.write(gray("Flags:") + `
+`);
+    for (const flag of spec.flags) {
+      process.stdout.write(`  ${flag}
+`);
+    }
+    process.stdout.write(`
+`);
+  }
+  if (spec.examples && spec.examples.length > 0) {
+    process.stdout.write(gray("Examples:") + `
+`);
+    for (const example of spec.examples) {
+      process.stdout.write(`  ${dim("$")} ${example}
+`);
+    }
+    process.stdout.write(`
+`);
+  }
+}
+function outputJsonManifest() {
+  const require3 = createRequire2(import.meta.url);
+  const pkg2 = require3("../../package.json");
+  const manifest = {
+    cli: {
+      name: pkg2.name,
+      version: pkg2.version,
+      description: pkg2.description,
+      bin: ["midnight", "mn"]
+    },
+    globalFlags: [
+      { name: "--json", description: "Output structured JSON to stdout (suppresses all stderr)" },
+      { name: "--wallet <file>", description: "Custom wallet file path" },
+      { name: "--network <name>", description: "Override network (preprod, preview, undeployed)" },
+      { name: "--version, -v", description: "Print CLI version" },
+      { name: "--help, -h", description: "Show help" }
+    ],
+    commands: COMMAND_SPECS.map((spec) => ({
+      name: spec.name,
+      description: spec.description,
+      usage: spec.usage,
+      flags: spec.flags,
+      examples: spec.examples,
+      jsonFields: spec.jsonFields
+    }))
+  };
+  writeJsonResult(manifest);
+}
+function printAgentManual() {
+  const require3 = createRequire2(import.meta.url);
+  const pkg2 = require3("../../package.json");
+  const manual = `
+MIDNIGHT CLI — AI Agent & MCP Reference
+========================================
+
+Version: ${pkg2.version}
+
+STRUCTURED JSON OUTPUT
+──────────────────────
+
+Every command supports the --json flag. When passed:
+  - stdout receives a single line of JSON
+  - stderr is fully suppressed (no spinners, no formatting)
+  - Errors produce JSON: {"error":true,"code":"...","message":"...","exitCode":N}
+
+Usage: midnight <command> [args] --json
+
+CAPABILITY MANIFEST
+───────────────────
+
+  midnight help --json
+
+Outputs a machine-readable JSON manifest containing all commands,
+their flags, examples, and expected JSON output fields. Use this
+for programmatic discovery of CLI capabilities.
+
+COMMANDS & JSON SCHEMAS
+───────────────────────
+${COMMAND_SPECS.filter((s) => s.jsonFields).map((spec) => {
+    const fields = Object.entries(spec.jsonFields).map(([k, v]) => `    ${k.padEnd(20)}${v}`).join(`
+`);
+    return `
+  ${spec.name}
+  ${spec.usage}
+  JSON fields:
+${fields}`;
+  }).join(`
+`)}
+
+ERROR CODES
+───────────
+
+When --json is active and an error occurs, the output is:
+  {"error":true,"code":"<CODE>","message":"...","exitCode":N}
+
+  Code                    Exit  Meaning
+  INVALID_ARGS            2     Missing or invalid arguments
+  WALLET_NOT_FOUND        3     Wallet file does not exist
+  NETWORK_ERROR           4     Connection refused, timeout, DNS failure
+  INSUFFICIENT_BALANCE    5     Not enough NIGHT for the operation
+  TX_REJECTED             6     Transaction rejected by the node
+  STALE_UTXO              6     UTXOs consumed by another transaction
+  PROOF_TIMEOUT           6     ZK proof generation timed out
+  DUST_REQUIRED           5     No dust tokens available for fees
+  CANCELLED               7     Operation cancelled (SIGINT)
+  UNKNOWN                 1     Unclassified error
+
+EXIT CODES
+──────────
+
+  0   Success
+  1   General error
+  2   Invalid arguments / usage
+  3   Wallet not found
+  4   Network / connection error
+  5   Insufficient balance
+  6   Transaction rejected
+  7   Operation cancelled (SIGINT)
+
+MCP SERVER
+──────────
+
+The CLI includes an MCP (Model Context Protocol) server for native
+AI agent integration. Instead of parsing CLI output, agents call
+typed tools directly via JSON-RPC over stdio.
+
+Add to your MCP config (.mcp.json, .cursor/mcp.json, etc.):
+
+  {
+    "mcpServers": {
+      "midnight-wallet": {
+        "command": "npx",
+        "args": ["-y", "midnight-wallet-cli@latest", "--mcp"]
+      }
+    }
+  }
+
+Or if installed globally: "command": "midnight-wallet-mcp"
+
+The MCP server exposes 17 tools covering all CLI commands
+(excluding help and localnet logs which are not suitable for MCP).
+
+EXAMPLE WORKFLOW
+────────────────
+
+  # 1. Generate a wallet
+  midnight generate --network undeployed --json
+  # → {"address":"mn_addr_...","network":"undeployed","seed":"...","mnemonic":"...","file":"...","createdAt":"..."}
+
+  # 2. Check balance
+  midnight balance --json
+  # → {"address":"mn_addr_...","network":"undeployed","balances":{},"utxoCount":0,"txCount":0}
+
+  # 3. Airdrop tokens (undeployed network)
+  midnight airdrop 1000 --json
+  # → {"txHash":"...","amount":"1000","recipient":"mn_addr_...","network":"undeployed"}
+
+  # 4. Transfer tokens
+  midnight transfer mn_addr_... 100 --json
+  # → {"txHash":"...","amount":"100","recipient":"mn_addr_...","network":"undeployed"}
+`;
+  process.stdout.write(manual);
+}
+async function helpCommand(args) {
+  if (hasFlag(args, "agent")) {
+    printAgentManual();
+    return;
+  }
+  if (hasFlag(args, "json")) {
+    outputJsonManifest();
+    return;
+  }
+  const targetCommand = args.subcommand;
+  if (targetCommand) {
+    const spec = COMMAND_SPECS.find((s) => s.name === targetCommand);
+    if (!spec) {
+      throw new Error(`Unknown command: "${targetCommand}"
+` + `Available commands: ${COMMAND_SPECS.map((s) => s.name).join(", ")}`);
+    }
+    printCommandHelp(spec);
+    return;
+  }
+  if (!process.stderr.isTTY) {
+    printPlainHelp();
+    return;
+  }
+  const sideContent = buildSideContent();
+  await animateMaterialize(undefined, sideContent);
+}
+var COMMAND_SPECS;
+var init_help = __esm(() => {
+  init_format();
+  init_animate();
+  init_art();
+  COMMAND_SPECS = [
+    {
+      name: "generate",
+      description: "Generate a new wallet (random mnemonic, or restore from seed/mnemonic)",
+      usage: 'midnight generate [--network <name>] [--seed <hex>] [--mnemonic "..."] [--output <file>] [--force]',
+      flags: [
+        "--network <name>    Network: preprod, preview, undeployed",
+        "--seed <hex>        Restore from existing seed (64-char hex)",
+        '--mnemonic "..."    Restore from BIP-39 mnemonic (24 words)',
+        "--output <file>     Custom output path (default: ~/.midnight/wallet.json)",
+        "--force             Overwrite existing wallet file"
+      ],
+      examples: [
+        "midnight generate --network preprod",
+        "midnight generate --network preprod --output my-wallet.json",
+        "midnight generate --seed 0123456789abcdef..."
+      ],
+      jsonFields: {
+        address: "Generated wallet address (bech32m)",
+        network: "Network name",
+        seed: "Hex-encoded 32-byte seed",
+        mnemonic: "BIP-39 mnemonic (24 words, only if generated or provided)",
+        file: "Path where wallet file was saved",
+        createdAt: "ISO 8601 creation timestamp"
+      }
+    },
+    {
+      name: "info",
+      description: "Display wallet address, network, creation date (no secrets shown)",
+      usage: "midnight info [--wallet <file>]",
+      flags: [
+        "--wallet <file>     Custom wallet file path"
+      ],
+      examples: [
+        "midnight info",
+        "midnight info --wallet my-wallet.json"
+      ],
+      jsonFields: {
+        address: "Wallet address (bech32m)",
+        network: "Network name",
+        createdAt: "ISO 8601 creation timestamp",
+        file: "Wallet file path"
+      }
+    },
+    {
+      name: "balance",
+      description: "Check unshielded balance via GraphQL subscription",
+      usage: "midnight balance [address] [--network <name>] [--indexer-ws <url>]",
+      flags: [
+        "<address>           Address to check (or reads from wallet file)",
+        "--network <name>    Override network detection",
+        "--indexer-ws <url>  Custom indexer WebSocket URL"
+      ],
+      examples: [
+        "midnight balance",
+        "midnight balance mn_addr_preprod1...",
+        "midnight balance --network preprod"
+      ],
+      jsonFields: {
+        address: "Checked address (bech32m)",
+        network: "Network name",
+        balances: "Object mapping token type to balance string",
+        utxoCount: "Number of UTXOs",
+        txCount: "Number of transactions synced"
+      }
+    },
+    {
+      name: "address",
+      description: "Derive and display an unshielded address from a seed",
+      usage: "midnight address --seed <hex> [--network <name>] [--index <n>]",
+      flags: [
+        "--seed <hex>        Seed to derive from (required, 64-char hex)",
+        "--network <name>    Network for address prefix (default: resolved)",
+        "--index <n>         Key derivation index (default: 0)"
+      ],
+      examples: [
+        "midnight address --seed 0123456789abcdef... --network preprod",
+        "midnight address --seed 0123456789abcdef... --index 1"
+      ],
+      jsonFields: {
+        address: "Derived address (bech32m)",
+        network: "Network name",
+        index: "Key derivation index",
+        path: "BIP-44 derivation path"
+      }
+    },
+    {
+      name: "genesis-address",
+      description: "Display the genesis wallet address (seed 0x01) for a network",
+      usage: "midnight genesis-address [--network <name>]",
+      flags: [
+        "--network <name>    Network for address prefix (default: resolved)"
+      ],
+      examples: [
+        "midnight genesis-address --network undeployed",
+        "midnight genesis-address --network preprod"
+      ],
+      jsonFields: {
+        address: "Genesis wallet address (bech32m)",
+        network: "Network name"
+      }
+    },
+    {
+      name: "inspect-cost",
+      description: "Display current block limits derived from LedgerParameters",
+      usage: "midnight inspect-cost",
+      examples: [
+        "midnight inspect-cost"
+      ],
+      jsonFields: {
+        readTime: "Read time limit (picoseconds)",
+        computeTime: "Compute time limit (picoseconds)",
+        blockUsage: "Block usage limit (bytes)",
+        bytesWritten: "Bytes written limit (bytes)",
+        bytesChurned: "Bytes churned limit (bytes)"
+      }
+    },
+    {
+      name: "airdrop",
+      description: "Fund your wallet from the genesis wallet (undeployed network only)",
+      usage: "midnight airdrop <amount> [--wallet <file>]",
+      flags: [
+        "<amount>            Amount in NIGHT to airdrop",
+        "--wallet <file>     Custom wallet file path"
+      ],
+      examples: [
+        "midnight airdrop 1000",
+        "midnight airdrop 0.5 --wallet my-wallet.json"
+      ],
+      jsonFields: {
+        txHash: "Transaction hash",
+        amount: "Amount airdropped (NIGHT string)",
+        recipient: "Recipient address (bech32m)",
+        network: "Network name"
+      }
+    },
+    {
+      name: "transfer",
+      description: "Send NIGHT tokens to another address",
+      usage: "midnight transfer <to> <amount> [--wallet <file>]",
+      flags: [
+        "<to>                Recipient bech32m address",
+        "<amount>            Amount in NIGHT to send",
+        "--wallet <file>     Custom wallet file path"
+      ],
+      examples: [
+        "midnight transfer mn_addr_undeployed1... 100",
+        "midnight transfer mn_addr_preprod1... 50 --wallet my-wallet.json"
+      ],
+      jsonFields: {
+        txHash: "Transaction hash",
+        amount: "Amount transferred (NIGHT string)",
+        recipient: "Recipient address (bech32m)",
+        network: "Network name"
+      }
+    },
+    {
+      name: "dust",
+      description: "Register UTXOs for dust (fee token) generation or check status",
+      usage: "midnight dust <register|status> [--wallet <file>]",
+      flags: [
+        "register            Register NIGHT UTXOs for dust generation",
+        "status              Check dust registration status and balance",
+        "--wallet <file>     Custom wallet file path"
+      ],
+      examples: [
+        "midnight dust register",
+        "midnight dust status"
+      ],
+      jsonFields: {
+        subcommand: "register or status",
+        dustBalance: "Dust balance (raw bigint string)",
+        registered: "Number of registered UTXOs (status only)",
+        unregistered: "Number of unregistered UTXOs (status only)",
+        nightBalance: "NIGHT balance (raw bigint string, status only)",
+        dustAvailable: "Whether dust tokens are available (status only)",
+        txHash: "Registration transaction hash (register only, if submitted)"
+      }
+    },
+    {
+      name: "config",
+      description: "Manage persistent config (default network, etc.)",
+      usage: "midnight config <get|set> <key> [value]",
+      flags: [
+        "get <key>           Read a config value",
+        "set <key> <value>   Write a config value"
+      ],
+      examples: [
+        "midnight config get network",
+        "midnight config set network preprod"
+      ],
+      jsonFields: {
+        action: "get or set",
+        key: "Config key name",
+        value: "Config value"
+      }
+    },
+    {
+      name: "localnet",
+      description: "Manage a local Midnight network via Docker Compose",
+      usage: "midnight localnet <up|stop|down|status|logs|clean>",
+      flags: [
+        "up              Start the local network (node, indexer, proof server)",
+        "stop            Stop containers (preserves state for fast restart)",
+        "down            Remove containers, networks, and volumes (full teardown)",
+        "status          Show service status and ports",
+        "logs            Stream service logs (Ctrl+C to stop)",
+        "clean           Remove conflicting containers from other setups"
+      ],
+      examples: [
+        "midnight localnet up",
+        "midnight localnet stop",
+        "midnight localnet status",
+        "midnight localnet down",
+        "midnight localnet clean"
+      ],
+      jsonFields: {
+        subcommand: "up, stop, down, status, or clean",
+        services: "Array of { name, state, port, health? } (up/status only)",
+        status: "Operation result message (stop/down/clean)",
+        removed: "Array of removed container names (clean only)"
+      }
+    },
+    {
+      name: "help",
+      description: "Show usage for all commands or a specific command",
+      usage: "midnight help [command]",
+      examples: [
+        "midnight help",
+        "midnight help balance"
+      ],
+      jsonFields: {
+        cli: "CLI metadata (name, version, description)",
+        globalFlags: "Array of global flag descriptions",
+        commands: "Array of command specs with jsonFields"
+      }
+    }
+  ];
+});
+
+// src/wallet.ts
+init_format();
+init_exit_codes();
+import { createRequire as createRequire3 } from "node:module";
+if (process.argv.includes("--mcp")) {
+  await Promise.resolve().then(() => (init_mcp_server(), exports_mcp_server));
+} else {
+  let handleShutdown = function() {
+    abortController.abort();
+    setTimeout(() => process.exit(130), 5000).unref();
+  };
+  const args = parseArgs();
+  const jsonMode = hasFlag(args, "json");
+  if (hasFlag(args, "version") || hasFlag(args, "v")) {
+    const require3 = createRequire3(import.meta.url);
+    const { version } = require3("../package.json");
+    process.stdout.write(version + `
+`);
+    process.exit(0);
+  }
+  if (hasFlag(args, "help") || hasFlag(args, "h")) {
+    args.command = "help";
+  }
+  const command = args.command ?? "help";
+  let restoreStderr;
+  if (jsonMode) {
+    restoreStderr = suppressStderr();
+  }
+  const abortController = new AbortController;
+  const { signal } = abortController;
+  process.on("SIGINT", handleShutdown);
+  process.on("SIGTERM", handleShutdown);
+  async function run() {
+    switch (command) {
+      case "help": {
+        const { default: handler } = await Promise.resolve().then(() => (init_help(), exports_help));
+        return handler(args);
+      }
+      case "generate": {
+        const { default: handler } = await Promise.resolve().then(() => (init_generate(), exports_generate));
+        return handler(args);
+      }
+      case "info": {
+        const { default: handler } = await Promise.resolve().then(() => (init_info(), exports_info));
+        return handler(args);
+      }
+      case "balance": {
+        const { default: handler } = await Promise.resolve().then(() => (init_balance(), exports_balance));
+        return handler(args);
+      }
+      case "address": {
+        const { default: handler } = await Promise.resolve().then(() => (init_address(), exports_address));
+        return handler(args);
+      }
+      case "genesis-address": {
+        const { default: handler } = await Promise.resolve().then(() => (init_genesis_address(), exports_genesis_address));
+        return handler(args);
+      }
+      case "inspect-cost": {
+        const { default: handler } = await Promise.resolve().then(() => (init_inspect_cost(), exports_inspect_cost));
+        return handler(args);
+      }
+      case "config": {
+        const { default: handler } = await Promise.resolve().then(() => (init_config(), exports_config));
+        return handler(args);
+      }
+      case "airdrop": {
+        const { default: handler } = await Promise.resolve().then(() => (init_airdrop(), exports_airdrop));
+        return handler(args, signal);
+      }
+      case "transfer": {
+        const { default: handler } = await Promise.resolve().then(() => (init_transfer2(), exports_transfer));
+        return handler(args, signal);
+      }
+      case "dust": {
+        const { default: handler } = await Promise.resolve().then(() => (init_dust(), exports_dust));
+        return handler(args, signal);
+      }
+      case "localnet": {
+        const { default: handler } = await Promise.resolve().then(() => (init_localnet2(), exports_localnet));
+        return handler(args);
+      }
+      default:
+        throw new Error(`Unknown command: "${command}"
+Run "midnight help" to see available commands.`);
+    }
+  }
+  const FACADE_COMMANDS = new Set(["airdrop", "transfer", "dust"]);
+  run().then(() => {
+    if (FACADE_COMMANDS.has(command)) {
+      process.exit(0);
+    }
+  }).catch((err) => {
+    if (jsonMode) {
+      restoreStderr?.();
+      const { exitCode, errorCode } = classifyError(err);
+      writeJsonError(err, errorCode, exitCode);
+      process.exit(exitCode);
+    } else {
+      process.stderr.write(`
+` + errorBox(err.message, 'Run "midnight help" for usage information.') + `
+
+`);
+      const { exitCode } = classifyError(err);
+      process.exit(exitCode);
+    }
+  });
+}