create-mn-app 0.3.28 → 0.4.1

package/templates/hello-world/src/deploy.ts.template

@@ -1,14 +1,16 @@
 /**
- * Deploy {{projectName}} contract to Midnight Preprod network
+ * Deploy {{projectName}} contract to a Midnight network (undeployed by default; use --network preview|preprod for public networks).
+ *
+ * Non-interactive: scaffold → npm run setup runs straight through.
+ * No readline prompts, no .midnight-seed file.
  */
-import { createInterface } from 'node:readline/promises';
-import { stdin, stdout } from 'node:process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { resolveNetwork, getOrCreateSeed, recordDeployment } from './network';
+import { createWallet, persistWalletState, unshieldedToken, type WalletContext } from './wallet';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { WebSocket } from 'ws';
 import * as Rx from 'rxjs';
-import { Buffer } from 'buffer';
 
 // Midnight SDK imports
 import { deployContract } from '@midnight-ntwrk/midnight-js-contracts';
@@ -16,53 +18,38 @@ import { httpClientProofProvider } from '@midnight-ntwrk/midnight-js-http-client
 import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-public-data-provider';
 import { levelPrivateStateProvider } from '@midnight-ntwrk/midnight-js-level-private-state-provider';
 import { NodeZkConfigProvider } from '@midnight-ntwrk/midnight-js-node-zk-config-provider';
-import { setNetworkId, getNetworkId } from '@midnight-ntwrk/midnight-js-network-id';
-import { toHex } from '@midnight-ntwrk/midnight-js-utils';
-import * as ledger from '@midnight-ntwrk/ledger-v8';
-import { unshieldedToken } from '@midnight-ntwrk/ledger-v8';
-import { WalletFacade } from '@midnight-ntwrk/wallet-sdk-facade';
-import { DustWallet } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
-import { HDWallet, Roles, generateRandomSeed } from '@midnight-ntwrk/wallet-sdk-hd';
-import { ShieldedWallet } from '@midnight-ntwrk/wallet-sdk-shielded';
-import { createKeystore, InMemoryTransactionHistoryStorage, PublicKey, UnshieldedWallet } from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
 import { CompiledContract } from '@midnight-ntwrk/compact-js';
 
-// Enable WebSocket for GraphQL subscriptions
 // @ts-expect-error Required for wallet sync
 globalThis.WebSocket = WebSocket;
 
-// Set network to preprod
-setNetworkId('preprod');
+// ─── Network configuration ─────────────────────────────────────────────────────
+//
+// Resolved from --network flag, .midnight-state.json, or defaulting to
+// 'undeployed' (local devnet). Switch networks with: npm run network <name>
 
-// Preprod network configuration
-const CONFIG = {
-  indexer: 'https://indexer.preprod.midnight.network/api/v3/graphql',
-  indexerWS: 'wss://indexer.preprod.midnight.network/api/v3/graphql/ws',
-  node: 'https://rpc.preprod.midnight.network',
-  proofServer: 'http://127.0.0.1:6300',
-  faucetUrl: 'https://faucet.preprod.midnight.network/',
-};
+const { network, config: networkConfig } = resolveNetwork();
+const SEED = getOrCreateSeed(network);
 
-// ─── Proof Server Health Check ─────────────────────────────────────────────────
+// ─── Proof server readiness ────────────────────────────────────────────────────
+//
+// The proof-server image is distroless and has no shell, so it can't run a
+// container-side healthcheck. Poll it from the host before we submit anything
+// that needs proofs.
 
-async function waitForProofServer(maxAttempts = 30, delayMs = 2000): Promise<boolean> {
+async function waitForProofServer(maxAttempts = 60, delayMs = 2000): Promise<boolean> {
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
-      // Try a simple GET - any response (even 404) means server is up
-      const response = await fetch(CONFIG.proofServer, { 
+      await fetch(networkConfig.proofServer, {
         method: 'GET',
         signal: AbortSignal.timeout(3000),
       });
-      // Any response means the server is running
       return true;
     } catch (err: any) {
-      // Check if it's a connection refused vs other error
-      const errMsg = err?.cause?.code || err?.code || '';
-      if (errMsg !== 'ECONNREFUSED' && errMsg !== 'UND_ERR_CONNECT_TIMEOUT') {
-        // Got some other error - server might be up but returning errors
+      const code = err?.cause?.code || err?.code || '';
+      if (code !== 'ECONNREFUSED' && code !== 'UND_ERR_CONNECT_TIMEOUT' && code !== 'UND_ERR_SOCKET') {
         return true;
       }
-      // Server not ready yet
     }
     if (attempt < maxAttempts) {
       process.stdout.write(`\r  Waiting for proof server... (${attempt}/${maxAttempts})   `);
@@ -72,13 +59,12 @@ async function waitForProofServer(maxAttempts = 30, delayMs = 2000): Promise<boo
   return false;
 }
 
+// ─── Compiled contract loading ─────────────────────────────────────────────────
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const zkConfigPath = path.resolve(__dirname, '..', 'contracts', 'managed', 'hello-world');
-
-// Load compiled contract
 const contractPath = path.join(zkConfigPath, 'contract', 'index.js');
 
-// Check if contract is compiled
 if (!fs.existsSync(contractPath)) {
   console.error('\n❌ Contract not compiled! Run: npm run compile\n');
   process.exit(1);
@@ -91,48 +77,13 @@ const compiledContract = CompiledContract.make('hello-world', HelloWorld.Contrac
   CompiledContract.withCompiledFileAssets(zkConfigPath),
 );
 
-// ─── Wallet Functions ──────────────────────────────────────────────────────────
-
-function deriveKeys(seed: string) {
-  const hdWallet = HDWallet.fromSeed(Buffer.from(seed, 'hex'));
-  if (hdWallet.type !== 'seedOk') throw new Error('Invalid seed');
-  const result = hdWallet.hdWallet.selectAccount(0).selectRoles([Roles.Zswap, Roles.NightExternal, Roles.Dust]).deriveKeysAt(0);
-  if (result.type !== 'keysDerived') throw new Error('Key derivation failed');
-  hdWallet.hdWallet.clear();
-  return result.keys;
-}
-
-async function createWallet(seed: string) {
-  const keys = deriveKeys(seed);
-  const networkId = getNetworkId();
-  const shieldedSecretKeys = ledger.ZswapSecretKeys.fromSeed(keys[Roles.Zswap]);
-  const dustSecretKey = ledger.DustSecretKey.fromSeed(keys[Roles.Dust]);
-  const unshieldedKeystore = createKeystore(keys[Roles.NightExternal], networkId);
-
-  const walletConfig = {
-    networkId,
-    indexerClientConnection: { indexerHttpUrl: CONFIG.indexer, indexerWsUrl: CONFIG.indexerWS },
-    provingServerUrl: new URL(CONFIG.proofServer),
-    relayURL: new URL(CONFIG.node.replace(/^http/, 'ws')),
-    txHistoryStorage: new InMemoryTransactionHistoryStorage(),
-    costParameters: { additionalFeeOverhead: 300_000_000_000_000n, feeBlocksMargin: 5 },
-  };
-
-  const wallet = await WalletFacade.init({
-    configuration: walletConfig,
-    shielded: async (config) => ShieldedWallet(config).startWithSecretKeys(shieldedSecretKeys),
-    unshielded: async (config) => UnshieldedWallet(config).startWithPublicKey(PublicKey.fromKeyStore(unshieldedKeystore)),
-    dust: async (config) => DustWallet(config).startWithSecretKey(dustSecretKey, ledger.LedgerParameters.initialParameters().dust),
-  });
-
-  await wallet.start(shieldedSecretKeys, dustSecretKey);
-
-  return { wallet, shieldedSecretKeys, dustSecretKey, unshieldedKeystore };
-}
-
-async function createProviders(walletCtx: ReturnType<typeof createWallet> extends Promise<infer T> ? T : never) {
-  const privateStatePassword = process.env.PRIVATE_STATE_PASSWORD?.trim() || 'development';
+// ─── Providers ─────────────────────────────────────────────────────────────────
 
+async function createProviders(walletCtx: WalletContext) {
+  // The SDK requires the private-state password to be at least 16 characters.
+  // The default below is a placeholder for local devnet only — set a strong
+  // password via PRIVATE_STATE_PASSWORD when you move to a non-local target.
+  const privateStatePassword = process.env.PRIVATE_STATE_PASSWORD?.trim() || 'Local-Devnet-Development-Placeholder-1';
   const state = await walletCtx.wallet.waitForSyncedState();
 
   const walletProvider = {
@@ -161,311 +112,248 @@ async function createProviders(walletCtx: ReturnType<typeof createWallet> extend
       accountId,
       privateStoragePasswordProvider: () => privateStatePassword,
     }),
-    publicDataProvider: indexerPublicDataProvider(CONFIG.indexer, CONFIG.indexerWS),
+    publicDataProvider: indexerPublicDataProvider(networkConfig.indexer, networkConfig.indexerWS),
     zkConfigProvider,
-    proofProvider: httpClientProofProvider(CONFIG.proofServer, zkConfigProvider),
+    proofProvider: httpClientProofProvider(networkConfig.proofServer, zkConfigProvider),
     walletProvider,
     midnightProvider: walletProvider,
   };
 }
 
-// ─── Main Deploy Script ────────────────────────────────────────────────────────
+// ─── Main ──────────────────────────────────────────────────────────────────────
 
 async function main() {
   console.log('\n╔══════════════════════════════════════════════════════════════╗');
-  console.log('║           Deploy {{projectName}} to Midnight Preprod           ║');
+  console.log(`║  Deploy {{projectName}} to ${network}`);
   console.log('╚══════════════════════════════════════════════════════════════╝\n');
 
-  const rl = createInterface({ input: stdin, output: stdout });
-
-  try {
-    // Check for existing deployment and seed
-    let existingSeed: string | undefined;
-    let existingContract: string | undefined;
+  const seed = SEED;
 
-    if (fs.existsSync('.midnight-seed')) {
-      try {
-        existingSeed = fs.readFileSync('.midnight-seed', 'utf-8').trim();
-      } catch {
-        // Ignore read errors
-      }
-    }
-
-    if (fs.existsSync('deployment.json')) {
-      try {
-        const existing = JSON.parse(fs.readFileSync('deployment.json', 'utf-8'));
-        if (existing.contractAddress) existingContract = existing.contractAddress;
-      } catch {
-        // Ignore parse errors
-      }
-    }
-
-    // If already deployed, ask if they want to redeploy
-    if (existingContract) {
-      console.log('─── Existing Deployment Found ──────────────────────────────────\n');
-      console.log(`  Contract: ${existingContract}`);
-      const redeploy = await rl.question('\n  Deploy a new contract? [y/N] ');
-      if (redeploy.toLowerCase() !== 'y') {
-        console.log('\n  Run `npm run cli` to interact with your existing contract.\n');
-        return;
-      }
-      existingSeed = undefined; // Fresh deployment = fresh wallet
-    }
-
-    // 1. Wallet setup
-    console.log('─── Step 1: Wallet Setup ───────────────────────────────────────\n');
+  console.log('─── Wallet setup ───────────────────────────────────────────────\n');
+  console.log('  Creating wallet...');
+  const walletCtx = await createWallet({ network, networkConfig, seed });
+  const restoredCount = Object.values(walletCtx.restored).filter(Boolean).length;
+  if (restoredCount > 0) {
+    console.log(`  Restored ${restoredCount}/3 child wallets from .midnight-wallet-state — sync will resume from saved point.`);
+  }
 
-    let seed: string;
+  console.log('  Syncing with network...');
+  console.log('  ℹ  This may take several minutes depending on network size.');
+  console.log('     RPC disconnection messages during sync are normal and can be safely ignored.\n');
+  const syncStart = Date.now();
+  const syncInterval = setInterval(() => {
+    const elapsed = Math.round((Date.now() - syncStart) / 1000);
+    process.stdout.write(`\r  ⏳ Still syncing... (${elapsed}s elapsed)   `);
+  }, 5000);
+  const state = await walletCtx.wallet.waitForSyncedState();
+  clearInterval(syncInterval);
+  process.stdout.write('\r  ✓ Synced with network.                                      \n');
+
+  // Persist sync state now so a later deploy failure doesn't waste the sync work.
+  await persistWalletState(network, walletCtx);
+
+  const address = walletCtx.unshieldedKeystore.getBech32Address();
+  let balance = state.unshielded.balances[unshieldedToken().raw] ?? 0n;
+  console.log(`\n  Wallet Address: ${address}`);
+  console.log(`  Balance: ${balance.toLocaleString()} tNight\n`);
+
+  if (network === 'undeployed' && balance === 0n) {
+    console.error(
+      '\n❌ Genesis-seed wallet has zero NIGHT. The devnet preset may not have minted to it.\n' +
+        '   Check `docker compose ps` and `docker compose logs node`. Then `docker compose down -v` and retry.\n',
+    );
+    await walletCtx.wallet.stop();
+    process.exit(1);
+  }
 
-    if (existingSeed) {
-      // Resume from previous failed deployment
-      console.log('  Found saved seed from previous attempt.');
-      const useSaved = await rl.question('  Use saved wallet? [Y/n] ');
-      if (useSaved.toLowerCase() !== 'n') {
-        seed = existingSeed;
-        console.log('  Using saved wallet...\n');
-      } else {
-        const choice = await rl.question('  [1] Create new wallet\n  [2] Restore from seed\n  > ');
-        seed = choice.trim() === '2'
-          ? await rl.question('\n  Enter your 64-character seed: ')
-          : toHex(Buffer.from(generateRandomSeed()));
-
-        if (choice.trim() !== '2') {
-          fs.writeFileSync('.midnight-seed', seed, { mode: 0o600 });
-          console.log('\n  ⚠️  A new wallet seed has been generated.');
-          console.log('  It has been saved to .midnight-seed (chmod 600).');
-          console.log('  Back it up securely and never commit this file.\n');
+  // Faucet poll for public networks. The wallet has 0 tNIGHT until the user
+  // funds the address from the network's faucet. The display balance is
+  // authoritative here (unlike DUST, tNIGHT shows up immediately once the
+  // faucet tx lands).
+  if (network !== 'undeployed' && networkConfig.faucet) {
+    // Same balance idiom used by check-balance.ts:
+    //   state.unshielded.balances[unshieldedToken().raw] ?? 0n
+    const initialBalance = await Rx.firstValueFrom(walletCtx.wallet.state().pipe(
+      Rx.filter((s) => s.isSynced),
+    ));
+    const initialTNight = initialBalance.unshielded.balances[unshieldedToken().raw] ?? 0n;
+    if (initialTNight === 0n) {
+      console.log('─── Fund Wallet ────────────────────────────────────────────────\n');
+      console.log(`  Wallet address: ${address}`);
+      console.log(`  Faucet:         ${networkConfig.faucet}`);
+      console.log('');
+      console.log('  Waiting for tNIGHT to arrive (poll every 10s)...');
+      const rawTimeout = Number(process.env.MIDNIGHT_FAUCET_TIMEOUT_MS);
+      const timeoutMs = Number.isFinite(rawTimeout) && rawTimeout > 0 ? rawTimeout : 600_000;
+      const start = Date.now();
+      while (true) {
+        await new Promise((r) => setTimeout(r, 10_000));
+        const s = await Rx.firstValueFrom(walletCtx.wallet.state().pipe(Rx.filter((x) => x.isSynced)));
+        const tn = s.unshielded.balances[unshieldedToken().raw] ?? 0n;
+        if (tn > 0n) {
+          console.log(`\n  Funded! tNIGHT balance: ${tn.toLocaleString()}\n`);
+          break;
         }
+        if (Date.now() - start > timeoutMs) {
+          console.log(`\n  ❌ Funding not received within ${Math.round(timeoutMs / 60_000)} min.`);
+          console.log(`  Address: ${address}`);
+          console.log(`  Faucet:  ${networkConfig.faucet}`);
+          console.log('  Re-run setup after funding — your seed is preserved.\n');
+          await walletCtx.wallet.stop();
+          process.exit(1);
+        }
+        const elapsed = Math.round((Date.now() - start) / 1000);
+        process.stdout.write(`\r  ...still waiting (${elapsed}s elapsed)`);
       }
-    } else {
-      const choice = await rl.question('  [1] Create new wallet\n  [2] Restore from seed\n  > ');
-      seed = choice.trim() === '2'
-        ? await rl.question('\n  Enter your 64-character seed: ')
-        : toHex(Buffer.from(generateRandomSeed()));
-
-      if (choice.trim() !== '2') {
-        fs.writeFileSync('.midnight-seed', seed, { mode: 0o600 });
-        console.log('\n  ⚠️  A new wallet seed has been generated.');
-        console.log('  It has been saved to .midnight-seed (chmod 600).');
-        console.log('  Back it up securely and never commit this file.\n');
-      }
-    }
-
-    console.log('  Creating wallet...');
-    const walletCtx = await createWallet(seed.trim());
-
-    console.log('  Syncing with network...');
-    console.log('  ℹ  This may take several minutes depending on network size.');
-    console.log('     RPC disconnection messages during sync are normal and can be safely ignored.\n');
-    const syncStart = Date.now();
-    const syncInterval = setInterval(() => {
-      const elapsed = Math.round((Date.now() - syncStart) / 1000);
-      process.stdout.write(`\r  ⏳ Still syncing... (${elapsed}s elapsed)   `);
-    }, 5000);
-    const state = await walletCtx.wallet.waitForSyncedState();
-    clearInterval(syncInterval);
-    process.stdout.write('\r  ✓ Synced with network.                                      \n');
-    const address = walletCtx.unshieldedKeystore.getBech32Address();
-    const balance = state.unshielded.balances[unshieldedToken().raw] ?? 0n;
-
-    console.log(`\n  Wallet Address: ${address}`);
-    console.log(`  Balance: ${balance.toLocaleString()} tNight\n`);
-
-    // 2. Fund wallet if needed
-    if (balance === 0n) {
-      console.log('─── Step 2: Fund Your Wallet ───────────────────────────────────\n');
-      console.log(`  Visit: ${CONFIG.faucetUrl}`);
-      console.log(`  Address: ${address}\n`);
-      console.log('  Waiting for funds...');
-
-      await Rx.firstValueFrom(
-        walletCtx.wallet.state().pipe(
-          Rx.throttleTime(10000),
-          Rx.filter((s) => s.isSynced),
-          Rx.map((s) => s.unshielded.balances[unshieldedToken().raw] ?? 0n),
-          Rx.filter((b) => b > 0n),
-        ),
-      );
-      console.log('  Funds received!\n');
-    }
-
-    // 3. Register for DUST
-    console.log('─── Step 3: DUST Token Setup ───────────────────────────────────\n');
-    const dustState = await Rx.firstValueFrom(walletCtx.wallet.state().pipe(Rx.filter((s) => s.isSynced)));
-
-    if (dustState.dust.balance(new Date()) === 0n) {
-      const nightUtxos = dustState.unshielded.availableCoins.filter((c: any) => !c.meta?.registeredForDustGeneration);
-      if (nightUtxos.length > 0) {
-        console.log('  Registering for DUST generation...');
-        const recipe = await walletCtx.wallet.registerNightUtxosForDustGeneration(
-          nightUtxos,
-          walletCtx.unshieldedKeystore.getPublicKey(),
-          (payload) => walletCtx.unshieldedKeystore.signData(payload),
-        );
-        const signedRecipe = await walletCtx.wallet.signRecipe(recipe, (payload) => walletCtx.unshieldedKeystore.signData(payload));
-        await walletCtx.wallet.submitTransaction(await walletCtx.wallet.finalizeRecipe(signedRecipe));
-      }
-
-      console.log('  Waiting for DUST tokens...');
-      await Rx.firstValueFrom(
-        walletCtx.wallet.state().pipe(Rx.throttleTime(5000), Rx.filter((s) => s.isSynced), Rx.filter((s) => s.dust.balance(new Date()) > 0n)),
-      );
-    }
-    console.log('  DUST tokens ready!\n');
-
-    // 4. Deploy contract
-    console.log('─── Step 4: Deploy Contract ────────────────────────────────────\n');
-
-    // Check proof server is running
-    console.log('  Checking proof server...');
-    const proofServerReady = await waitForProofServer();
-    if (!proofServerReady) {
-      console.log('\n  ❌ Proof server not responding\n');
-      console.log('  The proof server is required to generate zk-proofs for transactions.\n');
-      console.log('  ┌─ Start it with ──────────────────────────────────────────────┐');
-      console.log('  │                                                              │');
-      console.log('  │  $ docker compose up -d                                      │');
-      console.log('  │                                                              │');
-      console.log('  │  Then retry:  $ npm run deploy                               │');
-      console.log('  │                                                              │');
-      console.log('  └──────────────────────────────────────────────────────────────┘\n');
-
-      // Save seed for retry
-      fs.writeFileSync('.midnight-seed', seed, { mode: 0o600 });
-      const partialInfo = { address, network: 'preprod', status: 'proof_server_unavailable' };
-      fs.writeFileSync('deployment.json', JSON.stringify(partialInfo, null, 2));
-      console.log('  Wallet saved to .midnight-seed and deployment.json\n');
-
-      await walletCtx.wallet.stop();
-      process.exit(1);
     }
-    process.stdout.write('\r  Proof server ready!                    \n');
-
-    console.log('  Setting up providers...');
-    const providers = await createProviders(walletCtx);
+  }
 
-    console.log('  Deploying contract...\n');
+  // Register for DUST.
+  console.log('─── DUST Token Setup ───────────────────────────────────────────\n');
+  const dustState = await Rx.firstValueFrom(walletCtx.wallet.state().pipe(Rx.filter((s) => s.isSynced)));
+
+  const unregisteredUtxos = dustState.unshielded.availableCoins.filter(
+    (c: any) => !c.meta?.registeredForDustGeneration,
+  );
+  if (unregisteredUtxos.length > 0) {
+    console.log(`  Registering ${unregisteredUtxos.length} NIGHT UTXOs for DUST generation...`);
+    // The signDustRegistration callback (3rd arg) already produces a recipe
+    // with N signatures matching N inputs. Do NOT call signRecipe again — that
+    // would double-sign and the chain rejects with InputsSignaturesLengthMismatch
+    // (Custom error 192). Matches upstream example-counter and example-bboard.
+    const recipe = await walletCtx.wallet.registerNightUtxosForDustGeneration(
+      unregisteredUtxos,
+      walletCtx.unshieldedKeystore.getPublicKey(),
+      (payload) => walletCtx.unshieldedKeystore.signData(payload),
+    );
+    const finalized = await walletCtx.wallet.finalizeRecipe(recipe);
+    await walletCtx.wallet.submitTransaction(finalized);
+  }
 
-    const MAX_RETRIES = 8;
-    const RETRY_DELAY_MS = 15000; // 15 seconds between retries
+  if (dustState.dust.balance(new Date()) === 0n) {
+    console.log('  Waiting for DUST tokens...');
+    await Rx.firstValueFrom(
+      walletCtx.wallet.state().pipe(
+        Rx.throttleTime(5000),
+        Rx.filter((s) => s.isSynced),
+        Rx.filter((s) => s.dust.balance(new Date()) > 0n),
+      ),
+    );
+  }
+  console.log('  DUST tokens ready!\n');
 
-    let deployed: Awaited<ReturnType<typeof deployContract>> | undefined;
+  // Deploy.
+  console.log('─── Deploy Contract ────────────────────────────────────────────\n');
 
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-      try {
-       deployed = await deployContract(providers, {
+  console.log('  Checking proof server...');
+  const proofServerReady = await waitForProofServer();
+  if (!proofServerReady) {
+    console.log('\n  ❌ Proof server not responding. Run: docker compose up -d\n');
+    await walletCtx.wallet.stop();
+    process.exit(1);
+  }
+  process.stdout.write('\r  Proof server ready!                                 \n');
+
+  console.log('  Setting up providers...');
+  const providers = await createProviders(walletCtx);
+
+  // The wallet's reported DUST balance is a *time-projection* of what its
+  // registered NIGHT will eventually generate; the tx-builder spends only
+  // what the next block's timestamp accounts for, which lags wall-clock by
+  // ~1 block on a fresh devnet. Sleeping ~1 block-time before attempt 1
+  // closes that gap in the common case; the retry loop covers outliers.
+  process.stdout.write('  Generating DUST...');
+  await new Promise((r) => setTimeout(r, 6000));
+  process.stdout.write(' done.\n');
+
+  console.log('  Deploying contract...\n');
+
+  // Fallback timing. The 6s pre-pause above handles the common case; this
+  // loop covers genuine outliers (slow blocks, proof-server worker-pool
+  // settling). Earlier 2s retries caused CI flakes where attempt 2's /prove
+  // hit the proof-server before it had drained attempt 1's state — 5s gives
+  // it room to settle between attempts. 20 × 5 = 100s total budget.
+  const MAX_RETRIES = 20;
+  const RETRY_DELAY_MS = 5000;
+  let deployed: Awaited<ReturnType<typeof deployContract>> | undefined;
+
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      deployed = await deployContract(providers, {
         compiledContract: compiledContract as any,
         args: [],
       });
-        break; // Success - exit retry loop
-      } catch (err: any) {
-        const errMsg = err?.message || err?.toString() || '';
-        const errCause = err?.cause?.message || err?.cause?.toString() || '';
-        const fullError = `${errMsg} ${errCause}`;
-
-        // Check for proof server errors first
-        if (fullError.includes('Failed to connect to Proof Server') || 
-            fullError.includes('Failed to prove') ||
-            fullError.includes('127.0.0.1:6300')) {
-          console.log('  ❌ Proof server error\n');
-          console.log('  The proof server may have stopped or crashed.\n');
-          console.log('  ┌─ Fix ────────────────────────────────────────────────────────┐');
-          console.log('  │                                                              │');
-          console.log('  │  1. Check if running:  $ docker ps                           │');
-          console.log('  │  2. Restart:           $ docker compose up -d                │');
-          console.log('  │  3. Retry:             $ npm run deploy                      │');
-          console.log('  │                                                              │');
-          console.log('  └──────────────────────────────────────────────────────────────┘\n');
-
-          fs.writeFileSync('.midnight-seed', seed, { mode: 0o600 });
-          const partialInfo = { address, network: 'preprod', status: 'proof_server_error' };
-          fs.writeFileSync('deployment.json', JSON.stringify(partialInfo, null, 2));
-          console.log('  Wallet saved to .midnight-seed and deployment.json\n');
+      break;
+    } catch (err: any) {
+      const errMsg = err?.message || err?.toString() || '';
+      const errCause = err?.cause?.message || err?.cause?.toString() || '';
+      const fullError = `${errMsg} ${errCause}`;
+
+      // DUST shortage is the most common transient failure on a fresh devnet —
+      // check it BEFORE proof-server connectivity, because dust-balancing errors
+      // can surface through proof-server-shaped messages (the wallet talks to
+      // the proof-server while building the dust portion of the tx).
+      const isDustShortage =
+        fullError.includes('Not enough Dust') ||
+        fullError.includes('Insufficient Funds') ||
+        fullError.includes('could not balance dust');
+
+      // Quiet the first DUST-shortage retry: it's the expected race between
+      // wall-clock projection and block-timestamp accounting and the loud
+      // `Insufficient Funds: <huge number>` message scares first-time users.
+      // Real failures still get the full diagnostic from attempt 2 onward.
+      if (!(isDustShortage && attempt === 1)) {
+        console.error(`\n  Attempt ${attempt} error: ${errMsg}`);
+        if (errCause && errCause !== errMsg) console.error(`  Cause: ${errCause}`);
+      }
 
-          await walletCtx.wallet.stop();
-          process.exit(1);
-        }
+      if (
+        !isDustShortage &&
+        (fullError.includes('Failed to connect to Proof Server') ||
+          fullError.includes('connect ECONNREFUSED 127.0.0.1:6300'))
+      ) {
+        console.log('  ❌ Proof server unreachable. Run: docker compose up -d\n');
+        await walletCtx.wallet.stop();
+        process.exit(1);
+      }
 
-        // Check if it's a DUST-related error (must check "Not enough Dust" specifically)
-        if (fullError.includes('Not enough Dust')) {
-          // Get current DUST balance
-          const currentState = await walletCtx.wallet.waitForSyncedState();
-          const dustBalance = currentState.dust.balance(new Date());
-
-          if (attempt < MAX_RETRIES) {
-            console.log(`  ⏳ DUST balance: ${dustBalance.toLocaleString()} (need more for tx fees)`);
-            console.log(`     Attempt ${attempt}/${MAX_RETRIES} - waiting for DUST to accumulate...`);
-
-            // Countdown display
-            for (let i = RETRY_DELAY_MS / 1000; i > 0; i -= 5) {
-              process.stdout.write(`\r     Retrying in ${i}s...   `);
-              await new Promise((r) => setTimeout(r, 5000));
-            }
-            process.stdout.write('\r                              \r\n');
+      if (isDustShortage) {
+        const currentState = await walletCtx.wallet.waitForSyncedState();
+        const dustBalance = currentState.dust.balance(new Date());
+        if (attempt < MAX_RETRIES) {
+          if (attempt === 1) {
+            console.log(`  Still generating DUST, retrying in ${RETRY_DELAY_MS / 1000}s...`);
           } else {
-            // All retries exhausted
-            console.log('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-            console.log('  ❌ Not enough DUST for transaction fees\n');
-            console.log(`     Current DUST: ${dustBalance.toLocaleString()}`);
-            console.log('     This is a new wallet - DUST generates over time.\n');
-            console.log('  ┌─ Options ─────────────────────────────────────────────────┐');
-            console.log('  │                                                           │');
-            console.log('  │  [1] Wait & retry     $ npm run deploy                    │');
-            console.log('  │      (DUST accumulates as blocks are produced)            │');
-            console.log('  │                                                           │');
-            console.log('  │  [2] Send DUST from existing wallet to this address:      │');
-            console.log(`  │      ${address.toString().slice(0, 50)}...  │`);
-            console.log('  │                                                           │');
-            console.log('  │  [3] Import wallet with DUST (choose option 2 on retry)   │');
-            console.log('  │                                                           │');
-            console.log('  └───────────────────────────────────────────────────────────┘\n');
-
-            // Save partial deployment info so user can resume
-            fs.writeFileSync('.midnight-seed', seed, { mode: 0o600 });
-            const partialInfo = {
-              address,
-              network: 'preprod',
-              status: 'pending_dust',
-              lastAttempt: new Date().toISOString(),
-            };
-            fs.writeFileSync('deployment.json', JSON.stringify(partialInfo, null, 2));
-            console.log('  Wallet saved to .midnight-seed and deployment.json\n');
-
-            await walletCtx.wallet.stop();
-            process.exit(1);
+            console.log(`  ⏳ DUST balance: ${dustBalance.toLocaleString()} (attempt ${attempt}/${MAX_RETRIES}); retrying in ${RETRY_DELAY_MS / 1000}s...`);
           }
+          await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
         } else {
-          // Not a DUST error - rethrow
-          throw err;
+          console.log(`  ❌ Not enough DUST after ${MAX_RETRIES} retries (current: ${dustBalance.toLocaleString()})`);
+          await walletCtx.wallet.stop();
+          process.exit(1);
         }
+      } else {
+        throw err;
       }
     }
+  }
 
-    if (!deployed) {
-      throw new Error('Deployment failed after all retries');
-    }
-
-    const contractAddress = deployed.deployTxData.public.contractAddress;
-    console.log('  ✅ Contract deployed successfully!\n');
-    console.log(`  Contract Address: ${contractAddress}\n`);
+  if (!deployed) throw new Error('Deployment failed after all retries');
 
-    // 5. Save deployment info
-    fs.writeFileSync('.midnight-seed', seed, { mode: 0o600 });
-    const deploymentInfo = {
-      contractAddress,
-      network: 'preprod',
-      deployedAt: new Date().toISOString(),
-    };
+  const contractAddress = deployed.deployTxData.public.contractAddress;
+  console.log('  ✅ Contract deployed successfully!\n');
+  console.log(`  Contract Address: ${contractAddress}\n`);
 
-    fs.writeFileSync('deployment.json', JSON.stringify(deploymentInfo, null, 2));
-    console.log('  Saved to deployment.json\n');
+  recordDeployment(network, contractAddress, address.toString());
+  console.log('  Saved to .midnight-state.json\n');
 
-    await walletCtx.wallet.stop();
-    console.log('─── Deployment Complete! ───────────────────────────────────────\n');
-    console.log('  Next: Run `npm run cli` to interact with your contract.\n');
-  } finally {
-    rl.close();
-  }
+  await persistWalletState(network, walletCtx);
+  await walletCtx.wallet.stop();
+  console.log('─── Deployment complete ────────────────────────────────────────\n');
+  console.log('  Next: npm run cli\n');
 }
 
-main().catch(console.error);
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});