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

package/dist/index.js

@@ -1,105 +1,792 @@
-var V=Object.defineProperty,Dt=Object.defineProperties,Vt=Object.getOwnPropertyDescriptor,Ot=Object.getOwnPropertyDescriptors,Lt=Object.getOwnPropertyNames,D=Object.getOwnPropertySymbols;var Q=Object.prototype.hasOwnProperty,ct=Object.prototype.propertyIsEnumerable;var at=(t,e,r)=>e in t?V(t,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[e]=r,d=(t,e)=>{for(var r in e||(e={}))Q.call(e,r)&&at(t,r,e[r]);if(D)for(var r of D(e))ct.call(e,r)&&at(t,r,e[r]);return t},w=(t,e)=>Dt(t,Ot(e));var O=(t,e)=>{var r={};for(var n in t)Q.call(t,n)&&e.indexOf(n)<0&&(r[n]=t[n]);if(t!=null&&D)for(var n of D(t))e.indexOf(n)<0&&ct.call(t,n)&&(r[n]=t[n]);return r};var Mt=(t,e)=>{for(var r in e)V(t,r,{get:e[r],enumerable:!0})},_t=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of Lt(e))!Q.call(t,o)&&o!==r&&V(t,o,{get:()=>e[o],enumerable:!(n=Vt(e,o))||n.enumerable});return t};var Bt=t=>_t(V({},"__esModule",{value:!0}),t);var ne={};Mt(ne,{Generate:()=>A,configFileExists:()=>Ct,configFilePath:()=>gt,defaultConfigFile:()=>G,generateIndexFile:()=>rt,generateInterface:()=>zt,generateInterfaceFile:()=>et,generateProjectIndexFile:()=>ot,generateTypesFile:()=>nt,getArgName:()=>B,getConfigFile:()=>yt,getProjectConfig:()=>E,jsTypeFromAbiType:()=>p,makePureTypes:()=>tt,run:()=>kt.run});module.exports=Bt(ne);var kt=require("@oclif/command");var h=require("path"),M=require("fs/promises"),ut=require("fs");var X=require("@ltd/j-toml"),Y=require("path"),Z=require("fs/promises"),L=require("micro-stacks/wallet-sdk"),lt=require("toposort"),ft=require("micro-stacks/crypto");async function Jt(t){let e=(0,Y.resolve)(t,"settings","Devnet.toml"),r=await(0,Z.readFile)(e,{encoding:"utf-8"});return(0,X.parse)(r,1,`
-`,!0,{longer:!0})}async function Rt(t){let e=(0,Y.resolve)(t,"Clarinet.toml"),r=await(0,Z.readFile)(e,{encoding:"utf-8"});return(0,X.parse)(r,1,`
-`,!0)}async function pt(t,e){let r=await Rt(t),n=e.deployer.address;return Ut(r.contracts).map(a=>({file:r.contracts[a].path.replace(/^contracts\//,""),address:n,name:a}))}function Ut(t){let e=[],r=[];return Object.entries(t).forEach(([o,i])=>{r.push(o),i.depends_on.forEach(a=>e.push([o,a]))}),(0,lt.array)(r,e).reverse()}async function mt(t){let e=await Jt(t),r=await Promise.all(Object.entries(e.accounts).map(async([o,i])=>{let a=await(0,L.generateWallet)(i.mnemonic,"password"),[s]=a.accounts,f=(0,L.getStxAddressFromAccount)(s,ft.StacksNetworkVersion.testnetP2PKH);return[o,w(d({},i),{address:f})]}));return Object.fromEntries(r)}var G={outputDir:"src/clarigen",clarinet:"."};function gt(t){return(0,h.resolve)(t,"clarigen.config.json")}async function Ct(t){try{return await(0,M.access)(t,ut.constants.R_OK),!0}catch{return!1}}async function yt(t){let e=gt(t);if(await Ct(e)){let n=await(0,M.readFile)(e,{encoding:"utf-8"}),o=JSON.parse(n);return d(d({},G),o)}return G}async function E(t){let e=await yt(t),r=(0,h.resolve)(t,e.clarinet||"."),n=await mt(r),o=await pt(r,n),i=(0,h.relative)(process.cwd(),(0,h.join)(e.clarinet,"contracts"));return w(d({},e),{contracts:o,contractsDir:i,accounts:n,clarinet:e.clarinet||"."})}var m=require("micro-stacks/transactions"),_=require("@clarigen/core"),dt=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 B(t){let e=(0,_.toCamelCase)(t);return`${(0,dt.check)(e,6)?"_":""}${e}`}var Wt={public:"Public",read_only:"ReadOnly",private:"Private"};function tt(t){let e="";return t.functions.forEach((r,n)=>{let o=`${(0,_.toCamelCase)(r.name)}: `;if(o+=`(${r.args.map(s=>`${B(s.name)}: ${p(s.type,!0)}`).join(", ")}) => `,o+=`ContractCalls.${Wt[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 f=p(s.response.ok),l=p(s.response.error);o+=`${f}, ${l}>;`}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 $t=require("@clarigen/native-bin"),F=require("@clarigen/core"),J=require("path");var zt=async({provider:t,contractFile:e,contractAddress:r,contractName:n})=>{let o=await t.runCommand(["launch",`${r}.${n}`,e,t.dbFilePath,"--output_analysis","--costs","--assets"]);if((0,$t.hasStdErr)(o.stderr))throw new Error(`Error on ${e}:
-  ${o.stderr}
-    `);let i=JSON.parse(o.stdout);if(i.error){let{initialization:s}=i.error;if(s!=null&&s.includes(`
-Near:
-`)){let[f,l]=s.split(`
-Near:
-`),y="",C=/start_line: (\d+),/.exec(l);throw C&&(y=C[1]),new Error(`Error on ${e}:
-    ${f}
-    ${y?`Near line ${y}`:""}
-    Raw trace:
-    ${l}
-      `)}throw new Error(`Error on ${e}:
-  ${JSON.stringify(i.error,null,2)}
-    `)}return i.analysis},et=({contractName:t,abi:e})=>{let r=(0,F.toCamelCase)(t,!0),s=e,{clarity_version:n}=s,o=O(s,["clarity_version"]),i=JSON.stringify(o,null,2);return`import { ClarityAbi } from '@clarigen/core';
+var __create = Object.create;
+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 __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Generate: () => Generate,
+  configFileExists: () => configFileExists,
+  configFilePath: () => configFilePath,
+  defaultConfigFile: () => defaultConfigFile,
+  generateIndexFile: () => generateIndexFile,
+  generateInterfaceFile: () => generateInterfaceFile,
+  generateProjectIndexFile: () => generateProjectIndexFile,
+  generateTypesFile: () => generateTypesFile,
+  getArgName: () => getArgName,
+  getConfigFile: () => getConfigFile,
+  getProjectConfig: () => getProjectConfig,
+  jsTypeFromAbiType: () => jsTypeFromAbiType,
+  makePureTypes: () => makePureTypes,
+  run: () => import_command2.run
+});
+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");
+
+// 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;
+}
+function getContractsFromClarinet(clarinetConfig, accounts) {
+  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) {
+  var _a, _b;
+  const configFile = await getConfigFile(rootPath);
+  const clarinetPath = (0, import_path2.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"));
+  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,
+    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 import_core2 = require("@clarigen/core");
+var import_path3 = require("path");
+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};
-`},rt=({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;
 };
-`},nt=(t,e)=>{let r=(0,F.toCamelCase)(e,!0),n=tt(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}
 }
-`},ot=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(f=>{let l=t.accounts[f];return`"${f}": {
-    mnemonic: "${l.mnemonic}",
-    balance: ${l.balance.toString()}n,
-    address: "${l.address}",
-  },`}).join(`
-  `)}
-};`),t.contracts.forEach(s=>{let f=s.name,l=(0,F.toCamelCase)(f),y=`${l}Info`,x=`${(0,F.toCamelCase)(f,!0)}Contract`,C=(0,J.dirname)(s.file),b=`'./${(0,J.join)(C||".",f)}'`,c=`import { ${y} } from ${b};`;e.push(c);let u=`export type { ${x} } from ${b};`;r.push(u);let v=`${l}: ${y},`;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 = {
-  ${n.join(`
-  `)}
-};${o}
-`};var I=require("@oclif/command");var q=require("@clarigen/native-bin"),g=require("path"),jt=require("fs/promises");var R=require("@clarigen/claridocs"),T=require("fs/promises"),P=require("path");async function bt({contractFile:t,contractName:e,docsPath:r,abi:n,dirName:o}){let i=await(0,T.readFile)(t,{encoding:"utf-8"}),a=(0,R.createContractDocInfo)({contractSrc:i,abi:n}),s=(0,P.resolve)(process.cwd(),r,o||"."),f=(0,P.resolve)(s,`${e}.md`),l=(0,R.generateMarkdown)({contract:a,contractFile:(0,P.relative)(s,t),contractName:e,abi:n});await(0,T.mkdir)(s,{recursive:!0}),await(0,T.writeFile)(f,l)}async function xt(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 W=require("path"),wt=require("fs/promises"),z=require("util");function Kt(t){let{abi:e}=t,r=[],b=e,{functions:n,variables:o,maps:i}=b,a=O(b,["functions","variables","maps"]);n.forEach(c=>{let u=`${(0,N.toCamelCase)(c.name)}: `,S=`[${c.args.map(st=>`${B(st.name)}: ${p(st.type,!0)}`).join(", ")}]`;u+=JSON.stringify(c);let St=p(c.outputs.type);u+=` as TypedAbiFunction<${S}, ${St}>`,r.push(u)});let s=t.variables.map(c=>{let u=`${(0,N.toCamelCase)(c.name)}: `,v=p(c.type);return u+=`${(0,z.inspect)(c,!1,null,!1)} as TypedAbiVariable<${v}>`,u}),l=t.variables.filter(c=>c.access==="constant").map(c=>`"${(0,N.toCamelCase)(c.name)}": ${Ht(c.defaultValue)}`),y=i.map(c=>{let u=`${(0,N.toCamelCase)(c.name)}: `,v=p(c.key),S=p(c.value);return u+=JSON.stringify(c),u+=` as TypedAbiMap<${v}, ${S}>`,u}),x=JSON.stringify(a),C=(0,W.relative)(process.cwd(),t.contractFile);return`{
-  ${U("functions",r)}
-  ${U("variables",s)}
-  ${U("maps",y)}
-  ${U("constants",l)}
-  ${x.slice(1,-1)},
-  contractName: '${t.contractName}',
-  contractFile: '${C}',
-  }`}async function At(t,e){let r=e.map(a=>{let s=Kt(a);return`${(0,N.toCamelCase)(a.contractName)}: ${s}`}),n=await Qt(),o=qt(t);return`
-${n}
-
-export const contracts: Record<string, TypedAbi> = {
-  ${r.join(`,
-`)}
+  ${contractMap.join("\n  ")}
+};${accounts}
+`;
+  return file;
+};
+
+// src/commands/index.ts
+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");
+
+// 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 = serialize(v);
+    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 = {
+  ${contractDefs.join(",\n")}
 } as const;
 
-${o}
-`}function qt(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[z.inspect.custom]=function(){return`Uint8Array.from([${this.join(",")}])`};function Ht(t){return(0,z.inspect)(t,!1,null,!1)}function U(t,e){return`"${t}": {
-    ${e.join(`,
-    `)}
-  },`}async function Qt(){let t=(0,W.resolve)(__dirname,"../../../core/src/abi-types.ts");return await(0,wt.readFile)(t,{encoding:"utf-8"})}var ht=require("fs/promises"),Ft=require("path"),K=require("prettier"),Xt={printWidth:80,semi:!0,singleQuote:!0,trailingComma:"es5"};async function Yt(){try{let t=await(0,K.resolveConfig)(process.cwd());if(t)return t}catch{}return Xt}async function Zt(t,e){try{let r=(0,Ft.basename)(e),n=await Yt();return(0,K.format)(t,w(d({},n),{filepath:r}))}catch{}return t}async function j(t,e){let r=await Zt(e,t);await(0,ht.writeFile)(t,r)}var Tt=require("@clarigen/core"),vt=require("@clarigen/native-bin"),Pt=require("micro-stacks/clarity");async function Nt({abi:t,contractIdentifier:e,provider:r}){let n=t.variables.map(i=>Gt({variable:i,provider:r,contractIdentifier:e}));return await Promise.all(n)}async function Gt({contractIdentifier:t,variable:e,provider:r}){let n=te(e),o=await(0,vt.evalRaw)({contractAddress:t,code:n,provider:r}),i=(0,Pt.hexToCV)(o.output_serialized),a=(0,Tt.cvToValue)(i,!0);return w(d({},e),{defaultValue:a})}function te(t){let{access:e}=t;return e==="variable"?`(var-get ${t.name})`:t.name}var ee=async({contractFile:t,outputFolder:e,provider:r,contractAddress:n,dirName:o,contractName:i,docsPath:a})=>{let s=(0,g.resolve)(process.cwd(),t),f=`${n}.${i}`,l=await(0,q.deployContract)({contractIdentifier:f,contractFilePath:s,provider:r}),y=await Nt({abi:l,contractIdentifier:f,provider:r}),x=nt(l,i),C=rt({contractFile:(0,g.relative)(process.cwd(),s),contractAddress:n,contractName:i}),b=et({contractName:i,abi:l});typeof a<"u"&&await bt({contractFile:s,contractName:i,abi:l,docsPath:a,dirName:o});let c=(0,g.resolve)(e,o||".",i);return await(0,jt.mkdir)(c,{recursive:!0}),await j((0,g.resolve)(c,"abi.ts"),b),await j((0,g.resolve)(c,"index.ts"),C),await j((0,g.resolve)(c,"types.ts"),x),{abi:l,contractFile:s,contractName:i,dirName:o,contractAddress:n,variables:y}},H=async t=>{let e=await E(t),{contractsDir:r,outputDir:n,contracts:o}=e,i=(0,g.resolve)(t,n),a=await(0,q.createClarityBin)(),s=[];for(let C of o){let b=(0,g.resolve)(t,r,C.file),c=(0,g.dirname)(C.file),u=await ee({contractFile:b,outputFolder:i,provider:a,contractAddress:C.address,dirName:c,contractName:C.name,docsPath:e.docs});s.push(u)}let f=ot(e);await xt(e);let l=(0,g.resolve)(i,"index.ts");await j(l,f);let y=await At(e,s),x=(0,g.resolve)(i,"single.ts");await j(x,y)};var Et=require("chokidar"),It=require("path"),k=require("chalk"),re=require("ora"),it=class extends I.Command{async run(){let{flags:e}=this.parse(it),r=process.cwd();if(e.watch){let n=re("Generating files").start(),{contractsDir:o}=await E(r),i=(0,Et.watch)([o],{cwd:r});try{await H(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,It.basename)(a);n.clear(),n.start(`Change detected for ${(0,k.green)(s)}, generating.`);try{await H(r),n.succeed(`Finished generating files for ${(0,k.green)(s)}. Watching for changes.`)}catch(f){let l=f.message;n.fail(`Error after saving ${(0,k.red)(s)}.
-${l}`)}}),process.on("SIGINT",async()=>{await i.close(),process.exit()})}else await H(r)}},A=it;A.description="Generate project files",A.strict=!0,A.hidden=!1,A.flags={help:I.flags.help({char:"h"}),watch:I.flags.boolean({char:"w",description:"Watch for changes to your contracts"})},A.args=[];0&&(module.exports={Generate,configFileExists,configFilePath,defaultConfigFile,generateIndexFile,generateInterface,generateInterfaceFile,generateProjectIndexFile,generateTypesFile,getArgName,getConfigFile,getProjectConfig,jsTypeFromAbiType,makePureTypes,run});
+${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_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/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_bin2.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_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,
+      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 import_ora = __toESM(require("ora"));
+var _Generate = class extends import_command.Command {
+  async run() {
+    const { flags: flags2 } = this.parse(_Generate);
+    const cwd = process.cwd();
+    if (flags2.watch) {
+      const spinner = (0, import_ora.default)("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.
+${String(error.message)}`);
+      }
+      watcher.on("change", (path) => {
+        const cb = async () => {
+          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}`);
+          }
+        };
+        void cb();
+      });
+      process.on("SIGINT", () => {
+        async function cb() {
+          await watcher.close();
+          process.exit();
+        }
+        void cb();
+      });
+    } else {
+      await generateProject(cwd);
+    }
+  }
+};
+var Generate = _Generate;
+Generate.description = `Generate project files`;
+Generate.strict = true;
+Generate.hidden = false;
+Generate.flags = {
+  help: import_command.flags.help({ char: "h" }),
+  watch: import_command.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,
+  configFileExists,
+  configFilePath,
+  defaultConfigFile,
+  generateIndexFile,
+  generateInterfaceFile,
+  generateProjectIndexFile,
+  generateTypesFile,
+  getArgName,
+  getConfigFile,
+  getProjectConfig,
+  jsTypeFromAbiType,
+  makePureTypes,
+  run
+});