create-mn-app 0.3.8 → 0.3.10

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

@@ -1,214 +1,268 @@
-import "dotenv/config";
-import { WalletBuilder } from "@midnight-ntwrk/wallet";
-import { deployContract } from "@midnight-ntwrk/midnight-js-contracts";
-import { httpClientProofProvider } from "@midnight-ntwrk/midnight-js-http-client-proof-provider";
-import { indexerPublicDataProvider } from "@midnight-ntwrk/midnight-js-indexer-public-data-provider";
-import { NodeZkConfigProvider } from "@midnight-ntwrk/midnight-js-node-zk-config-provider";
-import { levelPrivateStateProvider } from "@midnight-ntwrk/midnight-js-level-private-state-provider";
-import {
-  getZswapNetworkId,
-  getLedgerNetworkId,
-} from "@midnight-ntwrk/midnight-js-network-id";
-import { createBalancedTx } from "@midnight-ntwrk/midnight-js-types";
-import { nativeToken, Transaction } from "@midnight-ntwrk/ledger";
-import { Transaction as ZswapTransaction } from "@midnight-ntwrk/zswap";
-import { WebSocket } from "ws";
-import * as fs from "fs";
-import * as path from "path";
-import * as Rx from "rxjs";
-import { type Wallet } from "@midnight-ntwrk/wallet-api";
-import chalk from "chalk";
-import { MidnightProviders } from "./providers/midnight-providers.js";
-import { EnvironmentManager } from "./utils/environment.js";
-
-// Fix WebSocket for Node.js environment
-// @ts-ignore
+/**
+ * Deploy {{projectName}} contract to Midnight Preprod network
+ */
+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 { 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';
+import { httpClientProofProvider } from '@midnight-ntwrk/midnight-js-http-client-proof-provider';
+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-v7';
+import { unshieldedToken } from '@midnight-ntwrk/ledger-v7';
+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;
 
-// Initialize network from environment config
-const networkConfig = EnvironmentManager.initializeNetwork();
-
-const waitForFunds = (wallet: Wallet) =>
-  Rx.firstValueFrom(
-    wallet.state().pipe(
-      Rx.tap((state) => {
-        if (state.syncProgress) {
-          console.log(
-            `Sync progress: synced=${state.syncProgress.synced}, sourceGap=${state.syncProgress.lag.sourceGap}, applyGap=${state.syncProgress.lag.applyGap}`
-          );
-        }
-      }),
-      Rx.filter((state) => state.syncProgress?.synced === true),
-      Rx.map((s) => s.balances[nativeToken()] ?? 0n),
-      Rx.filter((balance) => balance > 0n),
-      Rx.tap((balance) => console.log(`Wallet funded with balance: ${balance}`))
-    )
-  );
+// Set network to preprod
+setNetworkId('preprod');
 
-async function main() {
-  console.log();
-  console.log(chalk.blue.bold("━".repeat(60)));
-  console.log(chalk.blue.bold("🌙  {{projectName}} Deployment"));
-  console.log(chalk.blue.bold("━".repeat(60)));
-  console.log();
+// 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/',
+};
 
-  try {
-    // Validate environment
-    EnvironmentManager.validateEnvironment();
+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');
 
-    const contractName = process.env.CONTRACT_NAME || "hello-world";
+// Check if contract is compiled
+if (!fs.existsSync(contractPath)) {
+  console.error('\n❌ Contract not compiled! Run: npm run compile\n');
+  process.exit(1);
+}
+
+const HelloWorld = await import(pathToFileURL(contractPath).href);
+
+const compiledContract = CompiledContract.make('hello-world', HelloWorld.Contract).pipe(
+  CompiledContract.withVacantWitnesses,
+  CompiledContract.withCompiledFileAssets(zkConfigPath),
+);
 
-    // Check if contract is compiled
-    if (!EnvironmentManager.checkContractCompiled(contractName)) {
-      console.error("❌ Contract not compiled! Run: npm run compile");
-      process.exit(1);
+// ─── 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')),
+  };
+
+  const shieldedWallet = ShieldedWallet(walletConfig).startWithSecretKeys(shieldedSecretKeys);
+  const unshieldedWallet = UnshieldedWallet({
+    networkId,
+    indexerClientConnection: walletConfig.indexerClientConnection,
+    txHistoryStorage: new InMemoryTransactionHistoryStorage(),
+  }).startWithPublicKey(PublicKey.fromKeyStore(unshieldedKeystore));
+  const dustWallet = DustWallet({
+    ...walletConfig,
+    costParameters: { additionalFeeOverhead: 300_000_000_000_000n, feeBlocksMargin: 5 },
+  }).startWithSecretKey(dustSecretKey, ledger.LedgerParameters.initialParameters().dust);
+
+  const wallet = new WalletFacade(shieldedWallet, unshieldedWallet, dustWallet);
+  await wallet.start(shieldedSecretKeys, dustSecretKey);
+
+  return { wallet, shieldedSecretKeys, dustSecretKey, unshieldedKeystore };
+}
+
+// Workaround for wallet SDK signRecipe bug
+function signTransactionIntents(tx: { intents?: Map<number, any> }, signFn: (payload: Uint8Array) => ledger.Signature, proofMarker: 'proof' | 'pre-proof'): void {
+  if (!tx.intents || tx.intents.size === 0) return;
+  for (const segment of tx.intents.keys()) {
+    const intent = tx.intents.get(segment);
+    if (!intent) continue;
+    const cloned = ledger.Intent.deserialize<ledger.SignatureEnabled, ledger.Proofish, ledger.PreBinding>('signature', proofMarker, 'pre-binding', intent.serialize());
+    const sigData = cloned.signatureData(segment);
+    const signature = signFn(sigData);
+    if (cloned.fallibleUnshieldedOffer) {
+      const sigs = cloned.fallibleUnshieldedOffer.inputs.map((_: any, i: number) => cloned.fallibleUnshieldedOffer!.signatures.at(i) ?? signature);
+      cloned.fallibleUnshieldedOffer = cloned.fallibleUnshieldedOffer.addSignatures(sigs);
     }
+    if (cloned.guaranteedUnshieldedOffer) {
+      const sigs = cloned.guaranteedUnshieldedOffer.inputs.map((_: any, i: number) => cloned.guaranteedUnshieldedOffer!.signatures.at(i) ?? signature);
+      cloned.guaranteedUnshieldedOffer = cloned.guaranteedUnshieldedOffer.addSignatures(sigs);
+    }
+    tx.intents.set(segment, cloned);
+  }
+}
+
+async function createProviders(walletCtx: ReturnType<typeof createWallet> extends Promise<infer T> ? T : never) {
+  const state = await Rx.firstValueFrom(walletCtx.wallet.state().pipe(Rx.filter((s) => s.isSynced)));
+
+  const walletProvider = {
+    getCoinPublicKey: () => state.shielded.coinPublicKey.toHexString(),
+    getEncryptionPublicKey: () => state.shielded.encryptionPublicKey.toHexString(),
+    async balanceTx(tx: any, ttl?: Date) {
+      const recipe = await walletCtx.wallet.balanceUnboundTransaction(
+        tx,
+        { shieldedSecretKeys: walletCtx.shieldedSecretKeys, dustSecretKey: walletCtx.dustSecretKey },
+        { ttl: ttl ?? new Date(Date.now() + 30 * 60 * 1000) },
+      );
+      const signFn = (payload: Uint8Array) => walletCtx.unshieldedKeystore.signData(payload);
+      signTransactionIntents(recipe.baseTransaction, signFn, 'proof');
+      if (recipe.balancingTransaction) signTransactionIntents(recipe.balancingTransaction, signFn, 'pre-proof');
+      return walletCtx.wallet.finalizeRecipe(recipe);
+    },
+    submitTx: (tx: any) => walletCtx.wallet.submitTransaction(tx) as any,
+  };
+
+  const zkConfigProvider = new NodeZkConfigProvider(zkConfigPath);
+
+  return {
+    privateStateProvider: levelPrivateStateProvider({ privateStateStoreName: 'hello-world-state', walletProvider }),
+    publicDataProvider: indexerPublicDataProvider(CONFIG.indexer, CONFIG.indexerWS),
+    zkConfigProvider,
+    proofProvider: httpClientProofProvider(CONFIG.proofServer, zkConfigProvider),
+    walletProvider,
+    midnightProvider: walletProvider,
+  };
+}
 
-    const walletSeed = process.env.WALLET_SEED!;
+// ─── Main Deploy Script ────────────────────────────────────────────────────────
 
-    // Build wallet from seed
-    console.log("Building wallet...");
-    const wallet = await WalletBuilder.buildFromSeed(
-      networkConfig.indexer,
-      networkConfig.indexerWS,
-      networkConfig.proofServer,
-      networkConfig.node,
-      walletSeed,
-      getZswapNetworkId(),
-      "info"
-    );
+async function main() {
+  console.log('\n╔══════════════════════════════════════════════════════════════╗');
+  console.log('║           Deploy {{projectName}} to Midnight Preprod           ║');
+  console.log('╚══════════════════════════════════════════════════════════════╝\n');
 
-    wallet.start();
-    const state = await Rx.firstValueFrom(wallet.state());
+  const rl = createInterface({ input: stdin, output: stdout });
 
-    console.log(chalk.cyan.bold("📍 Wallet Address:"));
-    console.log(chalk.white(`   ${state.address}`));
-    console.log();
+  try {
+    // 1. Wallet setup
+    console.log('─── Step 1: Wallet Setup ───────────────────────────────────────\n');
+    const choice = await rl.question('  [1] Create new wallet\n  [2] Restore from seed\n  > ');
 
-    let balance = state.balances[nativeToken()] || 0n;
+    const seed = choice.trim() === '2'
+      ? await rl.question('\n  Enter your 64-character seed: ')
+      : toHex(Buffer.from(generateRandomSeed()));
+
+    if (choice.trim() !== '2') {
+      console.log(`\n  ⚠️  SAVE THIS SEED (you'll need it later):\n  ${seed}\n`);
+    }
 
+    console.log('  Creating wallet...');
+    const walletCtx = await createWallet(seed.trim());
+
+    console.log('  Syncing with network...');
+    const state = await Rx.firstValueFrom(walletCtx.wallet.state().pipe(Rx.throttleTime(5000), Rx.filter((s) => s.isSynced)));
+    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(chalk.yellow.bold("💰 Balance: ") + chalk.red.bold("0 DUST"));
-      console.log();
-      console.log(chalk.red.bold("❌ Wallet needs funding to deploy contracts."));
-      console.log();
-      console.log(chalk.magenta.bold("━".repeat(60)));
-      console.log(chalk.magenta.bold("📝 How to Get Test Tokens:"));
-      console.log(chalk.magenta.bold("━".repeat(60)));
-      console.log();
-      console.log(chalk.white("   1. ") + chalk.cyan("Visit: ") + chalk.underline(networkConfig.faucetUrl));
-      console.log(chalk.white("   2. ") + chalk.cyan("Paste your wallet address (shown above)"));
-      console.log(chalk.white("   3. ") + chalk.cyan("Request tokens from the faucet"));
-      console.log();
-      console.log(chalk.gray("━".repeat(60)));
-      console.log(chalk.gray("⏱️  Faucet transactions can take 2-5 minutes to process."));
-      console.log(chalk.gray("━".repeat(60)));
-      console.log();
-      console.log(chalk.yellow.bold("💡 Options while waiting:"));
-      console.log(chalk.white("   • ") + chalk.cyan("Let this script wait (it will auto-detect when funds arrive)"));
-      console.log(chalk.white("   • ") + chalk.cyan("OR press ") + chalk.yellow("Ctrl+C") + chalk.cyan(" to stop, then check balance with:"));
-      console.log(chalk.yellow.bold("     npm run check-balance"));
-      console.log(chalk.white("   • ") + chalk.cyan("Once funded, run: ") + chalk.yellow.bold("npm run deploy"));
-      console.log();
-      console.log(chalk.blue("⏳ Waiting to receive tokens..."));
-      balance = await waitForFunds(wallet);
+      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');
     }
 
-    console.log(chalk.yellow.bold("💰 Balance: ") + chalk.green.bold(`${balance} DUST`));
-    console.log();
-
-    // Load compiled contract files
-    console.log(chalk.gray("📦 Loading contract..."));
-    const contractPath = path.join(process.cwd(), "contracts");
-    const contractModulePath = path.join(
-      contractPath,
-      "managed",
-      contractName,
-      "contract",
-      "index.cjs"
-    );
-
-    const HelloWorldModule = await import(contractModulePath);
-    const contractInstance = new HelloWorldModule.Contract({});
-
-    // Create wallet provider for transactions
-    const walletState = await Rx.firstValueFrom(wallet.state());
-
-    const walletProvider = {
-      coinPublicKey: walletState.coinPublicKey,
-      encryptionPublicKey: walletState.encryptionPublicKey,
-      balanceTx(tx: any, newCoins: any) {
-        return wallet
-          .balanceTransaction(
-            ZswapTransaction.deserialize(
-              tx.serialize(getLedgerNetworkId()),
-              getZswapNetworkId()
-            ),
-            newCoins
-          )
-          .then((tx) => wallet.proveTransaction(tx))
-          .then((zswapTx) =>
-            Transaction.deserialize(
-              zswapTx.serialize(getZswapNetworkId()),
-              getLedgerNetworkId()
-            )
-          )
-          .then(createBalancedTx);
-      },
-      submitTx(tx: any) {
-        return wallet.submitTransaction(tx);
-      },
-    };
+    // 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)));
 
-    // Configure all required providers
-    console.log("Setting up providers...");
-    const providers = MidnightProviders.create({
-      contractName,
-      walletProvider,
-      networkConfig,
-    });
+    if (dustState.dust.walletBalance(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),
+        );
+        await walletCtx.wallet.submitTransaction(await walletCtx.wallet.finalizeRecipe(recipe));
+      }
+
+      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.walletBalance(new Date()) > 0n)),
+      );
+    }
+    console.log('  DUST tokens ready!\n');
 
-    // Deploy contract to blockchain
-    console.log(chalk.blue("🚀 Deploying contract (30-60 seconds)..."));
-    console.log();
+    // 4. Deploy contract
+    console.log('─── Step 4: Deploy Contract ────────────────────────────────────\n');
+    console.log('  Setting up providers...');
+    const providers = await createProviders(walletCtx);
 
+    console.log('  Deploying contract (this may take 30-60 seconds)...\n');
     const deployed = await deployContract(providers, {
-      contract: contractInstance,
-      privateStateId: "helloWorldState",
+      compiledContract,
+      privateStateId: 'helloWorldState',
       initialPrivateState: {},
     });
 
     const contractAddress = deployed.deployTxData.public.contractAddress;
+    console.log('  ✅ Contract deployed successfully!\n');
+    console.log(`  Contract Address: ${contractAddress}\n`);
 
-    // Save deployment information
-    console.log();
-    console.log(chalk.green.bold("━".repeat(60)));
-    console.log(chalk.green.bold("🎉 CONTRACT DEPLOYED SUCCESSFULLY!"));
-    console.log(chalk.green.bold("━".repeat(60)));
-    console.log();
-    console.log(chalk.cyan.bold("📍 Contract Address:"));
-    console.log(chalk.white(`   ${contractAddress}`));
-    console.log();
-
-    const info = {
+    // 5. Save deployment info
+    const deploymentInfo = {
       contractAddress,
+      seed,
+      network: 'preprod',
       deployedAt: new Date().toISOString(),
-      network: networkConfig.name,
-      contractName,
     };
 
-    fs.writeFileSync("deployment.json", JSON.stringify(info, null, 2));
-    console.log(chalk.gray("✅ Saved to deployment.json"));
-    console.log();
-
-    // Close wallet connection
-    await wallet.close();
-  } catch (error) {
-    console.log();
-    console.log(chalk.red.bold("❌ Deployment Failed:"));
-    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
-    console.log();
-    process.exit(1);
+    fs.writeFileSync('deployment.json', JSON.stringify(deploymentInfo, null, 2));
+    console.log('  Saved to deployment.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();
   }
 }
 

package/templates/hello-world/nodemon.json.template

@@ -1,7 +0,0 @@
-{
-  "watch": ["contracts/**/*.compact", "src/**/*.ts"],
-  "ext": "compact,ts",
-  "ignore": ["contracts/managed/**", "dist/**", "node_modules/**"],
-  "exec": "npm run compile && npm run build",
-  "delay": "1000"
-}

package/templates/hello-world/src/health-check.ts.template

@@ -1,127 +0,0 @@
-#!/usr/bin/env node
-import { execSync } from "child_process";
-import fs from "fs";
-import chalk from "chalk";
-
-interface HealthCheck {
-  name: string;
-  check: () => Promise<boolean>;
-  message: string;
-  error?: string;
-}
-
-const checks: HealthCheck[] = [
-  {
-    name: "Node.js Version",
-    message: "Checking Node.js version (>= 22.0.0)...",
-    check: async () => {
-      const version = process.version;
-      const major = parseInt(version.slice(1).split(".")[0]);
-      return major >= 22;
-    },
-    error: "Node.js 22 or higher is required. Please upgrade Node.js.",
-  },
-  {
-    name: "Docker",
-    message: "Checking Docker availability...",
-    check: async () => {
-      try {
-        execSync("docker --version", { stdio: "ignore" });
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    error: "Docker is not installed or not running. Install Docker to use the proof server.",
-  },
-  {
-    name: "Environment File",
-    message: "Checking .env configuration...",
-    check: async () => {
-      return fs.existsSync(".env");
-    },
-    error: ".env file not found. Run 'npm run setup' first.",
-  },
-  {
-    name: "Wallet Seed",
-    message: "Checking wallet configuration...",
-    check: async () => {
-      if (!fs.existsSync(".env")) return false;
-      const envContent = fs.readFileSync(".env", "utf-8");
-      return envContent.includes("WALLET_SEED=");
-    },
-    error: "WALLET_SEED not found in .env. Run 'npm run setup' to generate a wallet.",
-  },
-  {
-    name: "Dependencies",
-    message: "Checking node_modules...",
-    check: async () => {
-      return fs.existsSync("node_modules");
-    },
-    error: "Dependencies not installed. Run 'npm install' first.",
-  },
-  {
-    name: "Contract Compilation",
-    message: "Checking compiled contracts...",
-    check: async () => {
-      return fs.existsSync("dist") || fs.existsSync("build");
-    },
-    error: "Project not built. Run 'npm run compile' and 'npm run build'.",
-  },
-];
-
-async function runHealthCheck() {
-  console.log(chalk.blue.bold("\n🏥 Midnight App Health Check\n"));
-
-  let passed = 0;
-  let failed = 0;
-
-  for (const check of checks) {
-    process.stdout.write(chalk.gray(`⏳ ${check.message} `));
-
-    try {
-      const result = await check.check();
-
-      if (result) {
-        console.log(chalk.green("✓ Passed"));
-        passed++;
-      } else {
-        console.log(chalk.red("✗ Failed"));
-        if (check.error) {
-          console.log(chalk.yellow(`   ${check.error}`));
-        }
-        failed++;
-      }
-    } catch (error) {
-      console.log(chalk.red("✗ Error"));
-      console.log(chalk.yellow(`   ${check.error || "Unknown error"}`));
-      failed++;
-    }
-  }
-
-  console.log();
-  console.log(chalk.bold("━".repeat(60)));
-  console.log(
-    chalk.bold(
-      `Results: ${chalk.green(`${passed} passed`)} | ${chalk.red(`${failed} failed`)}`
-    )
-  );
-  console.log(chalk.bold("━".repeat(60)));
-
-  if (failed === 0) {
-    console.log(chalk.green.bold("\n✓ All checks passed! Your environment is ready.\n"));
-    process.exit(0);
-  } else {
-    console.log(
-      chalk.yellow.bold(
-        "\n⚠ Some checks failed. Please fix the issues above before continuing.\n"
-      )
-    );
-    process.exit(1);
-  }
-}
-
-runHealthCheck().catch((error) => {
-  console.error(chalk.red("\n✗ Health check failed:"), error.message);
-  process.exit(1);
-});

package/templates/hello-world/src/providers/midnight-providers.ts.template

@@ -1,50 +0,0 @@
-import path from "path";
-import { levelPrivateStateProvider } from "@midnight-ntwrk/midnight-js-level-private-state-provider";
-import { indexerPublicDataProvider } from "@midnight-ntwrk/midnight-js-indexer-public-data-provider";
-import { NodeZkConfigProvider } from "@midnight-ntwrk/midnight-js-node-zk-config-provider";
-import { httpClientProofProvider } from "@midnight-ntwrk/midnight-js-http-client-proof-provider";
-
-import { NetworkId } from "@midnight-ntwrk/midnight-js-network-id";
-
-export interface NetworkConfig {
-  indexer: string;
-  indexerWS: string;
-  node: string;
-  proofServer: string;
-  name: string;
-  faucetUrl: string;
-  networkId: NetworkId;
-}
-
-export interface ProviderConfig {
-  contractName: string;
-  walletProvider: any;
-  networkConfig: NetworkConfig;
-  privateStateStoreName?: string;
-}
-
-export class MidnightProviders {
-  static create(config: ProviderConfig) {
-    const contractPath = path.join(process.cwd(), "contracts");
-    const zkConfigPath = path.join(
-      contractPath,
-      "managed",
-      config.contractName
-    );
-
-    return {
-      privateStateProvider: levelPrivateStateProvider({
-        privateStateStoreName:
-          config.privateStateStoreName || `${config.contractName}-state`,
-      }),
-      publicDataProvider: indexerPublicDataProvider(
-        config.networkConfig.indexer,
-        config.networkConfig.indexerWS
-      ),
-      zkConfigProvider: new NodeZkConfigProvider(zkConfigPath),
-      proofProvider: httpClientProofProvider(config.networkConfig.proofServer),
-      walletProvider: config.walletProvider,
-      midnightProvider: config.walletProvider,
-    };
-  }
-}