midnight-wallet-cli 0.1.0

package/dist/mcp-server.js

@@ -0,0 +1,2693 @@
+#!/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/json-output.ts
+function setCaptureTarget(fn) {
+  captureTarget = fn;
+}
+function writeJsonResult(data) {
+  const json = JSON.stringify(data) + `
+`;
+  if (captureTarget) {
+    captureTarget(json);
+  } else {
+    process.stdout.write(json);
+  }
+}
+var captureTarget = null;
+
+// src/lib/argv.ts
+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/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/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/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/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 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;
+var init_format = () => {
+};
+
+// 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
+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";
+
+// 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;
+  }
+}
+
+// src/lib/exit-codes.ts
+var EXIT_GENERAL_ERROR = 1;
+var EXIT_INVALID_ARGS = 2;
+var EXIT_WALLET_NOT_FOUND = 3;
+var EXIT_NETWORK_ERROR = 4;
+var EXIT_INSUFFICIENT_BALANCE = 5;
+var EXIT_TX_REJECTED = 6;
+var EXIT_CANCELLED = 7;
+var 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"
+};
+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 };
+}
+
+// src/mcp-server.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+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
+  };
+}
+var 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))
+};
+async function importHandler(name) {
+  const loader = handlerLoaders[name];
+  if (!loader)
+    throw new Error(`Unknown command handler: ${name}`);
+  const mod = await loader();
+  return mod.default;
+}
+var 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);
+    }
+  }
+];
+var 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
+    };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+}
+main().catch((err) => {
+  process.stderr.write(`MCP server error: ${err.message}
+`);
+  process.exit(1);
+});