midnight-wallet-cli 0.1.5 → 0.1.7

package/dist/mcp-server.js

@@ -172,7 +172,7 @@ var init_network = __esm(() => {
 });
 
 // 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";
+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, DUST_REGISTRATION_TIMEOUT_MS = 600000, DUST_REGISTRATION_RETRY_DELAY_MS = 15000, 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";
@@ -1243,27 +1243,98 @@ function validateRecipientAddress(address, networkConfig) {
 ` + `Expected a bech32m address for network "${networkConfig.networkId}"`);
   }
 }
+function isTransactionRejectedError(err) {
+  let current = err;
+  while (current) {
+    const msg = String(current?.message ?? "").toLowerCase();
+    if (msg.includes("submission error"))
+      return true;
+    if (msg.includes("transaction") && msg.includes("invalid"))
+      return true;
+    if (msg.includes("138"))
+      return true;
+    const tag = current?._tag;
+    if (tag === "TransactionInvalidError" || tag === "SubmissionError")
+      return true;
+    current = current.cause;
+  }
+  return false;
+}
+function formatElapsed(ms) {
+  const totalSeconds = Math.round(ms / 1000);
+  if (totalSeconds < 60)
+    return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${seconds}s`;
+}
+async function submitDustRegistration(bundle, dustUtxos, dustReceiverAddress) {
+  const ttl = new Date(Date.now() + TX_TTL_MINUTES * 60 * 1000);
+  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);
+  return await bundle.facade.submitTransaction(finalized);
+}
+async function registerNightUtxos(bundle, dustUtxos, dustReceiverAddress, onStatus) {
+  const startTime = Date.now();
+  const deadline = startTime + DUST_REGISTRATION_TIMEOUT_MS;
+  let lastError;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+  const hasRpcNoise = (args) => args.some((a) => String(a).includes("RPC-CORE"));
+  const suppressRpcNoise = () => {
+    console.warn = (...args) => {
+      if (hasRpcNoise(args))
+        return;
+      originalWarn(...args);
+    };
+    console.error = (...args) => {
+      if (hasRpcNoise(args))
+        return;
+      originalError(...args);
+    };
+  };
+  const restoreConsole = () => {
+    console.warn = originalWarn;
+    console.error = originalError;
+  };
+  suppressRpcNoise();
+  try {
+    while (Date.now() < deadline) {
+      try {
+        return await submitDustRegistration(bundle, dustUtxos, dustReceiverAddress);
+      } catch (err) {
+        lastError = err;
+        if (isTransactionRejectedError(err) && Date.now() + DUST_REGISTRATION_RETRY_DELAY_MS < deadline) {
+          const elapsed = formatElapsed(Date.now() - startTime);
+          onStatus?.(`Waiting for dust generation capacity (${elapsed} elapsed, ~5 min on fresh wallets)...`);
+          await new Promise((resolve4) => setTimeout(resolve4, DUST_REGISTRATION_RETRY_DELAY_MS));
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError ?? new Error("Dust registration timed out");
+  } finally {
+    restoreConsole();
+  }
+}
 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);
+    await registerNightUtxos(bundle, dustUtxos, state.dust.dustAddress, onDust);
   } else if (state.dust.availableCoins.length > 0) {
     onDust?.("Dust available");
     return;
@@ -1274,7 +1345,7 @@ async function ensureDust(bundle, onDust) {
   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) {
+async function buildAndSubmitTransfer(bundle, recipientAddress, amount, onProving, onSubmitting, onDust) {
   let lastError;
   for (let attempt = 1;attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
     try {
@@ -1311,6 +1382,12 @@ async function buildAndSubmitTransfer(bundle, recipientAddress, amount, onProvin
       if (isStaleUtxo && attempt < MAX_RETRY_ATTEMPTS) {
         continue;
       }
+      const isDustInsufficient = err?.message?.toLowerCase().includes("not enough dust") || err?.message?.toLowerCase().includes("dust generated");
+      if (isDustInsufficient && attempt < MAX_RETRY_ATTEMPTS) {
+        onDust?.("Waiting for more dust to accumulate...");
+        await new Promise((resolve4) => setTimeout(resolve4, DUST_REGISTRATION_RETRY_DELAY_MS));
+        continue;
+      }
       throw err;
     }
   }
@@ -1361,7 +1438,7 @@ async function executeTransfer(params) {
     await ensureDust(bundle, onDust);
     if (signal?.aborted)
       throw new Error("Operation cancelled");
-    const txHash = await buildAndSubmitTransfer(bundle, recipientAddress, amount, onProving, onSubmitting);
+    const txHash = await buildAndSubmitTransfer(bundle, recipientAddress, amount, onProving, onSubmitting, onDust);
     return { txHash, amountMicroNight: amount };
   } finally {
     signal?.removeEventListener("abort", onAbort);
@@ -1465,7 +1542,13 @@ async function airdropCommand(args, signal) {
     process.stderr.write(`
 ` + divider() + `
 `);
-    process.stderr.write(dim("  Verify: midnight balance") + `
+    process.stderr.write(dim("  Verify:         midnight balance") + `
+`);
+    process.stderr.write(dim("  Register dust:  midnight dust register") + `
+`);
+    process.stderr.write(dim("  Note: Dust generation takes a few minutes on a fresh wallet.") + `
+`);
+    process.stderr.write(dim("        It will happen automatically on your first transfer.") + `
 
 `);
   } catch (err) {
@@ -1684,22 +1767,13 @@ async function dustRegister(bundle, networkName, jsonMode, signal, warningRef) {
       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);
+      txHash = await registerNightUtxos(bundle, dustUtxos, state.dust.dustAddress, (status) => {
+        spinner.update(status);
+      });
       spinner.update(`Registration submitted (${txHash.slice(0, 12)}...), waiting for dust...`);
     }
     if (signal?.aborted)
@@ -1795,6 +1869,7 @@ var init_dust = __esm(() => {
   init_wallet_config();
   init_resolve_network();
   init_facade();
+  init_transfer();
   init_format();
   init_spinner();
 });
@@ -2218,7 +2293,6 @@ var init_localnet2 = __esm(() => {
 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) {
@@ -2290,10 +2364,62 @@ function classifyError(err) {
   }
   return { exitCode: EXIT_GENERAL_ERROR, errorCode: ERROR_CODES.UNKNOWN };
 }
+// package.json
+var package_default = {
+  name: "midnight-wallet-cli",
+  version: "0.1.7",
+  type: "module",
+  description: "Git-style CLI wallet for the Midnight blockchain",
+  license: "Apache-2.0",
+  bin: {
+    midnight: "dist/wallet.js",
+    mn: "dist/wallet.js",
+    "midnight-wallet-cli": "dist/wallet.js",
+    "midnight-wallet-mcp": "dist/mcp-server.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    wallet: "tsx src/wallet.ts",
+    build: 'bun build src/wallet.ts --outfile dist/wallet.js --target node --format esm --packages external --banner "#!/usr/bin/env node" && bun build src/mcp-server.ts --outfile dist/mcp-server.js --target node --format esm --packages external --banner "#!/usr/bin/env node"',
+    mcp: "tsx src/mcp-server.ts",
+    prepublishOnly: "npm run build && npm run test",
+    test: "vitest run",
+    "test:watch": "vitest",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    "@midnight-ntwrk/ledger-v7": "7.0.0",
+    "@midnight-ntwrk/midnight-js-network-id": "3.0.0",
+    "@midnight-ntwrk/midnight-js-types": "3.0.0",
+    "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0",
+    "@midnight-ntwrk/wallet-sdk-dust-wallet": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-facade": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-hd": "3.0.0",
+    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "1.0.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@scure/bip39": "^2.0.1",
+    rxjs: "^7.8.1",
+    ws: "^8.19.0"
+  },
+  devDependencies: {
+    "@types/node": "^22.19.13",
+    "@types/ws": "^8.18.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3",
+    vitest: "^3.2.4"
+  }
+};
+
+// src/lib/pkg.ts
+var PKG_NAME = package_default.name;
+var PKG_VERSION = package_default.version;
+var PKG_DESCRIPTION = package_default.description;
 
 // 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 = [];
@@ -2646,7 +2772,7 @@ var TOOLS = [
     }
   }
 ];
-var server = new Server({ name: "midnight-wallet-cli", version: pkg.version }, { capabilities: { tools: {} } });
+var server = new Server({ name: "midnight-wallet-cli", version: PKG_VERSION }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   return {
     tools: TOOLS.map((t) => ({

package/dist/wallet.js

@@ -69,7 +69,7 @@ function requireFlag(args, name, description) {
 }
 
 // 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";
+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, DUST_REGISTRATION_TIMEOUT_MS = 600000, DUST_REGISTRATION_RETRY_DELAY_MS = 15000, 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() {
@@ -310,6 +310,68 @@ function writeJsonError(err, errorCode, exitCode) {
 }
 var captureTarget = null;
 
+// package.json
+var package_default;
+var init_package = __esm(() => {
+  package_default = {
+    name: "midnight-wallet-cli",
+    version: "0.1.7",
+    type: "module",
+    description: "Git-style CLI wallet for the Midnight blockchain",
+    license: "Apache-2.0",
+    bin: {
+      midnight: "dist/wallet.js",
+      mn: "dist/wallet.js",
+      "midnight-wallet-cli": "dist/wallet.js",
+      "midnight-wallet-mcp": "dist/mcp-server.js"
+    },
+    files: [
+      "dist"
+    ],
+    scripts: {
+      wallet: "tsx src/wallet.ts",
+      build: 'bun build src/wallet.ts --outfile dist/wallet.js --target node --format esm --packages external --banner "#!/usr/bin/env node" && bun build src/mcp-server.ts --outfile dist/mcp-server.js --target node --format esm --packages external --banner "#!/usr/bin/env node"',
+      mcp: "tsx src/mcp-server.ts",
+      prepublishOnly: "npm run build && npm run test",
+      test: "vitest run",
+      "test:watch": "vitest",
+      typecheck: "tsc --noEmit"
+    },
+    dependencies: {
+      "@midnight-ntwrk/ledger-v7": "7.0.0",
+      "@midnight-ntwrk/midnight-js-network-id": "3.0.0",
+      "@midnight-ntwrk/midnight-js-types": "3.0.0",
+      "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0",
+      "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0",
+      "@midnight-ntwrk/wallet-sdk-dust-wallet": "1.0.0",
+      "@midnight-ntwrk/wallet-sdk-facade": "1.0.0",
+      "@midnight-ntwrk/wallet-sdk-hd": "3.0.0",
+      "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0",
+      "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "1.0.0",
+      "@modelcontextprotocol/sdk": "^1.27.1",
+      "@scure/bip39": "^2.0.1",
+      rxjs: "^7.8.1",
+      ws: "^8.19.0"
+    },
+    devDependencies: {
+      "@types/node": "^22.19.13",
+      "@types/ws": "^8.18.1",
+      tsx: "^4.21.0",
+      typescript: "^5.9.3",
+      vitest: "^3.2.4"
+    }
+  };
+});
+
+// src/lib/pkg.ts
+var PKG_NAME, PKG_VERSION, PKG_DESCRIPTION;
+var init_pkg = __esm(() => {
+  init_package();
+  PKG_NAME = package_default.name;
+  PKG_VERSION = package_default.version;
+  PKG_DESCRIPTION = package_default.description;
+});
+
 // src/lib/run-command.ts
 async function captureCommand(handler, args, signal) {
   const chunks = [];
@@ -1430,27 +1492,98 @@ function validateRecipientAddress(address, networkConfig) {
 ` + `Expected a bech32m address for network "${networkConfig.networkId}"`);
   }
 }
+function isTransactionRejectedError(err) {
+  let current = err;
+  while (current) {
+    const msg = String(current?.message ?? "").toLowerCase();
+    if (msg.includes("submission error"))
+      return true;
+    if (msg.includes("transaction") && msg.includes("invalid"))
+      return true;
+    if (msg.includes("138"))
+      return true;
+    const tag = current?._tag;
+    if (tag === "TransactionInvalidError" || tag === "SubmissionError")
+      return true;
+    current = current.cause;
+  }
+  return false;
+}
+function formatElapsed(ms) {
+  const totalSeconds = Math.round(ms / 1000);
+  if (totalSeconds < 60)
+    return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${seconds}s`;
+}
+async function submitDustRegistration(bundle, dustUtxos, dustReceiverAddress) {
+  const ttl = new Date(Date.now() + TX_TTL_MINUTES * 60 * 1000);
+  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);
+  return await bundle.facade.submitTransaction(finalized);
+}
+async function registerNightUtxos(bundle, dustUtxos, dustReceiverAddress, onStatus) {
+  const startTime = Date.now();
+  const deadline = startTime + DUST_REGISTRATION_TIMEOUT_MS;
+  let lastError;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+  const hasRpcNoise = (args) => args.some((a) => String(a).includes("RPC-CORE"));
+  const suppressRpcNoise = () => {
+    console.warn = (...args) => {
+      if (hasRpcNoise(args))
+        return;
+      originalWarn(...args);
+    };
+    console.error = (...args) => {
+      if (hasRpcNoise(args))
+        return;
+      originalError(...args);
+    };
+  };
+  const restoreConsole = () => {
+    console.warn = originalWarn;
+    console.error = originalError;
+  };
+  suppressRpcNoise();
+  try {
+    while (Date.now() < deadline) {
+      try {
+        return await submitDustRegistration(bundle, dustUtxos, dustReceiverAddress);
+      } catch (err) {
+        lastError = err;
+        if (isTransactionRejectedError(err) && Date.now() + DUST_REGISTRATION_RETRY_DELAY_MS < deadline) {
+          const elapsed = formatElapsed(Date.now() - startTime);
+          onStatus?.(`Waiting for dust generation capacity (${elapsed} elapsed, ~5 min on fresh wallets)...`);
+          await new Promise((resolve4) => setTimeout(resolve4, DUST_REGISTRATION_RETRY_DELAY_MS));
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError ?? new Error("Dust registration timed out");
+  } finally {
+    restoreConsole();
+  }
+}
 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);
+    await registerNightUtxos(bundle, dustUtxos, state.dust.dustAddress, onDust);
   } else if (state.dust.availableCoins.length > 0) {
     onDust?.("Dust available");
     return;
@@ -1461,7 +1594,7 @@ async function ensureDust(bundle, onDust) {
   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) {
+async function buildAndSubmitTransfer(bundle, recipientAddress, amount, onProving, onSubmitting, onDust) {
   let lastError;
   for (let attempt = 1;attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
     try {
@@ -1498,6 +1631,12 @@ async function buildAndSubmitTransfer(bundle, recipientAddress, amount, onProvin
       if (isStaleUtxo && attempt < MAX_RETRY_ATTEMPTS) {
         continue;
       }
+      const isDustInsufficient = err?.message?.toLowerCase().includes("not enough dust") || err?.message?.toLowerCase().includes("dust generated");
+      if (isDustInsufficient && attempt < MAX_RETRY_ATTEMPTS) {
+        onDust?.("Waiting for more dust to accumulate...");
+        await new Promise((resolve4) => setTimeout(resolve4, DUST_REGISTRATION_RETRY_DELAY_MS));
+        continue;
+      }
       throw err;
     }
   }
@@ -1548,7 +1687,7 @@ async function executeTransfer(params) {
     await ensureDust(bundle, onDust);
     if (signal?.aborted)
       throw new Error("Operation cancelled");
-    const txHash = await buildAndSubmitTransfer(bundle, recipientAddress, amount, onProving, onSubmitting);
+    const txHash = await buildAndSubmitTransfer(bundle, recipientAddress, amount, onProving, onSubmitting, onDust);
     return { txHash, amountMicroNight: amount };
   } finally {
     signal?.removeEventListener("abort", onAbort);
@@ -1652,7 +1791,13 @@ async function airdropCommand(args, signal) {
     process.stderr.write(`
 ` + divider() + `
 `);
-    process.stderr.write(dim("  Verify: midnight balance") + `
+    process.stderr.write(dim("  Verify:         midnight balance") + `
+`);
+    process.stderr.write(dim("  Register dust:  midnight dust register") + `
+`);
+    process.stderr.write(dim("  Note: Dust generation takes a few minutes on a fresh wallet.") + `
+`);
+    process.stderr.write(dim("        It will happen automatically on your first transfer.") + `
 
 `);
   } catch (err) {
@@ -1871,22 +2016,13 @@ async function dustRegister(bundle, networkName, jsonMode, signal, warningRef) {
       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);
+      txHash = await registerNightUtxos(bundle, dustUtxos, state.dust.dustAddress, (status) => {
+        spinner.update(status);
+      });
       spinner.update(`Registration submitted (${txHash.slice(0, 12)}...), waiting for dust...`);
     }
     if (signal?.aborted)
@@ -1982,6 +2118,7 @@ var init_dust = __esm(() => {
   init_wallet_config();
   init_resolve_network();
   init_facade();
+  init_transfer();
   init_format();
   init_spinner();
 });
@@ -2406,7 +2543,6 @@ 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 = [];
@@ -2438,12 +2574,11 @@ async function main() {
   const transport = new StdioServerTransport;
   await server.connect(transport);
 }
-var require2, pkg, handlerLoaders, TOOLS, server;
+var handlerLoaders, TOOLS, server;
 var init_mcp_server = __esm(() => {
   init_run_command();
   init_exit_codes();
-  require2 = createRequire(import.meta.url);
-  pkg = require2("../package.json");
+  init_pkg();
   handlerLoaders = {
     generate: () => Promise.resolve().then(() => (init_generate(), exports_generate)),
     info: () => Promise.resolve().then(() => (init_info(), exports_info)),
@@ -2769,7 +2904,7 @@ var init_mcp_server = __esm(() => {
       }
     }
   ];
-  server = new Server({ name: "midnight-wallet-cli", version: pkg.version }, { capabilities: { tools: {} } });
+  server = new Server({ name: "midnight-wallet-cli", version: PKG_VERSION }, { capabilities: { tools: {} } });
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
       tools: TOOLS.map((t) => ({
@@ -3008,7 +3143,6 @@ __export(exports_help, {
   default: () => helpCommand,
   COMMAND_SPECS: () => COMMAND_SPECS
 });
-import { createRequire as createRequire2 } from "node:module";
 function buildRightColumn() {
   const lines = [];
   for (const wl of WORDMARK_BIG) {
@@ -3078,13 +3212,11 @@ function printCommandHelp(spec) {
   }
 }
 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,
+      name: PKG_NAME,
+      version: PKG_VERSION,
+      description: PKG_DESCRIPTION,
       bin: ["midnight", "mn"]
     },
     globalFlags: [
@@ -3106,13 +3238,11 @@ function outputJsonManifest() {
   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}
+Version: ${PKG_VERSION}
 
 STRUCTURED JSON OUTPUT
 ──────────────────────
@@ -3251,6 +3381,7 @@ var init_help = __esm(() => {
   init_format();
   init_animate();
   init_art();
+  init_pkg();
   COMMAND_SPECS = [
     {
       name: "generate",
@@ -3494,7 +3625,7 @@ var init_help = __esm(() => {
 // src/wallet.ts
 init_format();
 init_exit_codes();
-import { createRequire as createRequire3 } from "node:module";
+init_pkg();
 if (process.argv.includes("--mcp")) {
   await Promise.resolve().then(() => (init_mcp_server(), exports_mcp_server));
 } else {
@@ -3505,9 +3636,7 @@ if (process.argv.includes("--mcp")) {
   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.stdout.write(PKG_VERSION + `
 `);
     process.exit(0);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midnight-wallet-cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "description": "Git-style CLI wallet for the Midnight blockchain",
   "license": "Apache-2.0",