@clarigen/cli 1.0.0-next.21 → 1.0.0-next.25

package/dist/index.js

@@ -70,31 +70,112 @@ module.exports = __toCommonJS(src_exports);
 var import_command2 = require("@oclif/command");
 
 // src/config.ts
-var import_path2 = require("path");
-var import_promises2 = require("fs/promises");
-var import_fs = require("fs");
+var import_path4 = require("path");
+var import_promises4 = require("fs/promises");
+var import_fs2 = require("fs");
 
 // src/clarinet-config.ts
-var import_j_toml = require("@ltd/j-toml");
-var import_path = require("path");
-var import_promises = require("fs/promises");
+var import_toml = require("@iarna/toml");
+var import_path3 = require("path");
+var import_promises3 = require("fs/promises");
 var import_wallet_sdk = require("micro-stacks/wallet-sdk");
 var import_toposort = require("toposort");
 var import_crypto = require("micro-stacks/crypto");
+
+// src/generate/deployment.ts
+var import_js_yaml = require("js-yaml");
+var import_promises2 = require("fs/promises");
+var import_path2 = require("path");
+var import_fs = require("fs");
+
+// src/writer.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_prettier = require("prettier");
+var defaultPrettierConfig = {
+  printWidth: 80,
+  semi: true,
+  singleQuote: true,
+  trailingComma: "es5"
+};
+async function resolvePrettierConfig() {
+  try {
+    const local = await (0, import_prettier.resolveConfig)(process.cwd());
+    if (local)
+      return local;
+  } catch (error) {
+  }
+  return defaultPrettierConfig;
+}
+async function formatFile(contents, path) {
+  try {
+    const fileName = (0, import_path.basename)(path);
+    const config = await resolvePrettierConfig();
+    const formatted = (0, import_prettier.format)(contents, __spreadProps(__spreadValues({}, config), {
+      filepath: fileName
+    }));
+    return formatted;
+  } catch (error) {
+  }
+  return contents;
+}
+async function writeFile(path, contents) {
+  const formatted = await formatFile(contents, path);
+  await (0, import_promises.writeFile)(path, formatted);
+}
+
+// src/generate/deployment.ts
+async function parseDeployment(path) {
+  const contents = await (0, import_promises2.readFile)(path, { encoding: "utf-8" });
+  const parsed = (0, import_js_yaml.load)(contents);
+  return parsed;
+}
+async function generateDeployment(network, config) {
+  const file = `default.${network}-plan.yaml`;
+  const deploymentPath = (0, import_path2.resolve)(process.cwd(), config.clarinet, "deployments", file);
+  if ((0, import_fs.existsSync)(deploymentPath)) {
+    const plan = await parseDeployment(deploymentPath);
+    const varName = `${network}Deployment`;
+    const contents = `export const ${varName} = ${JSON.stringify(plan)} as const;
+    `;
+    const outputFile = (0, import_path2.resolve)(config.outputDir, "deployments", `${network}.ts`);
+    await writeFile(outputFile, contents);
+  }
+}
+async function generateDeployments(config) {
+  const networks = ["devnet", "simnet", "testnet", "mainnet"];
+  const folder = (0, import_path2.resolve)(process.cwd(), config.outputDir, "deployments");
+  await (0, import_promises2.mkdir)(folder, { recursive: true });
+  const generates = networks.map((n) => generateDeployment(n, config));
+  await Promise.all(generates);
+}
+
+// src/clarinet-config.ts
 async function getClarinetDevConfig(folder) {
-  const baseConfigPath = (0, import_path.resolve)(folder, "settings", "Devnet.toml");
-  const configContents = await (0, import_promises.readFile)(baseConfigPath, { encoding: "utf-8" });
-  const config = (0, import_j_toml.parse)(configContents, 1, "\n", true, {
-    longer: true
-  });
+  const baseConfigPath = (0, import_path3.resolve)(folder, "settings", "Devnet.toml");
+  const configContents = await (0, import_promises3.readFile)(baseConfigPath, { encoding: "utf-8" });
+  const config = (0, import_toml.parse)(configContents);
   return config;
 }
 async function getClarinetConfig(folder) {
-  const baseConfigPath = (0, import_path.resolve)(folder, "Clarinet.toml");
-  const configContents = await (0, import_promises.readFile)(baseConfigPath, { encoding: "utf-8" });
-  const config = (0, import_j_toml.parse)(configContents, 1, "\n", true);
+  const baseConfigPath = (0, import_path3.resolve)(folder, "Clarinet.toml");
+  const configContents = await (0, import_promises3.readFile)(baseConfigPath, { encoding: "utf-8" });
+  const config = (0, import_toml.parse)(configContents);
   return config;
 }
+async function getContractsFromDeployment(clarinetPath) {
+  const simnetPath = (0, import_path3.resolve)(clarinetPath || process.cwd(), "deployments/default.simnet-plan.yaml");
+  const deployment = await parseDeployment(simnetPath);
+  const txs = deployment.plan.batches[0].transactions;
+  return txs.map((_tx) => {
+    const tx = _tx["emulated-contract-publish"];
+    return {
+      file: tx.path,
+      name: tx["contract-name"],
+      address: tx["emulated-sender"]
+    };
+  });
+}
 function getContractsFromClarinet(clarinetConfig, accounts) {
   const deployerAddress = accounts.deployer.address;
   const sortedContracts = sortClarinetContracts(clarinetConfig.contracts);
@@ -113,8 +194,9 @@ function sortClarinetContracts(contractsConfig) {
   const edges = [];
   const nodes = [];
   Object.entries(contractsConfig).forEach(([contractName, info]) => {
+    var _a;
     nodes.push(contractName);
-    info.depends_on.forEach((dependency) => edges.push([contractName, dependency]));
+    (_a = info.depends_on) == null ? void 0 : _a.forEach((dependency) => edges.push([contractName, dependency]));
   });
   const sorted = (0, import_toposort.array)(nodes, edges).reverse();
   return sorted;
@@ -142,11 +224,11 @@ var defaultConfigFile = {
   clarinet: "."
 };
 function configFilePath(rootPath) {
-  return (0, import_path2.resolve)(rootPath, "clarigen.config.json");
+  return (0, import_path4.resolve)(rootPath, "clarigen.config.json");
 }
 async function configFileExists(configPath) {
   try {
-    await (0, import_promises2.access)(configPath, import_fs.constants.R_OK);
+    await (0, import_promises4.access)(configPath, import_fs2.constants.R_OK);
     return true;
   } catch (error) {
     return false;
@@ -156,7 +238,7 @@ async function getConfigFile(rootPath) {
   const fullPath = configFilePath(rootPath);
   const exists = await configFileExists(fullPath);
   if (exists) {
-    const configContents = await (0, import_promises2.readFile)(fullPath, { encoding: "utf-8" });
+    const configContents = await (0, import_promises4.readFile)(fullPath, { encoding: "utf-8" });
     const configFile = JSON.parse(configContents);
     return __spreadValues(__spreadValues({}, defaultConfigFile), configFile);
   }
@@ -165,11 +247,16 @@ async function getConfigFile(rootPath) {
 async function getProjectConfig(rootPath) {
   var _a, _b;
   const configFile = await getConfigFile(rootPath);
-  const clarinetPath = (0, import_path2.resolve)(rootPath, configFile.clarinet);
+  const clarinetPath = (0, import_path4.resolve)(rootPath, configFile.clarinet);
   const clarinet = await getClarinetConfig(clarinetPath);
   const accounts = await getClarinetAccounts(clarinetPath);
-  const contracts = getContractsFromClarinet(clarinet, accounts);
-  const contractsDir = (0, import_path2.relative)(process.cwd(), (0, import_path2.join)(configFile.clarinet, "contracts"));
+  let contracts;
+  try {
+    contracts = await getContractsFromDeployment(clarinetPath);
+  } catch (error) {
+    contracts = getContractsFromClarinet(clarinet, accounts);
+  }
+  const contractsDir = (0, import_path4.relative)(process.cwd(), (0, import_path4.join)(configFile.clarinet, "contracts"));
   return __spreadProps(__spreadValues({}, configFile), {
     outputDir: ((_a = clarinet.clarigen) == null ? void 0 : _a.output_dir) || configFile.outputDir,
     docs: ((_b = clarinet.clarigen) == null ? void 0 : _b.docs) || configFile.docs,
@@ -283,7 +370,7 @@ function makePureTypes(abi) {
 
 // src/generate/files.ts
 var import_core2 = require("@clarigen/core");
-var import_path3 = require("path");
+var import_path5 = require("path");
 var generateInterfaceFile = ({
   contractName,
   abi
@@ -370,8 +457,8 @@ export const accounts = {
     const contractVar = (0, import_core2.toCamelCase)(contractName);
     const contractInfo = `${contractVar}Info`;
     const contractInterface = `${(0, import_core2.toCamelCase)(contractName, true)}Contract`;
-    const dirName = (0, import_path3.dirname)(contract.file);
-    const importPath = `'./${(0, import_path3.join)(dirName || ".", contractName)}'`;
+    const dirName = (0, import_path5.dirname)(contract.file);
+    const importPath = `'./${contractName}'`;
     const _import = `import { ${contractInfo} } from ${importPath};`;
     imports.push(_import);
     const _export = `export type { ${contractInterface} } from ${importPath};`;
@@ -397,13 +484,13 @@ var import_command = require("@oclif/command");
 
 // src/utils.ts
 var import_native_bin2 = require("@clarigen/native-bin");
-var import_path7 = require("path");
-var import_promises6 = require("fs/promises");
+var import_path9 = require("path");
+var import_promises8 = require("fs/promises");
 
 // src/docs.ts
 var import_claridocs = require("@clarigen/claridocs");
-var import_promises3 = require("fs/promises");
-var import_path4 = require("path");
+var import_promises5 = require("fs/promises");
+var import_path6 = require("path");
 async function generateMarkdownDoc({
   contractFile,
   contractName,
@@ -411,18 +498,18 @@ async function generateMarkdownDoc({
   abi,
   dirName
 }) {
-  const contractSrc = await (0, import_promises3.readFile)(contractFile, { encoding: "utf-8" });
+  const contractSrc = await (0, import_promises5.readFile)(contractFile, { encoding: "utf-8" });
   const docs = (0, import_claridocs.createContractDocInfo)({ contractSrc, abi });
-  const folder = (0, import_path4.resolve)(process.cwd(), docsPath, dirName || ".");
-  const filePath = (0, import_path4.resolve)(folder, `${contractName}.md`);
+  const folder = (0, import_path6.resolve)(process.cwd(), docsPath, dirName || ".");
+  const filePath = (0, import_path6.resolve)(folder, `${contractName}.md`);
   const md = (0, import_claridocs.generateMarkdown)({
     contract: docs,
-    contractFile: (0, import_path4.relative)(folder, contractFile),
+    contractFile: (0, import_path6.relative)(folder, contractFile),
     contractName,
     abi
   });
-  await (0, import_promises3.mkdir)(folder, { recursive: true });
-  await (0, import_promises3.writeFile)(filePath, md);
+  await (0, import_promises5.mkdir)(folder, { recursive: true });
+  await (0, import_promises5.writeFile)(filePath, md);
 }
 async function generateDocsIndex(configFile) {
   if (!configFile.docs)
@@ -435,14 +522,14 @@ async function generateDocsIndex(configFile) {
 
 ${contractLines.join("\n")}
 `;
-  const filepath = (0, import_path4.resolve)(process.cwd(), configFile.docs, "README.md");
-  await (0, import_promises3.writeFile)(filepath, fileContents);
+  const filepath = (0, import_path6.resolve)(process.cwd(), configFile.docs, "README.md");
+  await (0, import_promises5.writeFile)(filepath, fileContents);
 }
 
 // src/generate/single.ts
 var import_core3 = require("@clarigen/core");
-var import_path5 = require("path");
-var import_promises4 = require("fs/promises");
+var import_path7 = require("path");
+var import_promises6 = require("fs/promises");
 var import_util = require("util");
 function generateContractMeta(contract) {
   const { abi } = contract;
@@ -480,7 +567,7 @@ function generateContractMeta(contract) {
     return mapLine;
   });
   const otherAbi = JSON.stringify(rest);
-  const contractFile = (0, import_path5.relative)(process.cwd(), contract.contractFile);
+  const contractFile = (0, import_path7.relative)(process.cwd(), contract.contractFile);
   return `{
   ${serializeLines("functions", functionLines)}
   ${serializeLines("variables", variableLines)}
@@ -545,116 +632,51 @@ function serializeLines(key, lines) {
   },`;
 }
 async function getSingleTypes() {
-  const typesPath = (0, import_path5.resolve)(__dirname, "../../dist/abi-types.ts.txt");
-  const typesFile = await (0, import_promises4.readFile)(typesPath, { encoding: "utf-8" });
+  const typesPath = (0, import_path7.resolve)(__dirname, "../../dist/abi-types.ts.txt");
+  const typesFile = await (0, import_promises6.readFile)(typesPath, { encoding: "utf-8" });
   return typesFile;
 }
 
-// src/writer.ts
-var import_promises5 = require("fs/promises");
-var import_path6 = require("path");
-var import_prettier = require("prettier");
-var defaultPrettierConfig = {
-  printWidth: 80,
-  semi: true,
-  singleQuote: true,
-  trailingComma: "es5"
-};
-async function resolvePrettierConfig() {
-  try {
-    const local = await (0, import_prettier.resolveConfig)(process.cwd());
-    if (local)
-      return local;
-  } catch (error) {
-  }
-  return defaultPrettierConfig;
-}
-async function formatFile(contents, path) {
-  try {
-    const fileName = (0, import_path6.basename)(path);
-    const config = await resolvePrettierConfig();
-    const formatted = (0, import_prettier.format)(contents, __spreadProps(__spreadValues({}, config), {
-      filepath: fileName
-    }));
-    return formatted;
-  } catch (error) {
-  }
-  return contents;
-}
-async function writeFile2(path, contents) {
-  const formatted = await formatFile(contents, path);
-  await (0, import_promises5.writeFile)(path, formatted);
-}
-
 // src/generate/vars.ts
 var import_core4 = require("@clarigen/core");
 var import_native_bin = require("@clarigen/native-bin");
 var import_clarity = require("micro-stacks/clarity");
-async function getVariables({
-  abi,
-  contractIdentifier,
-  provider
-}) {
-  const variableTransforms = abi.variables.map((variable) => {
-    return evalVariable({
-      variable,
-      provider,
-      contractIdentifier
-    });
-  });
-  const variables = await Promise.all(variableTransforms);
-  return variables;
-}
-async function evalVariable({
-  contractIdentifier,
-  variable,
-  provider
-}) {
-  const code = getEvalCode(variable);
-  const result = await (0, import_native_bin.evalRaw)({
-    contractAddress: contractIdentifier,
-    code,
-    provider
-  });
-  const resultCV = (0, import_clarity.hexToCV)(result.output_serialized);
-  const value = (0, import_core4.cvToValue)(resultCV, true);
-  return __spreadProps(__spreadValues({}, variable), {
-    defaultValue: value
-  });
-}
-function getEvalCode(variable) {
-  const { access: access2 } = variable;
-  if (access2 === "variable") {
-    return `(var-get ${variable.name})`;
+
+// src/deno-run.ts
+var import_child_process = require("child_process");
+var import_util2 = require("util");
+var exec = (0, import_util2.promisify)(import_child_process.exec);
+async function getClarinetSession(cwd) {
+  const scriptPath = "https://raw.githubusercontent.com/mechanismHQ/clarigen-deno/main/src/cli/print.ts";
+  const command = `clarinet run ${scriptPath}`;
+  try {
+    const result = await exec(command, { cwd });
+    const sessionJSON = result.stdout.split("\n")[1];
+    const session = JSON.parse(sessionJSON);
+    return session;
+  } catch (error) {
+    console.error(`Error getting clarinet session`);
+    throw error;
   }
-  return variable.name;
 }
 
-// src/utils.ts
-var generateFilesForContract = async ({
-  contractFile: _contractFile,
+// src/contract.ts
+var import_promises7 = require("fs/promises");
+var import_path8 = require("path");
+var generateFilesForContractWithSession = async ({
   outputFolder,
-  provider,
-  contractAddress,
+  sessionContract,
   dirName,
-  contractName,
-  docsPath
+  docsPath,
+  contractFile
 }) => {
-  const contractFile = (0, import_path7.resolve)(process.cwd(), _contractFile);
-  const contractIdentifier = `${contractAddress}.${contractName}`;
-  const abi = await (0, import_native_bin2.deployContract)({
-    contractIdentifier,
-    contractFilePath: contractFile,
-    provider
-  });
-  const variables = await getVariables({
-    abi,
-    contractIdentifier,
-    provider
-  });
+  const contractIdentifier = sessionContract.contract_id;
+  const [contractAddress, contractName] = contractIdentifier.split(".");
+  const abi = sessionContract.contract_interface;
+  const variables = [];
   const typesFile = generateTypesFile(abi, contractName);
   const indexFile = generateIndexFile({
-    contractFile: (0, import_path7.relative)(process.cwd(), contractFile),
+    contractFile: (0, import_path8.relative)(process.cwd(), contractFile),
     contractAddress,
     contractName
   });
@@ -668,11 +690,11 @@ var generateFilesForContract = async ({
       dirName
     });
   }
-  const outputPath = (0, import_path7.resolve)(outputFolder, dirName || ".", contractName);
-  await (0, import_promises6.mkdir)(outputPath, { recursive: true });
-  await writeFile2((0, import_path7.resolve)(outputPath, "abi.ts"), abiFile);
-  await writeFile2((0, import_path7.resolve)(outputPath, "index.ts"), indexFile);
-  await writeFile2((0, import_path7.resolve)(outputPath, "types.ts"), typesFile);
+  const outputPath = (0, import_path8.resolve)(outputFolder, dirName || ".", contractName);
+  await (0, import_promises7.mkdir)(outputPath, { recursive: true });
+  await writeFile((0, import_path8.resolve)(outputPath, "abi.ts"), abiFile);
+  await writeFile((0, import_path8.resolve)(outputPath, "index.ts"), indexFile);
+  await writeFile((0, import_path8.resolve)(outputPath, "types.ts"), typesFile);
   return {
     abi,
     contractFile,
@@ -682,38 +704,42 @@ var generateFilesForContract = async ({
     variables
   };
 };
+
+// src/utils.ts
 var generateProject = async (projectPath) => {
   const configFile = await getProjectConfig(projectPath);
   const { contractsDir, outputDir, contracts } = configFile;
-  const outputFolder = (0, import_path7.resolve)(projectPath, outputDir);
+  const outputFolder = (0, import_path9.resolve)(projectPath, outputDir);
   const provider = await (0, import_native_bin2.createClarityBin)();
   const metas = [];
-  for (const contract of contracts) {
-    const contractFile = (0, import_path7.resolve)(projectPath, contractsDir, contract.file);
-    const dirName = (0, import_path7.dirname)(contract.file);
-    const meta = await generateFilesForContract({
-      contractFile,
+  const session = await getClarinetSession((0, import_path9.resolve)(projectPath, configFile.clarinet));
+  for (const contract of session.contracts) {
+    const configContract = contracts.find((c) => c.name === contract.contract_id.split(".")[1]);
+    if (typeof configContract === "undefined") {
+      throw new Error(`No config contract found for ${contract.contract_id}`);
+    }
+    const contractFile = (0, import_path9.resolve)(projectPath, configFile.clarinet, configContract.file);
+    const meta = await generateFilesForContractWithSession({
+      sessionContract: contract,
       outputFolder,
-      provider,
-      contractAddress: contract.address,
-      dirName,
-      contractName: contract.name,
-      docsPath: configFile.docs
+      docsPath: configFile.docs,
+      contractFile
     });
     metas.push(meta);
   }
   const indexFile = generateProjectIndexFile(configFile);
   await generateDocsIndex(configFile);
-  const indexPath = (0, import_path7.resolve)(outputFolder, "index.ts");
-  await writeFile2(indexPath, indexFile);
+  const indexPath = (0, import_path9.resolve)(outputFolder, "index.ts");
+  await writeFile(indexPath, indexFile);
   const singleFile = await generateSingleFile(configFile, metas);
-  const singlePath = (0, import_path7.resolve)(outputFolder, "single.ts");
-  await writeFile2(singlePath, singleFile);
+  const singlePath = (0, import_path9.resolve)(outputFolder, "single.ts");
+  await writeFile(singlePath, singleFile);
+  await generateDeployments(configFile);
 };
 
 // src/commands/index.ts
 var import_chokidar = require("chokidar");
-var import_path8 = require("path");
+var import_path10 = require("path");
 var import_chalk = require("chalk");
 var import_ora = __toESM(require("ora"));
 var _Generate = class extends import_command.Command {
@@ -735,7 +761,7 @@ ${String(error.message)}`);
       }
       watcher.on("change", (path) => {
         const cb = async () => {
-          const file = (0, import_path8.basename)(path);
+          const file = (0, import_path10.basename)(path);
           spinner.clear();
           spinner.start(`Change detected for ${(0, import_chalk.green)(file)}, generating.`);
           try {
@@ -757,7 +783,11 @@ ${msg}`);
         void cb();
       });
     } else {
-      await generateProject(cwd);
+      try {
+        await generateProject(cwd);
+      } catch (error) {
+        console.log(error);
+      }
     }
   }
 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@clarigen/cli",
   "description": "A CLI for generating a Typescript interface for a Clarity contract.",
   "author": "Hank Stoever",
-  "version": "1.0.0-next.21",
+  "version": "1.0.0-next.25",
   "license": "MIT",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -30,6 +30,7 @@
   "devDependencies": {
     "@oclif/dev-cli": "^1.26.0",
     "@oclif/errors": "^1.3.4",
+    "@types/js-yaml": "^4.0.5",
     "@types/reserved-words": "0.1.0",
     "@types/toposort": "2.0.3",
     "@vercel/ncc": "0.27.0",
@@ -37,20 +38,23 @@
     "ts-node": "^9.1.1"
   },
   "dependencies": {
-    "@clarigen/core": "1.0.0-next.21",
-    "@clarigen/native-bin": "1.0.0-next.21",
-    "@clarigen/claridocs": "1.0.0-next.21",
-    "@ltd/j-toml": "1.12.2",
+    "@clarigen/claridocs": "1.0.0-next.25",
+    "@clarigen/core": "1.0.0-next.25",
+    "@clarigen/native-bin": "1.0.0-next.25",
+    "@iarna/toml": "^2.2.5",
     "@oclif/command": "^1.8.0",
     "@oclif/config": "^1.17.0",
     "@oclif/plugin-help": "3.2.3",
+    "@scure/bip32": "^1.1.0",
+    "@scure/bip39": "^1.1.0",
     "chalk": "4.1.0",
     "chokidar": "3.5.1",
-    "micro-stacks": "^0.2.0",
+    "js-yaml": "^4.1.0",
+    "micro-stacks": "^0.5.2",
     "ora": "5.4.0",
     "prettier": "2.6.2",
-    "toposort": "2.0.2",
-    "reserved-words": "0.1.2"
+    "reserved-words": "0.1.2",
+    "toposort": "2.0.2"
   },
   "publishConfig": {
     "access": "public"
@@ -65,6 +69,6 @@
     "lint": "eslint \"src/**/*.{ts,tsx}\" && prettier  --check src/**/*.ts",
     "typecheck": "tsc --noEmit -p tsconfig-test.json",
     "demo": "pnpm build && node bin/run",
-    "publish:dev": "yalc publish --push"
+    "publish:dev": "pnpm build && yalc publish --push"
   }
 }

package/src/clarinet-config.ts

@@ -1,4 +1,4 @@
-import { parse } from '@ltd/j-toml';
+import { parse } from '@iarna/toml';
 import { resolve } from 'path';
 import { readFile } from 'fs/promises';
 import { ConfigContract } from './config';
@@ -8,6 +8,8 @@ import {
 } from 'micro-stacks/wallet-sdk';
 import { array as toposort } from 'toposort';
 import { StacksNetworkVersion } from 'micro-stacks/crypto';
+import { parseDeployment } from './generate/deployment';
+import { SimnetDeploymentPlan } from '@clarigen/core';
 
 interface ClarinetConfigAccount {
   mnemonic: string;
@@ -29,15 +31,13 @@ export async function getClarinetDevConfig(
 ): Promise<ClarinetDevConfig> {
   const baseConfigPath = resolve(folder, 'settings', 'Devnet.toml');
   const configContents = await readFile(baseConfigPath, { encoding: 'utf-8' });
-  const config = parse(configContents, 1.0, '\n', true, {
-    longer: true,
-  }) as unknown as ClarinetDevConfig;
-  return config;
+  const config = parse(configContents);
+  return config as unknown as ClarinetDevConfig;
 }
 
 export interface ClarinetContract {
   path: string;
-  depends_on: string[];
+  depends_on?: string[];
 }
 
 export interface ClarinetContracts {
@@ -61,15 +61,31 @@ export const CLARINET_SETTINGS = [
 export async function getClarinetConfig(folder: string) {
   const baseConfigPath = resolve(folder, 'Clarinet.toml');
   const configContents = await readFile(baseConfigPath, { encoding: 'utf-8' });
-  const config = parse(
-    configContents,
-    1.0,
-    '\n',
-    true
-  ) as unknown as ClarinetConfig;
+  const config = parse(configContents) as unknown as ClarinetConfig;
   return config;
 }
 
+export async function getContractsFromDeployment(
+  clarinetPath?: string
+): Promise<ConfigContract[]> {
+  const simnetPath = resolve(
+    clarinetPath || process.cwd(),
+    'deployments/default.simnet-plan.yaml'
+  );
+  const deployment = (await parseDeployment(
+    simnetPath
+  )) as SimnetDeploymentPlan;
+  const txs = deployment.plan.batches[0].transactions;
+  return txs.map((_tx) => {
+    const tx = _tx['emulated-contract-publish'];
+    return {
+      file: tx.path,
+      name: tx['contract-name'],
+      address: tx['emulated-sender'],
+    };
+  });
+}
+
 export function getContractsFromClarinet(
   clarinetConfig: ClarinetConfig,
   accounts: ClarinetAccounts
@@ -93,7 +109,7 @@ export function sortClarinetContracts(contractsConfig: ClarinetContracts) {
   const nodes: string[] = [];
   Object.entries(contractsConfig).forEach(([contractName, info]) => {
     nodes.push(contractName);
-    info.depends_on.forEach((dependency) =>
+    info.depends_on?.forEach((dependency) =>
       edges.push([contractName, dependency])
     );
   });

package/src/commands/index.ts

@@ -66,7 +66,11 @@ export class Generate extends Command {
         void cb();
       });
     } else {
-      await generateProject(cwd);
+      try {
+        await generateProject(cwd);
+      } catch (error) {
+        console.log(error);
+      }
     }
   }
 }