midnight-wallet-cli 0.1.6 → 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();
 });
@@ -2292,7 +2367,7 @@ function classifyError(err) {
 // package.json
 var package_default = {
   name: "midnight-wallet-cli",
-  version: "0.1.6",
+  version: "0.1.7",
   type: "module",
   description: "Git-style CLI wallet for the Midnight blockchain",
   license: "Apache-2.0",

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() {
@@ -315,7 +315,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "midnight-wallet-cli",
-    version: "0.1.6",
+    version: "0.1.7",
     type: "module",
     description: "Git-style CLI wallet for the Midnight blockchain",
     license: "Apache-2.0",
@@ -1492,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;
@@ -1523,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 {
@@ -1560,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;
     }
   }
@@ -1610,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);
@@ -1714,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) {
@@ -1933,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)
@@ -2044,6 +2118,7 @@ var init_dust = __esm(() => {
   init_wallet_config();
   init_resolve_network();
   init_facade();
+  init_transfer();
   init_format();
   init_spinner();
 });

package/package.json

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