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

package/package.json

@@ -2,7 +2,7 @@
   "name": "@clarigen/cli",
   "description": "A CLI for generating a Typescript interface for a Clarity contract.",
   "author": "Hank Stoever",
-  "version": "1.0.0-next.16",
+  "version": "1.0.0-next.19",
   "license": "MIT",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -24,7 +24,8 @@
     "lint": "eslint \"src/**/*.{ts,tsx}\" && prettier  --check src/**/*.ts",
     "typecheck": "tsc --noEmit -p tsconfig-test.json",
     "prepublishOnly": "yarn build",
-    "demo": "yarn build && node bin/run"
+    "demo": "yarn build && node bin/run",
+    "publish:dev": "yalc publish --push"
   },
   "bin": {
     "clarigen": "./bin/run"
@@ -49,9 +50,9 @@
     "ts-node": "^9.1.1"
   },
   "dependencies": {
-    "@clarigen/claridocs": "1.0.0-next.16",
-    "@clarigen/core": "1.0.0-next.16",
-    "@clarigen/native-bin": "1.0.0-next.16",
+    "@clarigen/claridocs": "1.0.0-next.19",
+    "@clarigen/core": "1.0.0-next.19",
+    "@clarigen/native-bin": "1.0.0-next.19",
     "@ltd/j-toml": "1.12.2",
     "@oclif/command": "^1.8.0",
     "@oclif/config": "^1.17.0",
@@ -60,11 +61,12 @@
     "chokidar": "3.5.1",
     "micro-stacks": "^0.2.0",
     "ora": "5.4.0",
+    "prettier": "2.6.2",
     "reserved-words": "0.1.2",
     "toposort": "2.0.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cc40e90b2dc188debd134f25fe05b1ef5eb14ff2"
+  "gitHead": "d6b6fc199e367698d566f38ee3343b04a418c829"
 }

package/src/clarinet-config.ts

@@ -48,6 +48,12 @@ export interface ClarinetConfig {
   contracts: ClarinetContracts;
 }
 
+export const CLARINET_SETTINGS = [
+  'Devnet.toml',
+  'Testnet.toml',
+  'Mainnet.toml',
+];
+
 export async function getClarinetConfig(folder: string) {
   const baseConfigPath = resolve(folder, 'Clarinet.toml');
   const configContents = await readFile(baseConfigPath, { encoding: 'utf-8' });

package/src/generate/declaration.ts

@@ -41,7 +41,7 @@ export const jsTypeFromAbiType = (
   } else if (isClarityAbiResponse(val)) {
     const ok: any = jsTypeFromAbiType(val.response.ok);
     const err: any = jsTypeFromAbiType(val.response.error);
-    return `ClarityTypes.Response<${ok}, ${err}>`;
+    return `Response<${ok}, ${err}>`;
   } else if (isClarityAbiOptional(val)) {
     const innerType = jsTypeFromAbiType(val.optional);
     return `${innerType} | null`;
@@ -69,7 +69,7 @@ export const jsTypeFromAbiType = (
 };
 
 // Check if it's a reserved word, and then camelCase
-function getArgName(name: string) {
+export function getArgName(name: string) {
   const camel = toCamelCase(name);
   const prefix = check(camel, 6) ? '_' : '';
   return `${prefix}${camel}`;

package/src/generate/files.ts

@@ -115,7 +115,7 @@ export const ${varName}Info: Contract<${contractType}> = {
 export const generateTypesFile = (abi: ClarityAbi, contractName: string) => {
   const name = toCamelCase(contractName, true);
   const typings = makePureTypes(abi);
-  const fileContents = `import { ClarityTypes, ContractCalls } from '@clarigen/core';
+  const fileContents = `import { Response, ContractCalls } from '@clarigen/core';
 
 // prettier-ignore
 export interface ${name}Contract {

package/src/generate/single.ts

@@ -0,0 +1,134 @@
+import { toCamelCase } from '@clarigen/core';
+import type { ConfigFile } from '../config';
+import { getArgName, jsTypeFromAbiType } from './declaration';
+import type { ContractMeta } from '../utils';
+import { relative, resolve } from 'path';
+import { readFile } from 'fs/promises';
+import { inspect } from 'util';
+
+export function generateContractMeta(contract: ContractMeta) {
+  const { abi } = contract;
+  const functionLines: string[] = [];
+  const { functions, variables, maps, ...rest } = abi;
+  functions.forEach((func) => {
+    let functionLine = `${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 = `${toCamelCase(v.name)}: `;
+    const type = jsTypeFromAbiType(v.type);
+    const varJSON = inspect(v, false, null, false);
+    varLine += `${varJSON} as TypedAbiVariable<${type}>`;
+    return varLine;
+  });
+
+  const constants = contract.variables.filter((v) => v.access === 'constant');
+  const constantLines = constants.map((constant) => {
+    return `"${toCamelCase(constant.name)}": ${serialize(
+      constant.defaultValue
+    )}`;
+  });
+
+  const mapLines = maps.map((map) => {
+    let mapLine = `${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 = 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}',
+  }`;
+}
+
+export async function generateSingleFile(
+  config: ConfigFile,
+  contracts: ContractMeta[]
+) {
+  const contractDefs = contracts.map((contract) => {
+    const meta = generateContractMeta(contract);
+    const keyName = 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;
+
+${accounts}
+`;
+  return file;
+}
+
+function generateAccounts(config: ConfigFile) {
+  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[inspect.custom] = function (this: Uint8Array) {
+  return `Uint8Array.from([${this.join(',')}])`;
+};
+
+export function serialize(obj: any) {
+  return inspect(obj, {
+    showHidden: false,
+    maxArrayLength: null,
+    maxStringLength: null,
+    depth: null,
+    colors: false,
+  });
+}
+
+function serializeLines(key: string, lines: string[]) {
+  return `"${key}": {
+    ${lines.join(',\n    ')}
+  },`;
+}
+
+export async function getSingleTypes() {
+  // 🤔 weird stuff with tsup shims
+  const typesPath = resolve(__dirname, '../../dist/abi-types.ts.txt');
+  const typesFile = await readFile(typesPath, { encoding: 'utf-8' });
+  return typesFile;
+}

package/src/generate/vars.ts

@@ -0,0 +1,82 @@
+import {
+  ClarityAbiType,
+  cvToValue,
+  AbiTypeTo,
+  ClarityAbi,
+} from '@clarigen/core';
+import { evalRaw, NativeClarityBinProvider } from '@clarigen/native-bin';
+import { ClarityAbiVariable, hexToCV } from 'micro-stacks/clarity';
+import type { ContractMeta } from '../utils';
+
+// export interface TypedAbiVariable<T extends ClarityAbiType>
+//   extends ClarityAbiVariable {
+//   type: T;
+//   defaultValue: AbiTypeTo<T>;
+// }
+export type TypedAbiVariable<T> = ClarityAbiVariable & {
+  defaultValue: T;
+};
+// export type TypedAbiVariable<T> = T extends ClarityAbiVariable ?
+//   T['type'] extends ClarityAbiType ?
+export type VariableType<T> = T extends ClarityAbiVariable ? T['type'] : never;
+
+export async function getVariables({
+  abi,
+  contractIdentifier,
+  provider,
+}: {
+  abi: ClarityAbi;
+  contractIdentifier: string;
+  provider: NativeClarityBinProvider;
+}) {
+  const variableTransforms = abi.variables.map((variable) => {
+    return evalVariable({
+      variable,
+      provider,
+      contractIdentifier,
+    });
+  });
+  const variables = await Promise.all(variableTransforms);
+  return variables;
+}
+
+export async function evalVariable<T extends ClarityAbiVariable>({
+  contractIdentifier,
+  variable,
+  provider,
+}: {
+  contractIdentifier: string;
+  variable: T;
+  provider: NativeClarityBinProvider;
+}) {
+  const code = getEvalCode(variable);
+  const result = await evalRaw({
+    contractAddress: contractIdentifier,
+    code,
+    provider,
+  });
+  const resultCV = hexToCV(result.output_serialized);
+  const value = cvToValue(resultCV, true);
+  return {
+    ...variable,
+    defaultValue: value,
+  };
+}
+
+// export async function
+
+function getEvalCode(variable: ClarityAbiVariable) {
+  const { access } = variable;
+  if (access === 'variable') {
+    return `(var-get ${variable.name})`;
+  }
+  return variable.name;
+}
+
+// export function serializeVariable(variable: TypedAbiVariable<any>) {
+//   const { defaultValue, ...rest } = variable;
+//   const lines = Object.keys(rest).map((key) => {
+//     return `"${key}": ${JSON.stringify(rest[key])}`;
+//   });
+//   const valueLine = typeof defaultValue === 'bigint' ? `${defaultValue.toString()}n` : JSON.stringify()
+// }

package/src/utils.ts

@@ -8,11 +8,26 @@ import {
 import {
   NativeClarityBinProvider,
   createClarityBin,
+  deployContract,
 } from '@clarigen/native-bin';
 import { resolve, relative, dirname } from 'path';
-import { mkdir, writeFile } from 'fs/promises';
+import { mkdir } from 'fs/promises';
 import { getProjectConfig } from './config';
 import { generateDocsIndex, generateMarkdownDoc } from './docs';
+import { ClarityAbi, Contract } from '@clarigen/core';
+import { generateContractMeta, generateSingleFile } from './generate/single';
+import { writeFile } from './writer';
+import { getVariables, TypedAbiVariable } from './generate/vars';
+import { ClarityAbiVariable } from 'micro-stacks/clarity';
+
+export interface ContractMeta {
+  abi: ClarityAbi;
+  contractFile: string;
+  dirName: string;
+  contractName: string;
+  contractAddress: string;
+  variables: TypedAbiVariable<unknown>[];
+}
 
 export const generateFilesForContract = async ({
   contractFile: _contractFile,
@@ -30,15 +45,21 @@ export const generateFilesForContract = async ({
   dirName?: string;
   contractName: string;
   docsPath?: string;
-}) => {
+}): Promise<ContractMeta> => {
   const contractFile = resolve(process.cwd(), _contractFile);
+  const contractIdentifier = `${contractAddress}.${contractName}`;
 
-  const abi = await generateInterface({
-    contractFile,
+  const abi = await deployContract({
+    contractIdentifier,
+    contractFilePath: contractFile,
     provider,
-    contractAddress,
-    contractName,
   });
+  const variables = await getVariables({
+    abi,
+    contractIdentifier,
+    provider,
+  });
+
   const typesFile = generateTypesFile(abi, contractName);
   const indexFile = generateIndexFile({
     contractFile: relative(process.cwd(), contractFile),
@@ -63,6 +84,15 @@ export const generateFilesForContract = async ({
   await writeFile(resolve(outputPath, 'abi.ts'), abiFile);
   await writeFile(resolve(outputPath, 'index.ts'), indexFile);
   await writeFile(resolve(outputPath, 'types.ts'), typesFile);
+
+  return {
+    abi,
+    contractFile,
+    contractName,
+    dirName,
+    contractAddress,
+    variables,
+  };
 };
 
 export const generateProject = async (projectPath: string) => {
@@ -70,11 +100,12 @@ export const generateProject = async (projectPath: string) => {
   const { contractsDir, outputDir, contracts } = configFile;
   const outputFolder = resolve(projectPath, outputDir);
   const provider = await createClarityBin();
+  const metas: ContractMeta[] = [];
   // this needs to be serial
   for (const contract of contracts) {
     const contractFile = resolve(projectPath, contractsDir, contract.file);
     const dirName = dirname(contract.file);
-    await generateFilesForContract({
+    const meta = await generateFilesForContract({
       contractFile,
       outputFolder: outputFolder,
       provider,
@@ -83,6 +114,7 @@ export const generateProject = async (projectPath: string) => {
       contractName: contract.name,
       docsPath: configFile.docs,
     });
+    metas.push(meta);
   }
 
   const indexFile = generateProjectIndexFile(configFile);
@@ -90,4 +122,8 @@ export const generateProject = async (projectPath: string) => {
 
   const indexPath = resolve(outputFolder, 'index.ts');
   await writeFile(indexPath, indexFile);
+
+  const singleFile = await generateSingleFile(configFile, metas);
+  const singlePath = resolve(outputFolder, 'single.ts');
+  await writeFile(singlePath, singleFile);
 };

package/src/writer.ts

@@ -0,0 +1,39 @@
+// Utilities for writing and formatting files
+import { writeFile as _writeFile } from 'fs/promises';
+import { basename } from 'path';
+import { resolveConfig, format, Options } from 'prettier';
+
+const defaultPrettierConfig: Options = {
+  printWidth: 80,
+  semi: true,
+  singleQuote: true,
+  trailingComma: 'es5',
+};
+
+export async function resolvePrettierConfig(): Promise<Options> {
+  try {
+    const local = await resolveConfig(process.cwd());
+    if (local) return local;
+  } catch (error) {}
+  return defaultPrettierConfig;
+}
+
+export async function formatFile(contents: string, path: string) {
+  try {
+    const fileName = basename(path);
+    const config = await resolvePrettierConfig();
+    const formatted = format(contents, {
+      ...config,
+      filepath: fileName,
+    });
+    return formatted;
+  } catch (error) {
+    // handle formatting error
+  }
+  return contents;
+}
+
+export async function writeFile(path: string, contents: string) {
+  const formatted = await formatFile(contents, path);
+  await _writeFile(path, formatted);
+}

package/dist/commands/index.d.ts

@@ -1,16 +0,0 @@
-import * as _oclif_parser_lib_flags from '@oclif/parser/lib/flags';
-import { Command } from '@oclif/command';
-
-declare class Generate extends Command {
-    static description: string;
-    static strict: boolean;
-    static hidden: boolean;
-    static flags: {
-        help: _oclif_parser_lib_flags.IBooleanFlag<void>;
-        watch: _oclif_parser_lib_flags.IBooleanFlag<boolean>;
-    };
-    static args: any[];
-    run(): Promise<void>;
-}
-
-export { Generate };

package/dist/commands/index.mjs

@@ -1,78 +0,0 @@
-var rt=Object.defineProperty,nt=Object.defineProperties;var et=Object.getOwnPropertyDescriptors;var w=Object.getOwnPropertySymbols;var k=Object.prototype.hasOwnProperty,N=Object.prototype.propertyIsEnumerable;var j=(t,n,r)=>n in t?rt(t,n,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[n]=r,$=(t,n)=>{for(var r in n||(n={}))k.call(n,r)&&j(t,r,n[r]);if(w)for(var r of w(n))N.call(n,r)&&j(t,r,n[r]);return t},h=(t,n)=>nt(t,et(n));var ot=(t=>typeof require!="undefined"?require:typeof Proxy!="undefined"?new Proxy(t,{get:(n,r)=>(typeof require!="undefined"?require:n)[r]}):t)(function(t){if(typeof require!="undefined")return require.apply(this,arguments);throw new Error('Dynamic require of "'+t+'" is not supported')});var D=(t,n)=>{var r={};for(var e in t)k.call(t,e)&&n.indexOf(e)<0&&(r[e]=t[e]);if(t!=null&&w)for(var e of w(t))n.indexOf(e)<0&&N.call(t,e)&&(r[e]=t[e]);return r};import{Command as Wt,flags as Y}from"@oclif/command";import{hasStdErr as kt}from"@clarigen/native-bin";import{toCamelCase as x}from"@clarigen/core";import{dirname as Nt,join as Dt}from"path";import{run as Cr}from"@oclif/command";import{resolve as R,join as gt,relative as ut}from"path";import{readFile as mt,access as Ct}from"fs/promises";import{constants as dt}from"fs";import{parse as v}from"@ltd/j-toml";import{resolve as S}from"path";import{readFile as O}from"fs/promises";import{generateWallet as it,getStxAddressFromAccount as st}from"micro-stacks/wallet-sdk";import{array as ct}from"toposort";import{StacksNetworkVersion as at}from"micro-stacks/crypto";async function lt(t){let n=S(t,"settings","Devnet.toml"),r=await O(n,{encoding:"utf-8"});return v(r,1,`
-`,!0,{longer:!0})}async function ft(t){let n=S(t,"Clarinet.toml"),r=await O(n,{encoding:"utf-8"});return v(r,1,`
-`,!0)}async function _(t,n){let r=await ft(t),e=n.deployer.address;return pt(r.contracts).map(c=>({file:r.contracts[c].path.replace(/^contracts\//,""),address:e,name:c}))}function pt(t){let n=[],r=[];return Object.entries(t).forEach(([o,i])=>{r.push(o),i.depends_on.forEach(c=>n.push([o,c]))}),ct(r,n).reverse()}async function B(t){let n=await lt(t),r=await Promise.all(Object.entries(n.accounts).map(async([o,i])=>{let c=await it(i.mnemonic,"password"),[s]=c.accounts,a=st(s,at.testnetP2PKH);return[o,h($({},i),{address:a})]}));return Object.fromEntries(r)}var L={outputDir:"src/clarigen",clarinet:"."};function yt(t){return R(t,"clarigen.config.json")}async function $t(t){try{return await Ct(t,dt.R_OK),!0}catch{return!1}}async function xt(t){let n=yt(t);if(await $t(n)){let e=await mt(n,{encoding:"utf-8"}),o=JSON.parse(e);return $($({},L),o)}return L}async function b(t){let n=await xt(t),r=R(t,n.clarinet||"."),e=await B(r),o=await _(r,e),i=ut(process.cwd(),gt(n.clarinet,"contracts"));return h($({},n),{contracts:o,contractsDir:i,accounts:e,clarinet:n.clarinet||"."})}import{isClarityAbiBuffer as wt,isClarityAbiList as ht,isClarityAbiOptional as bt,isClarityAbiPrimitive as Ft,isClarityAbiResponse as J,isClarityAbiStringAscii as At,isClarityAbiStringUtf8 as Pt,isClarityAbiTuple as Tt}from"micro-stacks/transactions";import{toCamelCase as P}from"@clarigen/core";import{check as Et}from"reserved-words";var f=(t,n=!1)=>{if(Ft(t)){if(t==="uint128")return n?"number | bigint":"bigint";if(t==="int128")return n?"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(wt(t))return"Uint8Array";if(J(t)){let r=f(t.response.ok),e=f(t.response.error);return`ClarityTypes.Response<${r}, ${e}>`}else{if(bt(t))return`${f(t.optional)} | null`;if(Tt(t)){let r=[];return t.tuple.forEach(({name:e,type:o})=>{let i=f(o);r.push(`"${e}": ${i}`)}),`{
-  ${r.join(`;
-  `)}
-    }`}else{if(ht(t))return`${f(t.list.type)}[]`;if(At(t))return"string";if(Pt(t))return"string";if(t==="trait_reference")return"string";throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(t)}`)}}}};function It(t){let n=P(t);return`${Et(n,6)?"_":""}${n}`}var jt={public:"Public",read_only:"ReadOnly",private:"Private"};function M(t){let n="";return t.functions.forEach((r,e)=>{let o=`${P(r.name)}: `;if(o+=`(${r.args.map(s=>`${It(s.name)}: ${f(s.type,!0)}`).join(", ")}) => `,o+=`ContractCalls.${jt[r.access]}<`,r.access==="public"){let{type:s}=r.outputs;if(!J(s))throw new Error("Expected response type for public function");let a=f(s.response.ok),l=f(s.response.error);o+=`${a}, ${l}>;`}else o+=`${f(r.outputs.type)}>;`;n+=`${e===0?"":`
-`}  ${o}`}),t.maps.forEach(r=>{let e=`${P(r.name)}: `,o=f(r.key,!0),i=`key: ${o}`,c=f(r.value);e+=`(${i}) => ContractCalls.Map<${o}, ${c}>;`,n+=`
-  ${e}`}),n}var U=async({provider:t,contractFile:n,contractAddress:r,contractName:e})=>{let o=await t.runCommand(["launch",`${r}.${e}`,n,t.dbFilePath,"--output_analysis","--costs","--assets"]);if(kt(o.stderr))throw new Error(`Error on ${n}:
-  ${o.stderr}
-    `);let i=JSON.parse(o.stdout);if(i.error){let{initialization:s}=i.error;if(s!=null&&s.includes(`
-Near:
-`)){let[a,l]=s.split(`
-Near:
-`),p="",g=/start_line: (\d+),/.exec(l);throw g&&(p=g[1]),new Error(`Error on ${n}:
-    ${a}
-    ${p?`Near line ${p}`:""}
-    Raw trace:
-    ${l}
-      `)}throw new Error(`Error on ${n}:
-  ${JSON.stringify(i.error,null,2)}
-    `)}return i.analysis},W=({contractName:t,abi:n})=>{let r=x(t,!0),s=n,{clarity_version:e}=s,o=D(s,["clarity_version"]),i=JSON.stringify(o,null,2);return`import { ClarityAbi } from '@clarigen/core';
-
-// prettier-ignore
-export const ${r}Interface: ClarityAbi = ${i};
-`},V=({contractFile:t,contractAddress:n,contractName:r})=>{let e=x(r,!0),o=x(r),i=`${e}Contract`,c=`${e}Interface`;return`import { pureProxy, Contract } from '@clarigen/core';
-import type { ${i} } from './types';
-import { ${c} } from './abi';
-export type { ${i} } from './types';
-
-export function ${o}Contract(contractAddress: string, contractName: string) {
-  return pureProxy<${i}>({
-    abi: ${c},
-    contractAddress,
-    contractName,
-  });
-}
-
-export const ${o}Info: Contract<${i}> = {
-  contract: ${o}Contract,
-  address: '${n}',
-  contractFile: '${t}',
-  name: '${r}',
-  abi: ${c},
-};
-`},K=(t,n)=>{let r=x(n,!0),e=M(t);return`import { ClarityTypes, ContractCalls } from '@clarigen/core';
-
-// prettier-ignore
-export interface ${r}Contract {
-${e}
-}
-`},q=t=>{let n=["import type { ContractInstances } from '@clarigen/core';"],r=[],e=[],o="";"accounts"in t&&(o=`
-
-// prettier-ignore
-export const accounts = {
-  ${Object.keys(t.accounts).map(a=>{let l=t.accounts[a];return`"${a}": {
-    mnemonic: "${l.mnemonic}",
-    balance: ${l.balance.toString()}n,
-    address: "${l.address}",
-  },`}).join(`
-  `)}
-};`),t.contracts.forEach(s=>{let a=s.name,l=x(a),p=`${l}Info`,y=`${x(a,!0)}Contract`,g=Nt(s.file),I=`'./${Dt(g||".",a)}'`,z=`import { ${p} } from ${I};`;n.push(z);let G=`export type { ${y} } from ${I};`;r.push(G);let tt=`${l}: ${p},`;e.push(tt)});let i=`
-export type Contracts = ContractInstances<typeof contracts>;
-`;return`${n.join(`
-`)}
-${r.join(`
-`)}
-${i}
-export const contracts = {
-  ${e.join(`
-  `)}
-};${o}
-`};import{createClarityBin as Lt}from"@clarigen/native-bin";import{resolve as u,relative as Rt,dirname as Jt}from"path";import{mkdir as Mt,writeFile as F}from"fs/promises";import{createContractDocInfo as vt,generateMarkdown as St}from"@clarigen/claridocs";import{mkdir as Ot,readFile as _t,writeFile as H}from"fs/promises";import{relative as Bt,resolve as T}from"path";async function Q({contractFile:t,contractName:n,docsPath:r,abi:e,dirName:o}){let i=await _t(t,{encoding:"utf-8"}),c=vt({contractSrc:i,abi:e}),s=T(process.cwd(),r,o||"."),a=T(s,`${n}.md`),l=St({contract:c,contractFile:Bt(s,t),contractName:n,abi:e});await Ot(s,{recursive:!0}),await H(a,l)}async function X(t){if(!t.docs)return;let r=`# Contracts
-
-${t.contracts.map(o=>{let i=o.file.replace(".clar",".md");return`- [\`${o.name}\`](${i})`}).join(`
-`)}
-`,e=T(process.cwd(),t.docs,"README.md");await H(e,r)}var Ut=async({contractFile:t,outputFolder:n,provider:r,contractAddress:e,dirName:o,contractName:i,docsPath:c})=>{let s=u(process.cwd(),t),a=await U({contractFile:s,provider:r,contractAddress:e,contractName:i}),l=K(a,i),p=V({contractFile:Rt(process.cwd(),s),contractAddress:e,contractName:i}),y=W({contractName:i,abi:a});typeof c<"u"&&await Q({contractFile:s,contractName:i,abi:a,docsPath:c,dirName:o});let g=u(n,o||".",i);await Mt(g,{recursive:!0}),await F(u(g,"abi.ts"),y),await F(u(g,"index.ts"),p),await F(u(g,"types.ts"),l)},A=async t=>{let n=await b(t),{contractsDir:r,outputDir:e,contracts:o}=n,i=u(t,e),c=await Lt();for(let l of o){let p=u(t,r,l.file),y=Jt(l.file);await Ut({contractFile:p,outputFolder:i,provider:c,contractAddress:l.address,dirName:y,contractName:l.name,docsPath:n.docs})}let s=q(n);await X(n);let a=u(i,"index.ts");await F(a,s)};import{watch as Vt}from"chokidar";import{basename as Kt}from"path";import{red as qt,green as Z}from"chalk";var Ht=ot("ora"),E=class extends Wt{async run(){let{flags:n}=this.parse(E),r=process.cwd();if(n.watch){let e=Ht("Generating files").start(),{contractsDir:o}=await b(r),i=Vt([o],{cwd:r});try{await A(r),e.succeed("Finished generating files. Watching for changes.")}catch(c){e.fail(`Error generating files.
-${c.message}`)}i.on("change",async c=>{let s=Kt(c);e.clear(),e.start(`Change detected for ${Z(s)}, generating.`);try{await A(r),e.succeed(`Finished generating files for ${Z(s)}. Watching for changes.`)}catch(a){let l=a.message;e.fail(`Error after saving ${qt(s)}.
-${l}`)}}),process.on("SIGINT",async()=>{await i.close(),process.exit()})}else await A(r)}},d=E;d.description="Generate project files",d.strict=!0,d.hidden=!1,d.flags={help:Y.help({char:"h"}),watch:Y.boolean({char:"w",description:"Watch for changes to your contracts"})},d.args=[];export{d as Generate};

package/dist/index.d.ts

@@ -1,63 +0,0 @@
-export { run } from '@oclif/command';
-import { ClarityAbiType } from 'micro-stacks/clarity';
-import { ClarityAbi } from '@clarigen/core';
-import { NativeClarityBinProvider } from '@clarigen/native-bin';
-export { Generate } from './commands/index.js';
-import '@oclif/parser/lib/flags';
-
-interface ClarinetConfigAccount {
-    mnemonic: string;
-    balance: bigint;
-}
-interface ClarinetAccount extends ClarinetConfigAccount {
-    address: string;
-}
-interface ClarinetAccounts {
-    deployer: ClarinetAccount;
-    [name: string]: ClarinetAccount;
-}
-
-interface ConfigContract {
-    address: string;
-    file: string;
-    name: string;
-}
-interface ConfigFileContents {
-    outputDir: string;
-    clarinet: string;
-    docs?: string;
-}
-interface ConfigFile extends ConfigFileContents {
-    contractsDir: string;
-    contracts: ConfigContract[];
-    accounts: ClarinetAccounts;
-    clarinet: string;
-}
-declare const defaultConfigFile: ConfigFileContents;
-declare function configFilePath(rootPath: string): string;
-declare function configFileExists(configPath: string): Promise<boolean>;
-declare function getConfigFile(rootPath: string): Promise<ConfigFileContents>;
-declare function getProjectConfig(rootPath: string): Promise<ConfigFile>;
-
-declare const jsTypeFromAbiType: (val: ClarityAbiType, isArgument?: boolean) => string;
-declare function makePureTypes(abi: ClarityAbi): string;
-
-declare const generateInterface: ({ provider, contractFile, contractAddress, contractName, }: {
-    contractFile: string;
-    provider: NativeClarityBinProvider;
-    contractAddress: string;
-    contractName: string;
-}) => Promise<ClarityAbi>;
-declare const generateInterfaceFile: ({ contractName, abi, }: {
-    contractName: string;
-    abi: ClarityAbi;
-}) => string;
-declare const generateIndexFile: ({ contractFile, contractAddress, contractName, }: {
-    contractFile: string;
-    contractAddress: string;
-    contractName: string;
-}) => string;
-declare const generateTypesFile: (abi: ClarityAbi, contractName: string) => string;
-declare const generateProjectIndexFile: (config: ConfigFile) => string;
-
-export { ConfigContract, ConfigFile, ConfigFileContents, configFileExists, configFilePath, defaultConfigFile, generateIndexFile, generateInterface, generateInterfaceFile, generateProjectIndexFile, generateTypesFile, getConfigFile, getProjectConfig, jsTypeFromAbiType, makePureTypes };