@clarigen/cli 1.0.0-next.22 → 1.0.0-next.26

package/dist/commands/index.js

@@ -58,35 +58,118 @@ var import_command2 = require("@oclif/command");
 
 // src/generate/files.ts
 var import_core2 = require("@clarigen/core");
-var import_path3 = require("path");
+var import_path5 = require("path");
 
 // src/index.ts
 var import_command = 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_toml = require("@iarna/toml");
-var import_path = require("path");
-var import_promises = require("fs/promises");
+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 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 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);
@@ -132,14 +215,15 @@ async function getClarinetAccounts(folder) {
 // src/config.ts
 var defaultConfigFile = {
   outputDir: "src/clarigen",
-  clarinet: "."
+  clarinet: ".",
+  legacy: false
 };
 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;
@@ -149,7 +233,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);
   }
@@ -158,11 +242,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,
@@ -361,8 +450,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};`;
@@ -385,13 +474,13 @@ export const contracts = {
 
 // src/utils.ts
 var import_native_bin2 = require("@clarigen/native-bin");
-var import_path8 = require("path");
-var import_promises7 = 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,
@@ -399,18 +488,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)
@@ -423,14 +512,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;
@@ -468,7 +557,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)}
@@ -533,143 +622,49 @@ 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})`;
-  }
-  return variable.name;
-}
 
-// src/generate/deployment.ts
-var import_js_yaml = require("js-yaml");
-var import_promises6 = require("fs/promises");
-var import_path7 = require("path");
-var import_fs2 = require("fs");
-async function parseDeployment(path) {
-  const contents = await (0, import_promises6.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_path7.resolve)(process.cwd(), config.clarinet, "deployments", file);
-  if ((0, import_fs2.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_path7.resolve)(config.outputDir, "deployments", `${network}.ts`);
-    await writeFile2(outputFile, contents);
+// 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;
   }
 }
-async function generateDeployments(config) {
-  const networks = ["devnet", "simnet", "testnet", "mainnet"];
-  const folder = (0, import_path7.resolve)(process.cwd(), config.outputDir, "deployments");
-  await (0, import_promises6.mkdir)(folder, { recursive: true });
-  const generates = networks.map((n) => generateDeployment(n, config));
-  await Promise.all(generates);
-}
 
-// 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,
+  legacy = false
 }) => {
-  const contractFile = (0, import_path8.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_path8.relative)(process.cwd(), contractFile),
@@ -686,11 +681,13 @@ var generateFilesForContract = async ({
       dirName
     });
   }
-  const outputPath = (0, import_path8.resolve)(outputFolder, dirName || ".", contractName);
-  await (0, import_promises7.mkdir)(outputPath, { recursive: true });
-  await writeFile2((0, import_path8.resolve)(outputPath, "abi.ts"), abiFile);
-  await writeFile2((0, import_path8.resolve)(outputPath, "index.ts"), indexFile);
-  await writeFile2((0, import_path8.resolve)(outputPath, "types.ts"), typesFile);
+  if (legacy) {
+    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,
@@ -700,39 +697,46 @@ 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_path8.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_path8.resolve)(projectPath, contractsDir, contract.file);
-    const dirName = (0, import_path8.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,
+      legacy: configFile.legacy
     });
     metas.push(meta);
   }
-  const indexFile = generateProjectIndexFile(configFile);
   await generateDocsIndex(configFile);
-  const indexPath = (0, import_path8.resolve)(outputFolder, "index.ts");
-  await writeFile2(indexPath, indexFile);
-  const singleFile = await generateSingleFile(configFile, metas);
-  const singlePath = (0, import_path8.resolve)(outputFolder, "single.ts");
-  await writeFile2(singlePath, singleFile);
+  if (configFile.legacy) {
+    const indexFile = generateProjectIndexFile(configFile);
+    const indexPath = (0, import_path9.resolve)(outputFolder, "index.ts");
+    await writeFile(indexPath, indexFile);
+  }
+  const singleFileContents = await generateSingleFile(configFile, metas);
+  const singleFile = configFile.legacy ? "single.ts" : "index.ts";
+  const singlePath = (0, import_path9.resolve)(outputFolder, singleFile);
+  await writeFile(singlePath, singleFileContents);
   await generateDeployments(configFile);
 };
 
 // src/commands/index.ts
 var import_chokidar = require("chokidar");
-var import_path9 = require("path");
+var import_path10 = require("path");
 var import_chalk = require("chalk");
 var import_ora = __toESM(require("ora"));
 var _Generate = class extends import_command2.Command {
@@ -754,7 +758,7 @@ ${String(error.message)}`);
       }
       watcher.on("change", (path) => {
         const cb = async () => {
-          const file = (0, import_path9.basename)(path);
+          const file = (0, import_path10.basename)(path);
           spinner.clear();
           spinner.start(`Change detected for ${(0, import_chalk.green)(file)}, generating.`);
           try {
@@ -776,7 +780,11 @@ ${msg}`);
         void cb();
       });
     } else {
-      await generateProject(cwd);
+      try {
+        await generateProject(cwd);
+      } catch (error) {
+        console.log(error);
+      }
     }
   }
 };