@clarigen/cli 0.2.0 → 0.3.0

package/README.md

@@ -6,66 +6,8 @@ Most of the time, you'll only need to run `clarigen` to automatically build your
 
 # Usage
 
-<!-- usage -->
-```sh-session
-$ npm install -g @clarigen/cli
-$ clarigen COMMAND
-running command...
-$ clarigen (-v|--version|version)
-@clarigen/cli/0.1.1 darwin-arm64 node-v16.4.2
-$ clarigen --help [COMMAND]
-USAGE
-  $ clarigen COMMAND
-...
-```
-<!-- usagestop -->
-
 <!-- commands -->
-* [`clarigen `](#clarigen-)
-* [`clarigen contract [CONTRACT]`](#clarigen-contract-contract)
-* [`clarigen generate`](#clarigen-generate)
-
-## `clarigen `
-
-Generate project files
-
-```
-USAGE
-  $ clarigen
-
-OPTIONS
-  -h, --help   show CLI help
-  -w, --watch  Watch for changes to your contracts
-```
-
-## `clarigen contract [CONTRACT]`
-
-Generate files for a single contract
 
-```
-USAGE
-  $ clarigen contract [CONTRACT]
-
-ARGUMENTS
-  CONTRACT  The file path for your contract
-
-OPTIONS
-  -h, --help           show CLI help
-  -o, --output=output  [default: clarion] Output destination folder
-```
-
-## `clarigen generate`
-
-Generate project files
-
-```
-USAGE
-  $ clarigen generate
-
-OPTIONS
-  -h, --help   show CLI help
-  -w, --watch  Watch for changes to your contracts
-```
 <!-- commandsstop -->
 
 ## Development

package/bin/run

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-var-requires */
 
-require('../dist')
+require('@oclif/command')
   .run()
   .then(require('@oclif/command/flush'))
   .catch(require('@oclif/errors/handle'));

package/dist/clarinet-config.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClarinetAccounts = exports.getContractsFromClarinet = exports.getClarinetConfig = exports.getClarinetDevConfig = void 0;
+const j_toml_1 = require("@ltd/j-toml");
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const wallet_sdk_1 = require("@stacks/wallet-sdk");
+async function getClarinetDevConfig(folder) {
+    const baseConfigPath = path_1.resolve(folder, 'settings', 'Devnet.toml');
+    const configContents = await promises_1.readFile(baseConfigPath, { encoding: 'utf-8' });
+    const config = j_toml_1.parse(configContents, 1.0, '\n', true, {
+        longer: true,
+    });
+    return config;
+}
+exports.getClarinetDevConfig = getClarinetDevConfig;
+async function getClarinetConfig(folder) {
+    const baseConfigPath = path_1.resolve(folder, 'Clarinet.toml');
+    const configContents = await promises_1.readFile(baseConfigPath, { encoding: 'utf-8' });
+    const config = j_toml_1.parse(configContents, 1.0, '\n', true);
+    return config;
+}
+exports.getClarinetConfig = getClarinetConfig;
+async function getContractsFromClarinet(folder, accounts) {
+    const clarinetConfig = await getClarinetConfig(folder);
+    const deployerAddress = accounts.deployer.address;
+    const contracts = Object.entries(clarinetConfig.contracts).map(([contractName, info]) => {
+        const file = info.path.replace(/^contracts\//, '');
+        return {
+            file,
+            address: deployerAddress,
+        };
+    });
+    return contracts;
+}
+exports.getContractsFromClarinet = getContractsFromClarinet;
+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 wallet_sdk_1.generateWallet({
+            secretKey: info.mnemonic,
+            password: 'password',
+        });
+        const [account] = wallet.accounts;
+        const address = wallet_sdk_1.getStxAddress({ account });
+        return [
+            key,
+            {
+                ...info,
+                address,
+            },
+        ];
+    }));
+    const accounts = Object.fromEntries(accountEntries);
+    return accounts;
+}
+exports.getClarinetAccounts = getClarinetAccounts;

package/dist/commands/contract.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contract = void 0;
+const command_1 = require("@oclif/command");
+const utils_1 = require("../utils");
+class Contract extends command_1.Command {
+    async run() {
+        const { argv, flags } = this.parse(Contract);
+        const [contractFile] = argv;
+        await utils_1.generateFilesForContract({
+            contractFile,
+            outputFolder: flags.output,
+        });
+    }
+}
+exports.Contract = Contract;
+Contract.description = `Generate files for a single contract`;
+Contract.strict = true;
+Contract.hidden = true;
+Contract.flags = {
+    help: command_1.flags.help({ char: 'h' }),
+    output: command_1.flags.string({
+        char: 'o',
+        description: 'Output destination folder',
+        default: 'clarion',
+    }),
+};
+Contract.args = [
+    {
+        name: 'contract',
+        description: 'The file path for your contract',
+    },
+];

package/dist/commands/index.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Generate = void 0;
+const command_1 = require("@oclif/command");
+const utils_1 = require("../utils");
+const config_1 = require("../config");
+const chokidar_1 = require("chokidar");
+const path_1 = require("path");
+const chalk_1 = require("chalk");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const ora = require('ora');
+class Generate extends command_1.Command {
+    async run() {
+        const { flags } = this.parse(Generate);
+        const cwd = process.cwd();
+        if (flags.watch) {
+            const spinner = ora('Generating files').start();
+            const { contractsDir } = await config_1.getConfigFile(cwd);
+            const watcher = chokidar_1.watch([contractsDir], {
+                cwd,
+            });
+            try {
+                await utils_1.generateProject(cwd);
+                spinner.succeed(`Finished generating files. Watching for changes.`);
+            }
+            catch (error) {
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+                spinner.fail(`Error generating files.\n${error.message}`);
+            }
+            watcher.on('change', async (path) => {
+                const file = path_1.basename(path);
+                spinner.clear();
+                spinner.start(`Change detected for ${chalk_1.green(file)}, generating.`);
+                try {
+                    await utils_1.generateProject(cwd);
+                    spinner.succeed(`Finished generating files for ${chalk_1.green(file)}. Watching for changes.`);
+                }
+                catch (error) {
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+                    const msg = error.message;
+                    spinner.fail(`Error after saving ${chalk_1.red(file)}.\n${msg}`);
+                }
+            });
+            process.on('SIGINT', async () => {
+                await watcher.close();
+                process.exit();
+            });
+        }
+        else {
+            await utils_1.generateProject(cwd);
+        }
+    }
+}
+exports.Generate = Generate;
+Generate.description = `Generate project files`;
+Generate.strict = true;
+Generate.hidden = false;
+Generate.flags = {
+    help: command_1.flags.help({ char: 'h' }),
+    watch: command_1.flags.boolean({
+        char: 'w',
+        description: 'Watch for changes to your contracts',
+    }),
+};
+Generate.args = [];

package/dist/config.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigFile = void 0;
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const clarinet_config_1 = require("./clarinet-config");
+async function getConfigFile(rootPath) {
+    const fullPath = path_1.resolve(rootPath, 'clarigen.config.json');
+    const configContents = await promises_1.readFile(fullPath, { encoding: 'utf-8' });
+    const configFile = JSON.parse(configContents);
+    if (!configFile.outputDir)
+        throw new Error('Config file missing "outputDir"');
+    if ('clarinet' in configFile) {
+        const clarinetPath = path_1.resolve(rootPath, configFile.clarinet);
+        const accounts = await clarinet_config_1.getClarinetAccounts(clarinetPath);
+        const contracts = await clarinet_config_1.getContractsFromClarinet(clarinetPath, accounts);
+        const contractsDir = path_1.relative(process.cwd(), path_1.join(configFile.clarinet, 'contracts'));
+        return {
+            ...configFile,
+            contracts,
+            contractsDir,
+            accounts,
+        };
+    }
+    if (!configFile.contracts)
+        throw new Error('Config file missing "contracts"');
+    if (!configFile.contractsDir)
+        throw new Error('Config file missing "contractDir"');
+    return configFile;
+}
+exports.getConfigFile = getConfigFile;

package/dist/generate/declaration.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTypes = exports.jsTypeFromAbiType = exports.cvFromType = void 0;
+const transactions_1 = require("@stacks/transactions");
+const core_1 = require("@clarigen/core");
+const cvFromType = (val) => {
+    if (transactions_1.isClarityAbiPrimitive(val)) {
+        if (val === 'uint128') {
+            return 'ClarityTypes.UIntCV';
+        }
+        else if (val === 'int128') {
+            return 'ClarityTypes.IntCV';
+        }
+        else if (val === 'bool') {
+            return 'ClarityTypes.BooleanCV';
+        }
+        else if (val === 'principal') {
+            return 'ClarityTypes.PrincipalCV';
+        }
+        else if (val === 'none') {
+            return 'ClarityTypes.NoneCV';
+        }
+        else {
+            throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);
+        }
+    }
+    else if (transactions_1.isClarityAbiBuffer(val)) {
+        return 'ClarityTypes.BufferCV';
+    }
+    else if (transactions_1.isClarityAbiResponse(val)) {
+        return 'ClarityTypes.ResponseCV';
+    }
+    else if (transactions_1.isClarityAbiOptional(val)) {
+        return 'ClarityTypes.OptionalCV';
+    }
+    else if (transactions_1.isClarityAbiTuple(val)) {
+        return 'ClarityTypes.TupleCV';
+    }
+    else if (transactions_1.isClarityAbiList(val)) {
+        return 'ClarityTypes.ListCV';
+    }
+    else if (transactions_1.isClarityAbiStringAscii(val)) {
+        return 'ClarityTypes.StringAsciiCV';
+    }
+    else if (transactions_1.isClarityAbiStringUtf8(val)) {
+        return 'ClarityTypes.StringUtf8CV';
+    }
+    else {
+        throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);
+    }
+};
+exports.cvFromType = cvFromType;
+const jsTypeFromAbiType = (val, isArgument = false) => {
+    if (transactions_1.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 (transactions_1.isClarityAbiBuffer(val)) {
+        return 'Buffer';
+    }
+    else if (transactions_1.isClarityAbiResponse(val)) {
+        const ok = exports.jsTypeFromAbiType(val.response.ok);
+        const err = exports.jsTypeFromAbiType(val.response.error);
+        return `ClarityTypes.Response<${ok}, ${err}>`;
+    }
+    else if (transactions_1.isClarityAbiOptional(val)) {
+        const innerType = exports.jsTypeFromAbiType(val.optional);
+        return `${innerType} | null`;
+    }
+    else if (transactions_1.isClarityAbiTuple(val)) {
+        const tupleDefs = [];
+        val.tuple.forEach(({ name, type }) => {
+            const innerType = exports.jsTypeFromAbiType(type);
+            tupleDefs.push(`"${name}": ${innerType}`);
+        });
+        return `{
+  ${tupleDefs.join(';\n  ')}
+    }`;
+    }
+    else if (transactions_1.isClarityAbiList(val)) {
+        const innerType = exports.jsTypeFromAbiType(val.list.type);
+        return `${innerType}[]`;
+    }
+    else if (transactions_1.isClarityAbiStringAscii(val)) {
+        return 'string';
+    }
+    else if (transactions_1.isClarityAbiStringUtf8(val)) {
+        return 'string';
+    }
+    else if (val === 'trait_reference') {
+        return 'string';
+    }
+    else {
+        throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);
+    }
+};
+exports.jsTypeFromAbiType = jsTypeFromAbiType;
+const makeTypes = (abi) => {
+    let typings = '';
+    abi.functions.forEach((func, index) => {
+        if (func.access === 'private')
+            return;
+        let functionLine = `${core_1.toCamelCase(func.name)}: `;
+        const args = func.args.map((arg) => {
+            return `${core_1.toCamelCase(arg.name)}: ${exports.jsTypeFromAbiType(arg.type, true)}`;
+        });
+        functionLine += `(${args.join(', ')}) => `;
+        if (func.access === 'public') {
+            const { type } = func.outputs;
+            if (!transactions_1.isClarityAbiResponse(type))
+                throw new Error('Expected response type for public function');
+            functionLine += 'Transaction';
+            const ok = exports.jsTypeFromAbiType(type.response.ok);
+            const err = exports.jsTypeFromAbiType(type.response.error);
+            functionLine += `<${ok}, ${err}>;`;
+        }
+        else {
+            const jsType = exports.jsTypeFromAbiType(func.outputs.type);
+            functionLine += `Promise<${jsType}>;`;
+            // const { type } = func.outputs;
+            // if (isClarityAbiResponse(type)) {
+            //   const ok = jsTypeFromAbiType(type.response.ok);
+            //   const err = jsTypeFromAbiType(type.response.error);
+            //   functionLine += `Promise<ClarityTypes.Response<${ok}, ${err}>>;`;
+            // } else {
+            //   const jsType = jsTypeFromAbiType(func.outputs.type);
+            //   functionLine += `Promise<${jsType}>;`;
+            // }
+        }
+        typings += `${index === 0 ? '' : '\n'}  ${functionLine}`;
+    });
+    return typings;
+};
+exports.makeTypes = makeTypes;

package/dist/generate/files.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProjectIndexFile = exports.generateTypesFile = exports.generateIndexFile = exports.generateInterfaceFile = exports.generateInterface = void 0;
+const native_bin_1 = require("@clarigen/native-bin");
+const core_1 = require("@clarigen/core");
+const declaration_1 = require("./declaration");
+const path_1 = require("path");
+const generateInterface = async ({ provider: _provider, contractFile, contractAddress = 'S1G2081040G2081040G2081040G208105NK8PE5', }) => {
+    const provider = _provider || (await native_bin_1.createClarityBin());
+    const contractName = core_1.getContractNameFromPath(contractFile);
+    const receipt = await provider.runCommand([
+        'launch',
+        `${contractAddress}.${contractName}`,
+        contractFile,
+        provider.dbFilePath,
+        '--output_analysis',
+        '--costs',
+        '--assets',
+    ]);
+    if (receipt.stderr &&
+        !receipt.stderr.includes('Used unimplemented cost function')) {
+        throw new Error(`Error on ${contractFile}:
+  ${receipt.stderr}
+    `);
+    }
+    const output = JSON.parse(receipt.stdout);
+    if (output.error) {
+        const { initialization } = output.error;
+        if (initialization?.includes('\nNear:\n')) {
+            const [error, trace] = initialization.split('\nNear:\n');
+            let startLine = '';
+            const matcher = /start_line: (\d+),/;
+            const matches = matcher.exec(trace);
+            if (matches)
+                startLine = matches[1];
+            throw new Error(`Error on ${contractFile}:
+    ${error}
+    ${startLine ? `Near line ${startLine}` : ''}
+    Raw trace:
+    ${trace}
+      `);
+        }
+        throw new Error(`Error on ${contractFile}:
+  ${JSON.stringify(output.error, null, 2)}
+    `);
+    }
+    const abi = output.analysis;
+    return abi;
+};
+exports.generateInterface = generateInterface;
+const generateInterfaceFile = ({ contractFile, abi, }) => {
+    const contractName = core_1.getContractNameFromPath(contractFile);
+    const variableName = core_1.toCamelCase(contractName, true);
+    const abiString = JSON.stringify(abi, null, 2);
+    const fileContents = `import { ClarityAbi } from '@clarigen/core';
+
+// prettier-ignore
+export const ${variableName}Interface: ClarityAbi = ${abiString};
+`;
+    return fileContents;
+};
+exports.generateInterfaceFile = generateInterfaceFile;
+const generateIndexFile = ({ contractFile, address, }) => {
+    const contractName = core_1.getContractNameFromPath(contractFile);
+    const contractTitle = core_1.toCamelCase(contractName, true);
+    const varName = core_1.toCamelCase(contractName);
+    const contractType = `${contractTitle}Contract`;
+    const fileContents = `import { proxy, BaseProvider, Contract } from '@clarigen/core';
+import type { ${contractType} } from './types';
+import { ${contractTitle}Interface } from './abi';
+export type { ${contractType} } from './types';
+
+export const ${varName}Contract = (provider: BaseProvider) => {
+  const contract = proxy<${contractType}>(${contractTitle}Interface, provider);
+  return contract;
+};
+
+export const ${varName}Info: Contract<${contractType}> = {
+  contract: ${varName}Contract,
+  address: '${address}',
+  contractFile: '${contractFile}',
+};
+`;
+    return fileContents;
+};
+exports.generateIndexFile = generateIndexFile;
+const generateTypesFile = (abi, contractName) => {
+    const name = core_1.toCamelCase(contractName, true);
+    const typings = declaration_1.makeTypes(abi);
+    const fileContents = `import { ClarityTypes, Transaction } from '@clarigen/core';
+
+// prettier-ignore
+export interface ${name}Contract {
+${typings}
+}
+`;
+    return fileContents;
+};
+exports.generateTypesFile = generateTypesFile;
+const generateProjectIndexFile = (config) => {
+    const imports = [];
+    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 = `\n\n// prettier-ignore
+export const accounts = {
+  ${accountLines.join('\n  ')}
+};`;
+    }
+    config.contracts.forEach((contract) => {
+        const contractName = core_1.getContractNameFromPath(contract.file);
+        const contractVar = core_1.toCamelCase(contractName);
+        const contractInfo = `${contractVar}Info`;
+        const contractInterface = `${core_1.toCamelCase(contractName, true)}Contract`;
+        const dirName = path_1.dirname(contract.file);
+        const importPath = `'./${path_1.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 file = `${imports.join('\n')}
+${exports.join('\n')}
+
+export const contracts = {
+  ${contractMap.join('\n  ')}
+};${accounts}
+`;
+    return file;
+};
+exports.generateProjectIndexFile = generateProjectIndexFile;

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+var command_1 = require("@oclif/command");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return command_1.run; } });
+__exportStar(require("./config"), exports);
+__exportStar(require("./generate/declaration"), exports);
+__exportStar(require("./generate/files"), exports);
+__exportStar(require("./commands"), exports);

package/dist/start.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("@oclif/errors");
+const flush_1 = __importDefault(require("@oclif/command/flush"));
+const index_1 = require("./index");
+index_1.run().then(flush_1.default, errors_1.handle);

package/dist/utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProject = exports.generateFilesForContract = void 0;
+const files_1 = require("./generate/files");
+const core_1 = require("@clarigen/core");
+const native_bin_1 = require("@clarigen/native-bin");
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const config_1 = require("./config");
+const generateFilesForContract = async ({ contractFile: _contractFile, outputFolder, provider, contractAddress, dirName, }) => {
+    const contractFile = path_1.resolve(process.cwd(), _contractFile);
+    const contractName = core_1.getContractNameFromPath(contractFile);
+    const abi = await files_1.generateInterface({
+        contractFile,
+        provider,
+        contractAddress,
+    });
+    const typesFile = files_1.generateTypesFile(abi, contractName);
+    if (!contractAddress && process.env.NODE_ENV !== 'test') {
+        console.warn('Please provide an address with every contract.');
+    }
+    const indexFile = files_1.generateIndexFile({
+        contractFile: path_1.relative(process.cwd(), contractFile),
+        address: contractAddress || '',
+    });
+    const abiFile = files_1.generateInterfaceFile({ contractFile, abi });
+    const baseDir = outputFolder || path_1.resolve(process.cwd(), `tmp/${contractName}`);
+    const outputPath = path_1.resolve(baseDir, dirName || '.', contractName);
+    await promises_1.mkdir(outputPath, { recursive: true });
+    await promises_1.writeFile(path_1.resolve(outputPath, 'abi.ts'), abiFile);
+    await promises_1.writeFile(path_1.resolve(outputPath, 'index.ts'), indexFile);
+    await promises_1.writeFile(path_1.resolve(outputPath, 'types.ts'), typesFile);
+};
+exports.generateFilesForContract = generateFilesForContract;
+const generateProject = async (projectPath) => {
+    const configFile = await config_1.getConfigFile(projectPath);
+    const { contractsDir, outputDir, contracts } = configFile;
+    const outputFolder = path_1.resolve(projectPath, outputDir);
+    const provider = await native_bin_1.createClarityBin();
+    // this needs to be serial
+    for (const contract of contracts) {
+        const contractFile = path_1.resolve(projectPath, contractsDir, contract.file);
+        const dirName = path_1.dirname(contract.file);
+        await exports.generateFilesForContract({
+            contractFile,
+            outputFolder: outputFolder,
+            provider,
+            contractAddress: contract.address,
+            dirName,
+        });
+    }
+    const indexFile = files_1.generateProjectIndexFile(configFile);
+    const indexPath = path_1.resolve(outputFolder, 'index.ts');
+    await promises_1.writeFile(indexPath, indexFile);
+};
+exports.generateProject = generateProject;

package/package.json

@@ -2,13 +2,13 @@
   "name": "@clarigen/cli",
   "description": "A CLI for generating a Typescript interface for a Clarity contract.",
   "author": "Hank Stoever",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "MIT",
   "main": "dist/index.js",
   "files": [
     "dist",
     "src",
-    "/oclif.manifest.json"
+    "oclif.manifest.json"
   ],
   "engines": {
     "node": ">=10"
@@ -18,10 +18,11 @@
     "start": "ts-node-script src/start.ts",
     "compile": "ncc build src/index.ts --no-source-map-register -e @oclif/command -e @oclif/errors",
     "build-single-file": "yarn compile && oclif-dev readme",
-    "build": "tsdx build && oclif-dev readme",
+    "build": "rm -rf dist && tsc -b",
     "test": "tsdx test",
     "lint": "tsdx lint",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "yarn build"
   },
   "bin": {
     "clarigen": "./bin/run"
@@ -37,25 +38,26 @@
     "trailingComma": "es5"
   },
   "devDependencies": {
-    "@oclif/config": "^1.17.0",
     "@oclif/dev-cli": "^1.26.0",
     "@oclif/errors": "^1.3.4",
     "@vercel/ncc": "0.27.0",
-    "chokidar": "3.5.1",
     "oclif": "^1.16.1",
     "ts-node": "^9.1.1"
   },
   "dependencies": {
-    "@clarigen/core": "^0.2.0",
-    "@clarigen/native-bin": "^0.2.0",
+    "@clarigen/core": "0.2.3",
+    "@clarigen/native-bin": "0.2.7",
     "@ltd/j-toml": "1.12.2",
     "@oclif/command": "^1.8.0",
+    "@oclif/config": "^1.17.0",
+    "@oclif/plugin-help": "3.2.3",
     "@stacks/wallet-sdk": "1.0.0-wallet-sdk.4",
     "chalk": "4.1.0",
+    "chokidar": "3.5.1",
     "ora": "5.4.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c8f86f1c4793471c0df2ae80e25aaf7562d52eeb"
+  "gitHead": "1a82667ab26f312b401cbbd84aca4d1879e7e1a6"
 }

package/src/clarinet-config.ts

@@ -24,12 +24,9 @@ export async function getClarinetDevConfig(
 ): Promise<ClarinetDevConfig> {
   const baseConfigPath = resolve(folder, 'settings', 'Devnet.toml');
   const configContents = await readFile(baseConfigPath, { encoding: 'utf-8' });
-  const config = (parse(
-    configContents,
-    1.0,
-    '\n',
-    false
-  ) as unknown) as ClarinetDevConfig;
+  const config = (parse(configContents, 1.0, '\n', true, {
+    longer: true,
+  }) as unknown) as ClarinetDevConfig;
   return config;
 }
 
@@ -49,7 +46,7 @@ export async function getClarinetConfig(folder: string) {
     configContents,
     1.0,
     '\n',
-    false
+    true
   ) as unknown) as ClarinetConfig;
   return config;
 }

package/src/commands/contract.ts

@@ -4,6 +4,7 @@ import { generateFilesForContract } from '../utils';
 export class Contract extends Command {
   static description = `Generate files for a single contract`;
   static strict = true;
+  static hidden = true;
 
   static flags = {
     help: flags.help({ char: 'h' }),

package/src/commands/index.ts

@@ -1,3 +1,67 @@
-import { Generate } from './generate';
+import { Command, flags } from '@oclif/command';
+import { generateProject } from '../utils';
+import { getConfigFile } from '../config';
+import { watch } from 'chokidar';
+import { basename } from 'path';
+import { red, green } from 'chalk';
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const ora = require('ora');
 
-export default Generate;
+export class Generate extends Command {
+  static description = `Generate project files`;
+  static strict = true;
+  static hidden = false;
+
+  static flags = {
+    help: flags.help({ char: 'h' }),
+    watch: flags.boolean({
+      char: 'w',
+      description: 'Watch for changes to your contracts',
+    }),
+  };
+
+  static args = [];
+
+  async run() {
+    const { flags } = this.parse(Generate);
+    const cwd = process.cwd();
+
+    if (flags.watch) {
+      const spinner = ora('Generating files').start();
+      const { contractsDir } = await getConfigFile(cwd);
+      const watcher = watch([contractsDir], {
+        cwd,
+      });
+      try {
+        await generateProject(cwd);
+        spinner.succeed(`Finished generating files. Watching for changes.`);
+      } catch (error) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        spinner.fail(`Error generating files.\n${(error as any).message}`);
+      }
+      watcher.on('change', async (path) => {
+        const file = basename(path);
+        spinner.clear();
+        spinner.start(`Change detected for ${green(file)}, generating.`);
+        try {
+          await generateProject(cwd);
+          spinner.succeed(
+            `Finished generating files for ${green(
+              file
+            )}. Watching for changes.`
+          );
+        } catch (error) {
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+          const msg = (error as any).message;
+          spinner.fail(`Error after saving ${red(file)}.\n${msg}`);
+        }
+      });
+      process.on('SIGINT', async () => {
+        await watcher.close();
+        process.exit();
+      });
+    } else {
+      await generateProject(cwd);
+    }
+  }
+}

package/src/generate/files.ts

@@ -8,7 +8,7 @@ import {
   getContractNameFromPath,
 } from '@clarigen/core';
 import { makeTypes } from './declaration';
-import { ConfigContract, ConfigFile } from 'src/config';
+import { ConfigContract, ConfigFile } from '../config';
 import { dirname, resolve, join } from 'path';
 
 export const generateInterface = async ({
@@ -31,7 +31,10 @@ export const generateInterface = async ({
     '--costs',
     '--assets',
   ]);
-  if (receipt.stderr) {
+  if (
+    receipt.stderr &&
+    !receipt.stderr.includes('Used unimplemented cost function')
+  ) {
     throw new Error(`Error on ${contractFile}:
   ${receipt.stderr}
     `);
@@ -133,8 +136,19 @@ export const generateProjectIndexFile = (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 = `\n\n// prettier-ignore
-export const accounts = ${JSON.stringify(config.accounts, null, 2)};`;
+export const accounts = {
+  ${accountLines.join('\n  ')}
+};`;
   }
 
   config.contracts.forEach((contract) => {

package/src/index.ts

@@ -2,3 +2,4 @@ export { run } from '@oclif/command';
 export * from './config';
 export * from './generate/declaration';
 export * from './generate/files';
+export * from './commands';

package/CHANGELOG.md

@@ -1,29 +0,0 @@
-# @clarigen/cli
-
-## 0.2.0
-### Minor Changes
-
-- fd1b36b: This version contains a number of big changes!
-  
-  My favorite addition is the addition of a `@clarigen/native-bin` package. This removes the need to manually build and specify your local version of the `clarity-cli` binary. Most of this code was taken from the `@blockstack/clarity-native-bin` library. Users on Apple Silicon will also automatically download a pre-built binary (which was not previously available).
-  
-  These changes should really improve DX for project setup, as well as the ability to run Clarigen in CI.
-  
-  Other changes:
-  
-  - **Breaking change** JS types for functions that return `uint` or `int` types now use the `BigInt` native JavaScript type.
-    - Although this is a breaking change, this is not a major update. Clarigen is still 0.x and is not in wide use.
-  - **Breaking change**: Projects that have a `clarinet` configuration now look for the `Devnet.toml` file (instead of `Development.toml`)
-  - Clarity type conversion (between hex and JS) has been consolidated into the `core` library
-  - Bug fixes for boolean type conversion for function parameters
-  - Added `get-stx-balance` test utility function
-  - Added util for getting boot contract identifiers
-  - `clarity-cli` is now launched in testnet mode by default
-  - Added changesets for better release management
-  - Added Github Actions CI to this package
-
-### Patch Changes
-
-- Updated dependencies [fd1b36b]
-  - @clarigen/core@0.2.0
-  - @clarigen/native-bin@0.2.0

package/src/commands/generate.ts

@@ -1,63 +0,0 @@
-import { Command, flags } from '@oclif/command';
-import { generateProject } from '../utils';
-import { getConfigFile } from '../config';
-import { watch } from 'chokidar';
-import { basename } from 'path';
-import { red, green } from 'chalk';
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const ora = require('ora');
-
-export class Generate extends Command {
-  static description = `Generate project files`;
-  static strict = true;
-
-  static flags = {
-    help: flags.help({ char: 'h' }),
-    watch: flags.boolean({
-      char: 'w',
-      description: 'Watch for changes to your contracts',
-    }),
-  };
-
-  static args = [];
-
-  async run() {
-    const { flags } = this.parse(Generate);
-    const cwd = process.cwd();
-
-    if (flags.watch) {
-      const spinner = ora('Generating files').start();
-      const { contractsDir } = await getConfigFile(cwd);
-      const watcher = watch([contractsDir], {
-        cwd,
-      });
-      try {
-        await generateProject(cwd);
-        spinner.succeed(`Finished generating files. Watching for changes.`);
-      } catch (error: any) {
-        spinner.fail(`Error generating files.\n${error.message}`);
-      }
-      watcher.on('change', async (path) => {
-        const file = basename(path);
-        spinner.clear();
-        spinner.start(`Change detected for ${green(file)}, generating.`);
-        try {
-          await generateProject(cwd);
-          spinner.succeed(
-            `Finished generating files for ${green(
-              file
-            )}. Watching for changes.`
-          );
-        } catch (error: any) {
-          spinner.fail(`Error after saving ${red(file)}.\n${error.message}`);
-        }
-      });
-      process.on('SIGINT', async () => {
-        await watcher.close();
-        process.exit();
-      });
-    } else {
-      await generateProject(cwd);
-    }
-  }
-}