create-mn-app 1.0.0

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

@@ -0,0 +1,181 @@
+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 {
+  NetworkId,
+  setNetworkId,
+  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 { MidnightProviders } from "./providers/midnight-providers";
+import { EnvironmentManager } from "./utils/environment";
+
+// Fix WebSocket for Node.js environment
+// @ts-ignore
+globalThis.WebSocket = WebSocket;
+
+// Configure for Midnight Testnet
+setNetworkId(NetworkId.TestNet);
+
+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}`))
+    )
+  );
+
+async function main() {
+  console.log("🌙 {{projectName}} Deployment\n");
+
+  try {
+    // Validate environment
+    EnvironmentManager.validateEnvironment();
+
+    const networkConfig = EnvironmentManager.getNetworkConfig();
+    const contractName = process.env.CONTRACT_NAME || "hello-world";
+
+    // Check if contract is compiled
+    if (!EnvironmentManager.checkContractCompiled(contractName)) {
+      console.error("❌ Contract not compiled! Run: npm run compile");
+      process.exit(1);
+    }
+
+    const walletSeed = process.env.WALLET_SEED!;
+
+    // Build wallet from seed
+    console.log("Building wallet...");
+    const wallet = await WalletBuilder.buildFromSeed(
+      networkConfig.indexer,
+      networkConfig.indexerWS,
+      networkConfig.proofServer,
+      networkConfig.node,
+      walletSeed,
+      getZswapNetworkId(),
+      "info"
+    );
+
+    wallet.start();
+    const state = await Rx.firstValueFrom(wallet.state());
+
+    console.log(`Your wallet address is: ${state.address}`);
+
+    let balance = state.balances[nativeToken()] || 0n;
+
+    if (balance === 0n) {
+      console.log(`Your wallet balance is: 0`);
+      console.log(
+        "Visit: https://midnight.network/test-faucet to get some funds."
+      );
+      console.log(`Waiting to receive tokens...`);
+      balance = await waitForFunds(wallet);
+    }
+
+    console.log(`Balance: ${balance}`);
+
+    // Load compiled contract files
+    console.log("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);
+      },
+    };
+
+    // Configure all required providers
+    console.log("Setting up providers...");
+    const providers = MidnightProviders.create({
+      contractName,
+      walletProvider,
+      networkConfig,
+    });
+
+    // Deploy contract to blockchain
+    console.log("Deploying contract (30-60 seconds)...");
+
+    const deployed = await deployContract(providers, {
+      contract: contractInstance,
+      privateStateId: "helloWorldState",
+      initialPrivateState: {},
+    });
+
+    const contractAddress = deployed.deployTxData.public.contractAddress;
+
+    // Save deployment information
+    console.log("\n🎉 DEPLOYED!");
+    console.log(`Contract: ${contractAddress}\n`);
+
+    const info = {
+      contractAddress,
+      deployedAt: new Date().toISOString(),
+      network: networkConfig.name,
+      contractName,
+    };
+
+    fs.writeFileSync("deployment.json", JSON.stringify(info, null, 2));
+    console.log("✅ Saved to deployment.json");
+
+    // Close wallet connection
+    await wallet.close();
+  } catch (error) {
+    console.error("❌ Failed:", error);
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);

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

@@ -0,0 +1,46 @@
+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";
+
+export interface NetworkConfig {
+  indexer: string;
+  indexerWS: string;
+  node: string;
+  proofServer: string;
+  name: string;
+}
+
+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,
+    };
+  }
+}

package/templates/hello-world/src/utils/environment.ts.template

@@ -0,0 +1,51 @@
+import fs from "fs";
+import path from "path";
+import { NetworkConfig } from "../providers/midnight-providers";
+
+export class EnvironmentManager {
+  static getNetworkConfig(): NetworkConfig {
+    const network = process.env.MIDNIGHT_NETWORK || "testnet";
+
+    const networks = {
+      testnet: {
+        indexer: "https://indexer.testnet-02.midnight.network/api/v1/graphql",
+        indexerWS:
+          "wss://indexer.testnet-02.midnight.network/api/v1/graphql/ws",
+        node: "https://rpc.testnet-02.midnight.network",
+        proofServer: process.env.PROOF_SERVER_URL || "http://127.0.0.1:6300",
+        name: "Testnet",
+      },
+    };
+
+    return networks[network as keyof typeof networks] || networks.testnet;
+  }
+
+  static validateEnvironment(): void {
+    const required = ["WALLET_SEED"];
+    const missing = required.filter((key) => !process.env[key]);
+
+    if (missing.length > 0) {
+      throw new Error(
+        `Missing required environment variables: ${missing.join(", ")}`
+      );
+    }
+
+    const walletSeed = process.env.WALLET_SEED!;
+    if (!/^[a-fA-F0-9]{64}$/.test(walletSeed)) {
+      throw new Error("WALLET_SEED must be a 64-character hexadecimal string");
+    }
+  }
+
+  static checkContractCompiled(contractName: string): boolean {
+    const contractPath = path.join(
+      process.cwd(),
+      "contracts",
+      "managed",
+      contractName
+    );
+    const keysPath = path.join(contractPath, "keys");
+    const contractModulePath = path.join(contractPath, "contract", "index.cjs");
+
+    return fs.existsSync(keysPath) && fs.existsSync(contractModulePath);
+  }
+}

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

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "contracts/managed"]
+}