create-mn-app 0.0.6

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

@@ -0,0 +1,51 @@
+{
+  "name": "{{projectName}}",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "A Midnight Network application created with create-midnight-app",
+  "author": "{{author}}",
+  "license": "MIT",
+  "scripts": {
+    "dev": "concurrently \"npm run proof-server\" \"npm run watch\"",
+    "watch": "nodemon --config nodemon.json",
+    "setup": "npm run compile && npm run build && npm run deploy",
+    "compile": "compact compile contracts/hello-world.compact contracts/managed/hello-world",
+    "build": "tsc",
+    "deploy": "node dist/deploy.js",
+    "cli": "node dist/cli.js",
+    "check-balance": "npm run build && node dist/check-balance.js",
+    "reset": "rm -rf contracts/managed deployment.json dist && npm run compile",
+    "validate": "tsc --noEmit && npm run compile",
+    "clean": "rm -rf dist contracts/managed deployment.json",
+    "proof-server": "docker run -p 6300:6300 midnightnetwork/proof-server -- 'midnight-proof-server --network testnet'",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@midnight-ntwrk/compact-runtime": "^0.8.1",
+    "@midnight-ntwrk/ledger": "^4.0.0",
+    "@midnight-ntwrk/midnight-js-contracts": "2.0.2",
+    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "2.0.2",
+    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "2.0.2",
+    "@midnight-ntwrk/midnight-js-level-private-state-provider": "2.0.2",
+    "@midnight-ntwrk/midnight-js-node-zk-config-provider": "2.0.2",
+    "@midnight-ntwrk/midnight-js-network-id": "2.0.2",
+    "@midnight-ntwrk/midnight-js-types": "2.0.2",
+    "@midnight-ntwrk/wallet": "5.0.0",
+    "@midnight-ntwrk/wallet-api": "5.0.0",
+    "@midnight-ntwrk/zswap": "^4.0.0",
+    "ws": "^8.18.3",
+    "dotenv": "^16.3.1",
+    "chalk": "^5.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.4.0",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.9.2",
+    "nodemon": "^3.0.1",
+    "concurrently": "^8.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": ["midnight", "blockchain", "zero-knowledge", "privacy"]
+}

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

@@ -0,0 +1,107 @@
+import "dotenv/config";
+import { WalletBuilder } from "@midnight-ntwrk/wallet";
+import {
+  NetworkId,
+  setNetworkId,
+  getZswapNetworkId,
+  getLedgerNetworkId,
+} from "@midnight-ntwrk/midnight-js-network-id";
+import { nativeToken } from "@midnight-ntwrk/ledger";
+import { WebSocket } from "ws";
+import * as Rx from "rxjs";
+import chalk from "chalk";
+import { EnvironmentManager } from "./utils/environment.js";
+
+// Fix WebSocket for Node.js environment
+// @ts-ignore
+globalThis.WebSocket = WebSocket;
+
+// Configure for Midnight Testnet
+setNetworkId(NetworkId.TestNet);
+
+async function checkBalance() {
+  try {
+    console.log();
+    console.log(chalk.blue.bold("━".repeat(60)));
+    console.log(chalk.blue.bold("🌙  Wallet Balance Checker"));
+    console.log(chalk.blue.bold("━".repeat(60)));
+    console.log();
+
+    const seed = process.env.WALLET_SEED;
+    if (!seed) {
+      throw new Error("WALLET_SEED not found in .env file");
+    }
+
+    console.log(chalk.gray("Building wallet..."));
+    console.log();
+
+    // Get network configuration
+    const networkConfig = EnvironmentManager.getNetworkConfig();
+
+    // Build wallet from seed
+    const wallet = await WalletBuilder.buildFromSeed(
+      networkConfig.indexer,
+      networkConfig.indexerWS,
+      networkConfig.proofServer,
+      networkConfig.node,
+      seed,
+      getZswapNetworkId(),
+      "info"
+    );
+
+    wallet.start();
+
+    const state = await Rx.firstValueFrom(wallet.state());
+
+    console.log(chalk.cyan.bold("📍 Wallet Address:"));
+    console.log(chalk.white(`   ${state.address}`));
+    console.log();
+
+    const balance = state.balances[nativeToken()] || 0n;
+
+    if (balance === 0n) {
+      console.log(chalk.yellow.bold("💰 Balance: ") + chalk.red.bold("0 DUST"));
+      console.log();
+      console.log(chalk.red("❌ No funds detected."));
+      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("https://midnight.network/test-faucet"));
+      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(chalk.white("   4. ") + chalk.cyan("Wait 2-5 minutes for processing"));
+      console.log(chalk.white("   5. ") + chalk.cyan("Run ") + chalk.yellow.bold("'npm run check-balance'") + chalk.cyan(" again"));
+      console.log();
+      console.log(chalk.gray("━".repeat(60)));
+      console.log(chalk.gray("💡 Tip: Faucet transactions typically take 2-5 minutes to process."));
+      console.log(chalk.gray("━".repeat(60)));
+    } else {
+      console.log(chalk.yellow.bold("💰 Balance: ") + chalk.green.bold(`${balance} DUST`));
+      console.log();
+      console.log(chalk.green.bold("✅ Wallet is funded and ready!"));
+      console.log();
+      console.log(chalk.magenta.bold("━".repeat(60)));
+      console.log(chalk.magenta.bold("🚀 Next Step:"));
+      console.log(chalk.magenta.bold("━".repeat(60)));
+      console.log();
+      console.log(chalk.cyan("   Deploy your contract with:"));
+      console.log(chalk.yellow.bold("   npm run deploy"));
+      console.log();
+      console.log(chalk.gray("━".repeat(60)));
+    }
+
+    console.log();
+    wallet.close();
+    process.exit(0);
+  } catch (error) {
+    console.log();
+    console.log(chalk.red.bold("❌ Error checking balance:"));
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    console.log();
+    process.exit(1);
+  }
+}
+
+checkBalance();

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

@@ -0,0 +1,194 @@
+import "dotenv/config";
+import * as readline from "readline/promises";
+import { WalletBuilder } from "@midnight-ntwrk/wallet";
+import { findDeployedContract } from "@midnight-ntwrk/midnight-js-contracts";
+import {
+  NetworkId,
+  setNetworkId,
+  getZswapNetworkId,
+  getLedgerNetworkId,
+} from "@midnight-ntwrk/midnight-js-network-id";
+import { createBalancedTx } from "@midnight-ntwrk/midnight-js-types";
+import { Transaction } from "@midnight-ntwrk/ledger";
+import { Transaction as ZswapTransaction } from "@midnight-ntwrk/zswap";
+import { WebSocket } from "ws";
+import * as path from "path";
+import * as fs from "fs";
+import * as Rx from "rxjs";
+import { MidnightProviders } from "./providers/midnight-providers.js";
+import { EnvironmentManager } from "./utils/environment.js";
+
+// Fix WebSocket for Node.js environment
+// @ts-ignore
+globalThis.WebSocket = WebSocket;
+
+// Configure for Midnight Testnet
+setNetworkId(NetworkId.TestNet);
+
+async function main() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log("🌙 {{projectName}} CLI\n");
+
+  try {
+    // Validate environment
+    EnvironmentManager.validateEnvironment();
+
+    // Check for deployment file
+    if (!fs.existsSync("deployment.json")) {
+      console.error("❌ No deployment.json found! Run npm run deploy first.");
+      process.exit(1);
+    }
+
+    const deployment = JSON.parse(fs.readFileSync("deployment.json", "utf-8"));
+    console.log(`Contract: ${deployment.contractAddress}\n`);
+
+    const networkConfig = EnvironmentManager.getNetworkConfig();
+    const contractName =
+      deployment.contractName || process.env.CONTRACT_NAME || "hello-world";
+    const walletSeed = process.env.WALLET_SEED!;
+
+    console.log("Connecting to Midnight network...");
+
+    // Build wallet
+    const wallet = await WalletBuilder.buildFromSeed(
+      networkConfig.indexer,
+      networkConfig.indexerWS,
+      networkConfig.proofServer,
+      networkConfig.node,
+      walletSeed,
+      getZswapNetworkId(),
+      "info"
+    );
+
+    wallet.start();
+
+    // Wait for sync
+    await Rx.firstValueFrom(
+      wallet.state().pipe(Rx.filter((s) => s.syncProgress?.synced === true))
+    );
+
+    // Load 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
+    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 providers
+    const providers = MidnightProviders.create({
+      contractName,
+      walletProvider,
+      networkConfig,
+    });
+
+    // Connect to contract
+    const deployed: any = await findDeployedContract(providers, {
+      contractAddress: deployment.contractAddress,
+      contract: contractInstance,
+      privateStateId: "helloWorldState",
+      initialPrivateState: {},
+    });
+
+    console.log("✅ Connected to contract\n");
+
+    // Main menu loop
+    let running = true;
+    while (running) {
+      console.log("--- Menu ---");
+      console.log("1. Store message");
+      console.log("2. Read current message");
+      console.log("3. Exit");
+
+      const choice = await rl.question("\nYour choice: ");
+
+      switch (choice) {
+        case "1":
+          console.log("\nStoring custom message...");
+          const customMessage = await rl.question("Enter your message: ");
+          try {
+            const tx = await deployed.callTx.storeMessage(customMessage);
+            console.log("✅ Success!");
+            console.log(`Message: "${customMessage}"`);
+            console.log(`Transaction ID: ${tx.public.txId}`);
+            console.log(`Block height: ${tx.public.blockHeight}\n`);
+          } catch (error) {
+            console.error("❌ Failed to store message:", error);
+          }
+          break;
+
+        case "2":
+          console.log("\nReading message from blockchain...");
+          try {
+            const state = await providers.publicDataProvider.queryContractState(
+              deployment.contractAddress
+            );
+            if (state) {
+              const ledger = HelloWorldModule.ledger(state.data);
+              const message = Buffer.from(ledger.message).toString();
+              console.log(`📋 Current message: "${message}"\n`);
+            } else {
+              console.log("📋 No message found\n");
+            }
+          } catch (error) {
+            console.error("❌ Failed to read message:", error);
+          }
+          break;
+
+        case "3":
+          running = false;
+          console.log("\n👋 Goodbye!");
+          break;
+
+        default:
+          console.log("❌ Invalid choice. Please enter 1, 2, or 3.\n");
+      }
+    }
+
+    // Clean up
+    await wallet.close();
+  } catch (error) {
+    console.error("\n❌ Error:", error);
+  } finally {
+    rl.close();
+  }
+}
+
+main().catch(console.error);

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

@@ -0,0 +1,218 @@
+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 chalk from "chalk";
+import { MidnightProviders } from "./providers/midnight-providers.js";
+import { EnvironmentManager } from "./utils/environment.js";
+
+// 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();
+  console.log(chalk.blue.bold("━".repeat(60)));
+  console.log(chalk.blue.bold("🌙  {{projectName}} Deployment"));
+  console.log(chalk.blue.bold("━".repeat(60)));
+  console.log();
+
+  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(chalk.cyan.bold("📍 Wallet Address:"));
+    console.log(chalk.white(`   ${state.address}`));
+    console.log();
+
+    let balance = state.balances[nativeToken()] || 0n;
+
+    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("https://midnight.network/test-faucet"));
+      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(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);
+      },
+    };
+
+    // Configure all required providers
+    console.log("Setting up providers...");
+    const providers = MidnightProviders.create({
+      contractName,
+      walletProvider,
+      networkConfig,
+    });
+
+    // Deploy contract to blockchain
+    console.log(chalk.blue("🚀 Deploying contract (30-60 seconds)..."));
+    console.log();
+
+    const deployed = await deployContract(providers, {
+      contract: contractInstance,
+      privateStateId: "helloWorldState",
+      initialPrivateState: {},
+    });
+
+    const contractAddress = deployed.deployTxData.public.contractAddress;
+
+    // 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 = {
+      contractAddress,
+      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);
+  }
+}
+
+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.js";
+
+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"]
+}