@clarigen/cli 1.0.0-next.18 → 1.0.0-next.19

package/dist/commands/index.js

@@ -1,92 +1,757 @@
-var D=Object.defineProperty,jt=Object.defineProperties,Et=Object.getOwnPropertyDescriptor,It=Object.getOwnPropertyDescriptors,kt=Object.getOwnPropertyNames,S=Object.getOwnPropertySymbols;var H=Object.prototype.hasOwnProperty,rt=Object.prototype.propertyIsEnumerable;var et=(t,e,r)=>e in t?D(t,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[e]=r,y=(t,e)=>{for(var r in e||(e={}))H.call(e,r)&&et(t,r,e[r]);if(S)for(var r of S(e))rt.call(e,r)&&et(t,r,e[r]);return t},x=(t,e)=>jt(t,It(e));var V=(t,e)=>{var r={};for(var n in t)H.call(t,n)&&e.indexOf(n)<0&&(r[n]=t[n]);if(t!=null&&S)for(var n of S(t))e.indexOf(n)<0&&rt.call(t,n)&&(r[n]=t[n]);return r};var St=(t,e)=>{for(var r in e)D(t,r,{get:e[r],enumerable:!0})},Dt=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of kt(e))!H.call(t,o)&&o!==r&&D(t,o,{get:()=>e[o],enumerable:!(n=Et(e,o))||n.enumerable});return t};var Vt=t=>Dt(D({},"__esModule",{value:!0}),t);var re={};St(re,{Generate:()=>w});module.exports=Vt(re);var E=require("@oclif/command");var Wt=require("@clarigen/native-bin"),F=require("@clarigen/core"),B=require("path");var Ut=require("@oclif/command");var h=require("path"),L=require("fs/promises"),ct=require("fs");var Q=require("@ltd/j-toml"),X=require("path"),Y=require("fs/promises"),O=require("micro-stacks/wallet-sdk"),nt=require("toposort"),ot=require("micro-stacks/crypto");async function Ot(t){let e=(0,X.resolve)(t,"settings","Devnet.toml"),r=await(0,Y.readFile)(e,{encoding:"utf-8"});return(0,Q.parse)(r,1,`
-`,!0,{longer:!0})}async function Lt(t){let e=(0,X.resolve)(t,"Clarinet.toml"),r=await(0,Y.readFile)(e,{encoding:"utf-8"});return(0,Q.parse)(r,1,`
-`,!0)}async function it(t,e){let r=await Lt(t),n=e.deployer.address;return Mt(r.contracts).map(a=>({file:r.contracts[a].path.replace(/^contracts\//,""),address:n,name:a}))}function Mt(t){let e=[],r=[];return Object.entries(t).forEach(([o,i])=>{r.push(o),i.depends_on.forEach(a=>e.push([o,a]))}),(0,nt.array)(r,e).reverse()}async function st(t){let e=await Ot(t),r=await Promise.all(Object.entries(e.accounts).map(async([o,i])=>{let a=await(0,O.generateWallet)(i.mnemonic,"password"),[s]=a.accounts,l=(0,O.getStxAddressFromAccount)(s,ot.StacksNetworkVersion.testnetP2PKH);return[o,x(y({},i),{address:l})]}));return Object.fromEntries(r)}var at={outputDir:"src/clarigen",clarinet:"."};function _t(t){return(0,h.resolve)(t,"clarigen.config.json")}async function Bt(t){try{return await(0,L.access)(t,ct.constants.R_OK),!0}catch{return!1}}async function Jt(t){let e=_t(t);if(await Bt(e)){let n=await(0,L.readFile)(e,{encoding:"utf-8"}),o=JSON.parse(n);return y(y({},at),o)}return at}async function M(t){let e=await Jt(t),r=(0,h.resolve)(t,e.clarinet||"."),n=await st(r),o=await it(r,n),i=(0,h.relative)(process.cwd(),(0,h.join)(e.clarinet,"contracts"));return x(y({},e),{contracts:o,contractsDir:i,accounts:n,clarinet:e.clarinet||"."})}var m=require("micro-stacks/transactions"),_=require("@clarigen/core"),lt=require("reserved-words"),p=(t,e=!1)=>{if((0,m.isClarityAbiPrimitive)(t)){if(t==="uint128")return e?"number | bigint":"bigint";if(t==="int128")return e?"number | bigint":"bigint";if(t==="bool")return"boolean";if(t==="principal")return"string";if(t==="none")return"null";if(t==="trait_reference")return"string";throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(t)}`)}else{if((0,m.isClarityAbiBuffer)(t))return"Uint8Array";if((0,m.isClarityAbiResponse)(t)){let r=p(t.response.ok),n=p(t.response.error);return`Response<${r}, ${n}>`}else{if((0,m.isClarityAbiOptional)(t))return`${p(t.optional)} | null`;if((0,m.isClarityAbiTuple)(t)){let r=[];return t.tuple.forEach(({name:n,type:o})=>{let i=p(o);r.push(`"${n}": ${i}`)}),`{
-  ${r.join(`;
-  `)}
-    }`}else{if((0,m.isClarityAbiList)(t))return`${p(t.list.type)}[]`;if((0,m.isClarityAbiStringAscii)(t))return"string";if((0,m.isClarityAbiStringUtf8)(t))return"string";if(t==="trait_reference")return"string";throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(t)}`)}}}};function Z(t){let e=(0,_.toCamelCase)(t);return`${(0,lt.check)(e,6)?"_":""}${e}`}var Rt={public:"Public",read_only:"ReadOnly",private:"Private"};function ft(t){let e="";return t.functions.forEach((r,n)=>{let o=`${(0,_.toCamelCase)(r.name)}: `;if(o+=`(${r.args.map(s=>`${Z(s.name)}: ${p(s.type,!0)}`).join(", ")}) => `,o+=`ContractCalls.${Rt[r.access]}<`,r.access==="public"){let{type:s}=r.outputs;if(!(0,m.isClarityAbiResponse)(s))throw new Error("Expected response type for public function");let l=p(s.response.ok),f=p(s.response.error);o+=`${l}, ${f}>;`}else o+=`${p(r.outputs.type)}>;`;e+=`${n===0?"":`
-`}  ${o}`}),t.maps.forEach(r=>{let n=`${(0,_.toCamelCase)(r.name)}: `,o=p(r.key,!0),i=`key: ${o}`,a=p(r.value);n+=`(${i}) => ContractCalls.Map<${o}, ${a}>;`,e+=`
-  ${n}`}),e}var pt=({contractName:t,abi:e})=>{let r=(0,F.toCamelCase)(t,!0),s=e,{clarity_version:n}=s,o=V(s,["clarity_version"]),i=JSON.stringify(o,null,2);return`import { ClarityAbi } from '@clarigen/core';
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/index.ts
+var commands_exports = {};
+__export(commands_exports, {
+  Generate: () => Generate
+});
+module.exports = __toCommonJS(commands_exports);
+var import_command2 = require("@oclif/command");
+
+// src/generate/files.ts
+var import_native_bin = require("@clarigen/native-bin");
+var import_core2 = require("@clarigen/core");
+var import_path3 = 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");
+
+// 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_wallet_sdk = require("micro-stacks/wallet-sdk");
+var import_toposort = require("toposort");
+var import_crypto = require("micro-stacks/crypto");
+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
+  });
+  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);
+  return config;
+}
+async function getContractsFromClarinet(folder, accounts) {
+  const clarinetConfig = await getClarinetConfig(folder);
+  const deployerAddress = accounts.deployer.address;
+  const sortedContracts = sortClarinetContracts(clarinetConfig.contracts);
+  const contracts = sortedContracts.map((contractName) => {
+    const info = clarinetConfig.contracts[contractName];
+    const file = info.path.replace(/^contracts\//, "");
+    return {
+      file,
+      address: deployerAddress,
+      name: contractName
+    };
+  });
+  return contracts;
+}
+function sortClarinetContracts(contractsConfig) {
+  const edges = [];
+  const nodes = [];
+  Object.entries(contractsConfig).forEach(([contractName, info]) => {
+    nodes.push(contractName);
+    info.depends_on.forEach((dependency) => edges.push([contractName, dependency]));
+  });
+  const sorted = (0, import_toposort.array)(nodes, edges).reverse();
+  return sorted;
+}
+async function getClarinetAccounts(folder) {
+  const devConfig = await getClarinetDevConfig(folder);
+  const accountEntries = await Promise.all(Object.entries(devConfig.accounts).map(async ([key, info]) => {
+    const wallet = await (0, import_wallet_sdk.generateWallet)(info.mnemonic, "password");
+    const [account] = wallet.accounts;
+    const address = (0, import_wallet_sdk.getStxAddressFromAccount)(account, import_crypto.StacksNetworkVersion.testnetP2PKH);
+    return [
+      key,
+      __spreadProps(__spreadValues({}, info), {
+        address
+      })
+    ];
+  }));
+  const accounts = Object.fromEntries(accountEntries);
+  return accounts;
+}
+
+// src/config.ts
+var defaultConfigFile = {
+  outputDir: "src/clarigen",
+  clarinet: "."
+};
+function configFilePath(rootPath) {
+  return (0, import_path2.resolve)(rootPath, "clarigen.config.json");
+}
+async function configFileExists(configPath) {
+  try {
+    await (0, import_promises2.access)(configPath, import_fs.constants.R_OK);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+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 configFile = JSON.parse(configContents);
+    return __spreadValues(__spreadValues({}, defaultConfigFile), configFile);
+  }
+  return defaultConfigFile;
+}
+async function getProjectConfig(rootPath) {
+  const configFile = await getConfigFile(rootPath);
+  const clarinetPath = (0, import_path2.resolve)(rootPath, configFile.clarinet || ".");
+  const accounts = await getClarinetAccounts(clarinetPath);
+  const contracts = await getContractsFromClarinet(clarinetPath, accounts);
+  const contractsDir = (0, import_path2.relative)(process.cwd(), (0, import_path2.join)(configFile.clarinet, "contracts"));
+  return __spreadProps(__spreadValues({}, configFile), {
+    contracts,
+    contractsDir,
+    accounts,
+    clarinet: configFile.clarinet || "."
+  });
+}
+
+// src/generate/declaration.ts
+var import_transactions = require("micro-stacks/transactions");
+var import_core = require("@clarigen/core");
+var import_reserved_words = require("reserved-words");
+var jsTypeFromAbiType = (val, isArgument = false) => {
+  if ((0, import_transactions.isClarityAbiPrimitive)(val)) {
+    if (val === "uint128") {
+      if (isArgument)
+        return "number | bigint";
+      return "bigint";
+    } else if (val === "int128") {
+      if (isArgument)
+        return "number | bigint";
+      return "bigint";
+    } else if (val === "bool") {
+      return "boolean";
+    } else if (val === "principal") {
+      return "string";
+    } else if (val === "none") {
+      return "null";
+    } else if (val === "trait_reference") {
+      return "string";
+    } else {
+      throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);
+    }
+  } else if ((0, import_transactions.isClarityAbiBuffer)(val)) {
+    return "Uint8Array";
+  } else if ((0, import_transactions.isClarityAbiResponse)(val)) {
+    const ok = jsTypeFromAbiType(val.response.ok);
+    const err = jsTypeFromAbiType(val.response.error);
+    return `Response<${ok}, ${err}>`;
+  } else if ((0, import_transactions.isClarityAbiOptional)(val)) {
+    const innerType = jsTypeFromAbiType(val.optional);
+    return `${innerType} | null`;
+  } else if ((0, import_transactions.isClarityAbiTuple)(val)) {
+    const tupleDefs = [];
+    val.tuple.forEach(({ name, type }) => {
+      const innerType = jsTypeFromAbiType(type);
+      tupleDefs.push(`"${name}": ${innerType}`);
+    });
+    return `{
+  ${tupleDefs.join(";\n  ")}
+    }`;
+  } else if ((0, import_transactions.isClarityAbiList)(val)) {
+    const innerType = jsTypeFromAbiType(val.list.type);
+    return `${innerType}[]`;
+  } else if ((0, import_transactions.isClarityAbiStringAscii)(val)) {
+    return "string";
+  } else if ((0, import_transactions.isClarityAbiStringUtf8)(val)) {
+    return "string";
+  } else if (val === "trait_reference") {
+    return "string";
+  } else {
+    throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);
+  }
+};
+function getArgName(name) {
+  const camel = (0, import_core.toCamelCase)(name);
+  const prefix = (0, import_reserved_words.check)(camel, 6) ? "_" : "";
+  return `${prefix}${camel}`;
+}
+var accessToReturnType = {
+  public: "Public",
+  read_only: "ReadOnly",
+  private: "Private"
+};
+function makePureTypes(abi) {
+  let typings = "";
+  abi.functions.forEach((func, index) => {
+    let functionLine = `${(0, import_core.toCamelCase)(func.name)}: `;
+    const args = func.args.map((arg) => {
+      return `${getArgName(arg.name)}: ${jsTypeFromAbiType(arg.type, true)}`;
+    });
+    functionLine += `(${args.join(", ")}) => `;
+    const funcType = accessToReturnType[func.access];
+    functionLine += `ContractCalls.${funcType}<`;
+    if (func.access === "public") {
+      const { type } = func.outputs;
+      if (!(0, import_transactions.isClarityAbiResponse)(type))
+        throw new Error("Expected response type for public function");
+      const ok = jsTypeFromAbiType(type.response.ok);
+      const err = jsTypeFromAbiType(type.response.error);
+      functionLine += `${ok}, ${err}>;`;
+    } else {
+      const returnType = jsTypeFromAbiType(func.outputs.type);
+      functionLine += `${returnType}>;`;
+    }
+    typings += `${index === 0 ? "" : "\n"}  ${functionLine}`;
+  });
+  abi.maps.forEach((map) => {
+    let functionLine = `${(0, import_core.toCamelCase)(map.name)}: `;
+    const keyType = jsTypeFromAbiType(map.key, true);
+    const arg = `key: ${keyType}`;
+    const valType = jsTypeFromAbiType(map.value);
+    functionLine += `(${arg}) => ContractCalls.Map<${keyType}, ${valType}>;`;
+    typings += `
+  ${functionLine}`;
+  });
+  return typings;
+}
+
+// src/generate/files.ts
+var generateInterfaceFile = ({
+  contractName,
+  abi
+}) => {
+  const variableName = (0, import_core2.toCamelCase)(contractName, true);
+  const _a = abi, { clarity_version } = _a, rest = __objRest(_a, ["clarity_version"]);
+  const abiString = JSON.stringify(rest, null, 2);
+  const fileContents = `import { ClarityAbi } from '@clarigen/core';
 
 // prettier-ignore
-export const ${r}Interface: ClarityAbi = ${i};
-`},mt=({contractFile:t,contractAddress:e,contractName:r})=>{let n=(0,F.toCamelCase)(r,!0),o=(0,F.toCamelCase)(r),i=`${n}Contract`,a=`${n}Interface`;return`import { pureProxy, Contract } from '@clarigen/core';
-import type { ${i} } from './types';
-import { ${a} } from './abi';
-export type { ${i} } from './types';
-
-export function ${o}Contract(contractAddress: string, contractName: string) {
-  return pureProxy<${i}>({
-    abi: ${a},
+export const ${variableName}Interface: ClarityAbi = ${abiString};
+`;
+  return fileContents;
+};
+var generateIndexFile = ({
+  contractFile,
+  contractAddress,
+  contractName
+}) => {
+  const contractTitle = (0, import_core2.toCamelCase)(contractName, true);
+  const varName = (0, import_core2.toCamelCase)(contractName);
+  const contractType = `${contractTitle}Contract`;
+  const interfaceVar = `${contractTitle}Interface`;
+  const fileContents = `import { pureProxy, Contract } from '@clarigen/core';
+import type { ${contractType} } from './types';
+import { ${interfaceVar} } from './abi';
+export type { ${contractType} } from './types';
+
+export function ${varName}Contract(contractAddress: string, contractName: string) {
+  return pureProxy<${contractType}>({
+    abi: ${interfaceVar},
     contractAddress,
     contractName,
   });
 }
 
-export const ${o}Info: Contract<${i}> = {
-  contract: ${o}Contract,
-  address: '${e}',
-  contractFile: '${t}',
-  name: '${r}',
-  abi: ${a},
+export const ${varName}Info: Contract<${contractType}> = {
+  contract: ${varName}Contract,
+  address: '${contractAddress}',
+  contractFile: '${contractFile}',
+  name: '${contractName}',
+  abi: ${interfaceVar},
+};
+`;
+  return fileContents;
 };
-`},ut=(t,e)=>{let r=(0,F.toCamelCase)(e,!0),n=ft(t);return`import { Response, ContractCalls } from '@clarigen/core';
+var generateTypesFile = (abi, contractName) => {
+  const name = (0, import_core2.toCamelCase)(contractName, true);
+  const typings = makePureTypes(abi);
+  const fileContents = `import { Response, ContractCalls } from '@clarigen/core';
 
 // prettier-ignore
-export interface ${r}Contract {
-${n}
+export interface ${name}Contract {
+${typings}
 }
-`},gt=t=>{let e=["import type { ContractInstances } from '@clarigen/core';"],r=[],n=[],o="";"accounts"in t&&(o=`
+`;
+  return fileContents;
+};
+var generateProjectIndexFile = (config) => {
+  const imports = [
+    "import type { ContractInstances } from '@clarigen/core';"
+  ];
+  const exports = [];
+  const contractMap = [];
+  let accounts = "";
+  if ("accounts" in config) {
+    const accountLines = Object.keys(config.accounts).map((key) => {
+      const account = config.accounts[key];
+      return `"${key}": {
+    mnemonic: "${account.mnemonic}",
+    balance: ${account.balance.toString()}n,
+    address: "${account.address}",
+  },`;
+    });
+    accounts = `
 
 // prettier-ignore
 export const accounts = {
-  ${Object.keys(t.accounts).map(l=>{let f=t.accounts[l];return`"${l}": {
-    mnemonic: "${f.mnemonic}",
-    balance: ${f.balance.toString()}n,
-    address: "${f.address}",
-  },`}).join(`
-  `)}
-};`),t.contracts.forEach(s=>{let l=s.name,f=(0,F.toCamelCase)(l),b=`${f}Info`,A=`${(0,F.toCamelCase)(l,!0)}Contract`,C=(0,B.dirname)(s.file),$=`'./${(0,B.join)(C||".",l)}'`,c=`import { ${b} } from ${$};`;e.push(c);let u=`export type { ${A} } from ${$};`;r.push(u);let v=`${f}: ${b},`;n.push(v)});let i=`
+  ${accountLines.join("\n  ")}
+};`;
+  }
+  config.contracts.forEach((contract) => {
+    const contractName = contract.name;
+    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 _import = `import { ${contractInfo} } from ${importPath};`;
+    imports.push(_import);
+    const _export = `export type { ${contractInterface} } from ${importPath};`;
+    exports.push(_export);
+    const map = `${contractVar}: ${contractInfo},`;
+    contractMap.push(map);
+  });
+  const contractsType = `
 export type Contracts = ContractInstances<typeof contracts>;
-`;return`${e.join(`
-`)}
-${r.join(`
-`)}
-${i}
+`;
+  const file = `${imports.join("\n")}
+${exports.join("\n")}
+${contractsType}
+export const contracts = {
+  ${contractMap.join("\n  ")}
+};${accounts}
+`;
+  return file;
+};
+
+// src/utils.ts
+var import_native_bin3 = require("@clarigen/native-bin");
+var import_path7 = require("path");
+var import_promises6 = require("fs/promises");
+
+// src/docs.ts
+var import_claridocs = require("@clarigen/claridocs");
+var import_promises3 = require("fs/promises");
+var import_path4 = require("path");
+async function generateMarkdownDoc({
+  contractFile,
+  contractName,
+  docsPath,
+  abi,
+  dirName
+}) {
+  const contractSrc = await (0, import_promises3.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 md = (0, import_claridocs.generateMarkdown)({
+    contract: docs,
+    contractFile: (0, import_path4.relative)(folder, contractFile),
+    contractName,
+    abi
+  });
+  await (0, import_promises3.mkdir)(folder, { recursive: true });
+  await (0, import_promises3.writeFile)(filePath, md);
+}
+async function generateDocsIndex(configFile) {
+  if (!configFile.docs)
+    return;
+  const contractLines = configFile.contracts.map((contract) => {
+    const fileName = contract.file.replace(".clar", ".md");
+    return `- [\`${contract.name}\`](${fileName})`;
+  });
+  const fileContents = `# Contracts
+
+${contractLines.join("\n")}
+`;
+  const filepath = (0, import_path4.resolve)(process.cwd(), configFile.docs, "README.md");
+  await (0, import_promises3.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_util = require("util");
+function generateContractMeta(contract) {
+  const { abi } = contract;
+  const functionLines = [];
+  const _a = abi, { functions, variables, maps } = _a, rest = __objRest(_a, ["functions", "variables", "maps"]);
+  functions.forEach((func) => {
+    let functionLine = `${(0, import_core3.toCamelCase)(func.name)}: `;
+    const args = func.args.map((arg) => {
+      return `${getArgName(arg.name)}: ${jsTypeFromAbiType(arg.type, true)}`;
+    });
+    const argsTuple = `[${args.join(", ")}]`;
+    const funcDef = JSON.stringify(func);
+    functionLine += funcDef;
+    const retType = jsTypeFromAbiType(func.outputs.type);
+    functionLine += ` as TypedAbiFunction<${argsTuple}, ${retType}>`;
+    functionLines.push(functionLine);
+  });
+  const variableLines = contract.variables.map((v) => {
+    let varLine = `${(0, import_core3.toCamelCase)(v.name)}: `;
+    const type = jsTypeFromAbiType(v.type);
+    const varJSON = (0, import_util.inspect)(v, false, null, false);
+    varLine += `${varJSON} as TypedAbiVariable<${type}>`;
+    return varLine;
+  });
+  const constants2 = contract.variables.filter((v) => v.access === "constant");
+  const constantLines = constants2.map((constant) => {
+    return `"${(0, import_core3.toCamelCase)(constant.name)}": ${serialize(constant.defaultValue)}`;
+  });
+  const mapLines = maps.map((map) => {
+    let mapLine = `${(0, import_core3.toCamelCase)(map.name)}: `;
+    const keyType = jsTypeFromAbiType(map.key);
+    const valType = jsTypeFromAbiType(map.value);
+    mapLine += JSON.stringify(map);
+    mapLine += ` as TypedAbiMap<${keyType}, ${valType}>`;
+    return mapLine;
+  });
+  const otherAbi = JSON.stringify(rest);
+  const contractFile = (0, import_path5.relative)(process.cwd(), contract.contractFile);
+  return `{
+  ${serializeLines("functions", functionLines)}
+  ${serializeLines("variables", variableLines)}
+  ${serializeLines("maps", mapLines)}
+  ${serializeLines("constants", constantLines)}
+  ${otherAbi.slice(1, -1)},
+  contractName: '${contract.contractName}',
+  contractFile: '${contractFile}',
+  }`;
+}
+async function generateSingleFile(config, contracts) {
+  const contractDefs = contracts.map((contract) => {
+    const meta = generateContractMeta(contract);
+    const keyName = (0, import_core3.toCamelCase)(contract.contractName);
+    return `${keyName}: ${meta}`;
+  });
+  const types = await getSingleTypes();
+  const accounts = generateAccounts(config);
+  const file = `
+${types}
+
 export const contracts = {
-  ${n.join(`
-  `)}
-};${o}
-`};var K=require("@clarigen/native-bin"),g=require("path"),Tt=require("fs/promises");var J=require("@clarigen/claridocs"),T=require("fs/promises"),P=require("path");async function Ct({contractFile:t,contractName:e,docsPath:r,abi:n,dirName:o}){let i=await(0,T.readFile)(t,{encoding:"utf-8"}),a=(0,J.createContractDocInfo)({contractSrc:i,abi:n}),s=(0,P.resolve)(process.cwd(),r,o||"."),l=(0,P.resolve)(s,`${e}.md`),f=(0,J.generateMarkdown)({contract:a,contractFile:(0,P.relative)(s,t),contractName:e,abi:n});await(0,T.mkdir)(s,{recursive:!0}),await(0,T.writeFile)(l,f)}async function yt(t){if(!t.docs)return;let r=`# Contracts
-
-${t.contracts.map(o=>{let i=o.file.replace(".clar",".md");return`- [\`${o.name}\`](${i})`}).join(`
-`)}
-`,n=(0,P.resolve)(process.cwd(),t.docs,"README.md");await(0,T.writeFile)(n,r)}var N=require("@clarigen/core");var U=require("path"),dt=require("fs/promises"),W=require("util");function zt(t){let{abi:e}=t,r=[],$=e,{functions:n,variables:o,maps:i}=$,a=V($,["functions","variables","maps"]);n.forEach(c=>{let u=`${(0,N.toCamelCase)(c.name)}: `,k=`[${c.args.map(tt=>`${Z(tt.name)}: ${p(tt.type,!0)}`).join(", ")}]`;u+=JSON.stringify(c);let Nt=p(c.outputs.type);u+=` as TypedAbiFunction<${k}, ${Nt}>`,r.push(u)});let s=t.variables.map(c=>{let u=`${(0,N.toCamelCase)(c.name)}: `,v=p(c.type);return u+=`${(0,W.inspect)(c,!1,null,!1)} as TypedAbiVariable<${v}>`,u}),f=t.variables.filter(c=>c.access==="constant").map(c=>`"${(0,N.toCamelCase)(c.name)}": ${qt(c.defaultValue)}`),b=i.map(c=>{let u=`${(0,N.toCamelCase)(c.name)}: `,v=p(c.key),k=p(c.value);return u+=JSON.stringify(c),u+=` as TypedAbiMap<${v}, ${k}>`,u}),A=JSON.stringify(a),C=(0,U.relative)(process.cwd(),t.contractFile);return`{
-  ${R("functions",r)}
-  ${R("variables",s)}
-  ${R("maps",b)}
-  ${R("constants",f)}
-  ${A.slice(1,-1)},
-  contractName: '${t.contractName}',
-  contractFile: '${C}',
-  }`}async function $t(t,e){let r=e.map(a=>{let s=zt(a);return`${(0,N.toCamelCase)(a.contractName)}: ${s}`}),n=await Ht(),o=Kt(t);return`
-${n}
-
-export const contracts: Record<string, TypedAbi> = {
-  ${r.join(`,
-`)}
+  ${contractDefs.join(",\n")}
 } as const;
 
-${o}
-`}function Kt(t){let e="";return"accounts"in t&&(e=`export const accounts = {
-  ${Object.keys(t.accounts).map(n=>{let o=t.accounts[n];return`"${n}": {
-    mnemonic: "${o.mnemonic}",
-    balance: ${o.balance.toString()}n,
-    address: "${o.address}",
-  },`}).join(`
-  `)}
-} as const;`),e}Uint8Array.prototype[W.inspect.custom]=function(){return`Uint8Array.from([${this.join(",")}])`};function qt(t){return(0,W.inspect)(t,!1,null,!1)}function R(t,e){return`"${t}": {
-    ${e.join(`,
-    `)}
-  },`}async function Ht(){let t=(0,U.resolve)(__dirname,"../../../core/src/abi-types.ts");return await(0,dt.readFile)(t,{encoding:"utf-8"})}var bt=require("fs/promises"),xt=require("path"),z=require("prettier"),Qt={printWidth:80,semi:!0,singleQuote:!0,trailingComma:"es5"};async function Xt(){try{let t=await(0,z.resolveConfig)(process.cwd());if(t)return t}catch{}return Qt}async function Yt(t,e){try{let r=(0,xt.basename)(e),n=await Xt();return(0,z.format)(t,x(y({},n),{filepath:r}))}catch{}return t}async function j(t,e){let r=await Yt(e,t);await(0,bt.writeFile)(t,r)}var wt=require("@clarigen/core"),At=require("@clarigen/native-bin"),ht=require("micro-stacks/clarity");async function Ft({abi:t,contractIdentifier:e,provider:r}){let n=t.variables.map(i=>Zt({variable:i,provider:r,contractIdentifier:e}));return await Promise.all(n)}async function Zt({contractIdentifier:t,variable:e,provider:r}){let n=Gt(e),o=await(0,At.evalRaw)({contractAddress:t,code:n,provider:r}),i=(0,ht.hexToCV)(o.output_serialized),a=(0,wt.cvToValue)(i,!0);return x(y({},e),{defaultValue:a})}function Gt(t){let{access:e}=t;return e==="variable"?`(var-get ${t.name})`:t.name}var te=async({contractFile:t,outputFolder:e,provider:r,contractAddress:n,dirName:o,contractName:i,docsPath:a})=>{let s=(0,g.resolve)(process.cwd(),t),l=`${n}.${i}`,f=await(0,K.deployContract)({contractIdentifier:l,contractFilePath:s,provider:r}),b=await Ft({abi:f,contractIdentifier:l,provider:r}),A=ut(f,i),C=mt({contractFile:(0,g.relative)(process.cwd(),s),contractAddress:n,contractName:i}),$=pt({contractName:i,abi:f});typeof a<"u"&&await Ct({contractFile:s,contractName:i,abi:f,docsPath:a,dirName:o});let c=(0,g.resolve)(e,o||".",i);return await(0,Tt.mkdir)(c,{recursive:!0}),await j((0,g.resolve)(c,"abi.ts"),$),await j((0,g.resolve)(c,"index.ts"),C),await j((0,g.resolve)(c,"types.ts"),A),{abi:f,contractFile:s,contractName:i,dirName:o,contractAddress:n,variables:b}},q=async t=>{let e=await M(t),{contractsDir:r,outputDir:n,contracts:o}=e,i=(0,g.resolve)(t,n),a=await(0,K.createClarityBin)(),s=[];for(let C of o){let $=(0,g.resolve)(t,r,C.file),c=(0,g.dirname)(C.file),u=await te({contractFile:$,outputFolder:i,provider:a,contractAddress:C.address,dirName:c,contractName:C.name,docsPath:e.docs});s.push(u)}let l=gt(e);await yt(e);let f=(0,g.resolve)(i,"index.ts");await j(f,l);let b=await $t(e,s),A=(0,g.resolve)(i,"single.ts");await j(A,b)};var vt=require("chokidar"),Pt=require("path"),I=require("chalk"),ee=require("ora"),G=class extends E.Command{async run(){let{flags:e}=this.parse(G),r=process.cwd();if(e.watch){let n=ee("Generating files").start(),{contractsDir:o}=await M(r),i=(0,vt.watch)([o],{cwd:r});try{await q(r),n.succeed("Finished generating files. Watching for changes.")}catch(a){n.fail(`Error generating files.
-${a.message}`)}i.on("change",async a=>{let s=(0,Pt.basename)(a);n.clear(),n.start(`Change detected for ${(0,I.green)(s)}, generating.`);try{await q(r),n.succeed(`Finished generating files for ${(0,I.green)(s)}. Watching for changes.`)}catch(l){let f=l.message;n.fail(`Error after saving ${(0,I.red)(s)}.
-${f}`)}}),process.on("SIGINT",async()=>{await i.close(),process.exit()})}else await q(r)}},w=G;w.description="Generate project files",w.strict=!0,w.hidden=!1,w.flags={help:E.flags.help({char:"h"}),watch:E.flags.boolean({char:"w",description:"Watch for changes to your contracts"})},w.args=[];0&&(module.exports={Generate});
+${accounts}
+`;
+  return file;
+}
+function generateAccounts(config) {
+  let accounts = "";
+  if ("accounts" in config) {
+    const accountLines = Object.keys(config.accounts).map((key) => {
+      const account = config.accounts[key];
+      return `"${key}": {
+    mnemonic: "${account.mnemonic}",
+    balance: ${account.balance.toString()}n,
+    address: "${account.address}",
+  },`;
+    });
+    accounts = `export const accounts = {
+  ${accountLines.join("\n  ")}
+} as const;`;
+  }
+  return accounts;
+}
+Uint8Array.prototype[import_util.inspect.custom] = function() {
+  return `Uint8Array.from([${this.join(",")}])`;
+};
+function serialize(obj) {
+  return (0, import_util.inspect)(obj, {
+    showHidden: false,
+    maxArrayLength: null,
+    maxStringLength: null,
+    depth: null,
+    colors: false
+  });
+}
+function serializeLines(key, lines) {
+  return `"${key}": {
+    ${lines.join(",\n    ")}
+  },`;
+}
+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" });
+  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_bin2 = 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_bin2.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/utils.ts
+var generateFilesForContract = async ({
+  contractFile: _contractFile,
+  outputFolder,
+  provider,
+  contractAddress,
+  dirName,
+  contractName,
+  docsPath
+}) => {
+  const contractFile = (0, import_path7.resolve)(process.cwd(), _contractFile);
+  const contractIdentifier = `${contractAddress}.${contractName}`;
+  const abi = await (0, import_native_bin3.deployContract)({
+    contractIdentifier,
+    contractFilePath: contractFile,
+    provider
+  });
+  const variables = await getVariables({
+    abi,
+    contractIdentifier,
+    provider
+  });
+  const typesFile = generateTypesFile(abi, contractName);
+  const indexFile = generateIndexFile({
+    contractFile: (0, import_path7.relative)(process.cwd(), contractFile),
+    contractAddress,
+    contractName
+  });
+  const abiFile = generateInterfaceFile({ contractName, abi });
+  if (typeof docsPath !== "undefined") {
+    await generateMarkdownDoc({
+      contractFile,
+      contractName,
+      abi,
+      docsPath,
+      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);
+  return {
+    abi,
+    contractFile,
+    contractName,
+    dirName,
+    contractAddress,
+    variables
+  };
+};
+var generateProject = async (projectPath) => {
+  const configFile = await getProjectConfig(projectPath);
+  const { contractsDir, outputDir, contracts } = configFile;
+  const outputFolder = (0, import_path7.resolve)(projectPath, outputDir);
+  const provider = await (0, import_native_bin3.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,
+      outputFolder,
+      provider,
+      contractAddress: contract.address,
+      dirName,
+      contractName: contract.name,
+      docsPath: configFile.docs
+    });
+    metas.push(meta);
+  }
+  const indexFile = generateProjectIndexFile(configFile);
+  await generateDocsIndex(configFile);
+  const indexPath = (0, import_path7.resolve)(outputFolder, "index.ts");
+  await writeFile2(indexPath, indexFile);
+  const singleFile = await generateSingleFile(configFile, metas);
+  const singlePath = (0, import_path7.resolve)(outputFolder, "single.ts");
+  await writeFile2(singlePath, singleFile);
+};
+
+// src/commands/index.ts
+var import_chokidar = require("chokidar");
+var import_path8 = require("path");
+var import_chalk = require("chalk");
+var ora = require("ora");
+var _Generate = class extends import_command2.Command {
+  async run() {
+    const { flags: flags2 } = this.parse(_Generate);
+    const cwd = process.cwd();
+    if (flags2.watch) {
+      const spinner = ora("Generating files").start();
+      const { contractsDir } = await getProjectConfig(cwd);
+      const watcher = (0, import_chokidar.watch)([contractsDir], {
+        cwd
+      });
+      try {
+        await generateProject(cwd);
+        spinner.succeed(`Finished generating files. Watching for changes.`);
+      } catch (error) {
+        spinner.fail(`Error generating files.
+${error.message}`);
+      }
+      watcher.on("change", async (path) => {
+        const file = (0, import_path8.basename)(path);
+        spinner.clear();
+        spinner.start(`Change detected for ${(0, import_chalk.green)(file)}, generating.`);
+        try {
+          await generateProject(cwd);
+          spinner.succeed(`Finished generating files for ${(0, import_chalk.green)(file)}. Watching for changes.`);
+        } catch (error) {
+          const msg = error.message;
+          spinner.fail(`Error after saving ${(0, import_chalk.red)(file)}.
+${msg}`);
+        }
+      });
+      process.on("SIGINT", async () => {
+        await watcher.close();
+        process.exit();
+      });
+    } else {
+      await generateProject(cwd);
+    }
+  }
+};
+var Generate = _Generate;
+Generate.description = `Generate project files`;
+Generate.strict = true;
+Generate.hidden = false;
+Generate.flags = {
+  help: import_command2.flags.help({ char: "h" }),
+  watch: import_command2.flags.boolean({
+    char: "w",
+    description: "Watch for changes to your contracts"
+  })
+};
+Generate.args = [];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Generate
+});