@clarigen/cli 0.3.6 → 1.0.0-next.3

package/dist/clarinet-config.js

@@ -4,21 +4,22 @@ exports.getClarinetAccounts = exports.sortClarinetContracts = exports.getContrac
 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");
+const wallet_sdk_1 = require("micro-stacks/wallet-sdk");
 const toposort_1 = require("toposort");
+const crypto_1 = require("micro-stacks/crypto");
 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, {
+    const baseConfigPath = (0, path_1.resolve)(folder, 'settings', 'Devnet.toml');
+    const configContents = await (0, promises_1.readFile)(baseConfigPath, { encoding: 'utf-8' });
+    const config = (0, 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);
+    const baseConfigPath = (0, path_1.resolve)(folder, 'Clarinet.toml');
+    const configContents = await (0, promises_1.readFile)(baseConfigPath, { encoding: 'utf-8' });
+    const config = (0, j_toml_1.parse)(configContents, 1.0, '\n', true);
     return config;
 }
 exports.getClarinetConfig = getClarinetConfig;
@@ -26,12 +27,13 @@ async function getContractsFromClarinet(folder, accounts) {
     const clarinetConfig = await getClarinetConfig(folder);
     const deployerAddress = accounts.deployer.address;
     const sortedContracts = sortClarinetContracts(clarinetConfig.contracts);
-    const contracts = sortedContracts.map(contractName => {
+    const contracts = sortedContracts.map((contractName) => {
         const info = clarinetConfig.contracts[contractName];
         const file = info.path.replace(/^contracts\//, '');
         return {
             file,
             address: deployerAddress,
+            name: contractName,
         };
     });
     return contracts;
@@ -44,19 +46,16 @@ function sortClarinetContracts(contractsConfig) {
         nodes.push(contractName);
         info.depends_on.forEach((dependency) => edges.push([contractName, dependency]));
     });
-    const sorted = toposort_1.array(nodes, edges).reverse();
+    const sorted = (0, toposort_1.array)(nodes, edges).reverse();
     return sorted;
 }
 exports.sortClarinetContracts = sortClarinetContracts;
 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 wallet = await (0, wallet_sdk_1.generateWallet)(info.mnemonic, 'password');
         const [account] = wallet.accounts;
-        const address = wallet_sdk_1.getStxAddress({ account });
+        const address = (0, wallet_sdk_1.getStxAddressFromAccount)(account, crypto_1.StacksNetworkVersion.testnetP2PKH);
         return [
             key,
             {

package/dist/commands/index.js

@@ -15,12 +15,12 @@ class Generate extends command_1.Command {
         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], {
+            const { contractsDir } = await (0, config_1.getProjectConfig)(cwd);
+            const watcher = (0, chokidar_1.watch)([contractsDir], {
                 cwd,
             });
             try {
-                await utils_1.generateProject(cwd);
+                await (0, utils_1.generateProject)(cwd);
                 spinner.succeed(`Finished generating files. Watching for changes.`);
             }
             catch (error) {
@@ -28,17 +28,17 @@ class Generate extends command_1.Command {
                 spinner.fail(`Error generating files.\n${error.message}`);
             }
             watcher.on('change', async (path) => {
-                const file = path_1.basename(path);
+                const file = (0, path_1.basename)(path);
                 spinner.clear();
-                spinner.start(`Change detected for ${chalk_1.green(file)}, generating.`);
+                spinner.start(`Change detected for ${(0, chalk_1.green)(file)}, generating.`);
                 try {
-                    await utils_1.generateProject(cwd);
-                    spinner.succeed(`Finished generating files for ${chalk_1.green(file)}. Watching for changes.`);
+                    await (0, utils_1.generateProject)(cwd);
+                    spinner.succeed(`Finished generating files for ${(0, 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}`);
+                    spinner.fail(`Error after saving ${(0, chalk_1.red)(file)}.\n${msg}`);
                 }
             });
             process.on('SIGINT', async () => {
@@ -47,7 +47,7 @@ class Generate extends command_1.Command {
             });
         }
         else {
-            await utils_1.generateProject(cwd);
+            await (0, utils_1.generateProject)(cwd);
         }
     }
 }

package/dist/config.js

@@ -1,31 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfigFile = void 0;
+exports.getProjectConfig = exports.getConfigFile = exports.configFileExists = exports.configFilePath = exports.defaultConfigFile = void 0;
 const path_1 = require("path");
 const promises_1 = require("fs/promises");
+const fs_1 = require("fs");
 const clarinet_config_1 = require("./clarinet-config");
+exports.defaultConfigFile = {
+    outputDir: 'src/clarigen',
+    clarinet: '.',
+};
+function configFilePath(rootPath) {
+    return (0, path_1.resolve)(rootPath, 'clarigen.config.json');
+}
+exports.configFilePath = configFilePath;
+async function configFileExists(configPath) {
+    try {
+        await (0, promises_1.access)(configPath, fs_1.constants.R_OK);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.configFileExists = configFileExists;
 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'));
+    const fullPath = configFilePath(rootPath);
+    const exists = await configFileExists(fullPath);
+    if (exists) {
+        const configContents = await (0, promises_1.readFile)(fullPath, { encoding: 'utf-8' });
+        const configFile = JSON.parse(configContents);
         return {
+            ...exports.defaultConfigFile,
             ...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;
+    return exports.defaultConfigFile;
 }
 exports.getConfigFile = getConfigFile;
+async function getProjectConfig(rootPath) {
+    const configFile = await getConfigFile(rootPath);
+    const clarinetPath = (0, path_1.resolve)(rootPath, configFile.clarinet || '.');
+    const accounts = await (0, clarinet_config_1.getClarinetAccounts)(clarinetPath);
+    const contracts = await (0, clarinet_config_1.getContractsFromClarinet)(clarinetPath, accounts);
+    const contractsDir = (0, path_1.relative)(process.cwd(), (0, path_1.join)(configFile.clarinet, 'contracts'));
+    return {
+        ...configFile,
+        contracts,
+        contractsDir,
+        accounts,
+        clarinet: configFile.clarinet || '.',
+    };
+}
+exports.getProjectConfig = getProjectConfig;

package/dist/generate/declaration.js

@@ -1,57 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTypes = exports.jsTypeFromAbiType = exports.cvFromType = void 0;
-const transactions_1 = require("@stacks/transactions");
+exports.makePureTypes = exports.jsTypeFromAbiType = void 0;
+const transactions_1 = require("micro-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 reserved_words_1 = require("reserved-words");
 const jsTypeFromAbiType = (val, isArgument = false) => {
-    if (transactions_1.isClarityAbiPrimitive(val)) {
+    if ((0, transactions_1.isClarityAbiPrimitive)(val)) {
         if (val === 'uint128') {
             if (isArgument)
                 return 'number | bigint';
@@ -78,36 +32,36 @@ const jsTypeFromAbiType = (val, isArgument = false) => {
             throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);
         }
     }
-    else if (transactions_1.isClarityAbiBuffer(val)) {
-        return 'Buffer';
+    else if ((0, transactions_1.isClarityAbiBuffer)(val)) {
+        return 'Uint8Array';
     }
-    else if (transactions_1.isClarityAbiResponse(val)) {
-        const ok = exports.jsTypeFromAbiType(val.response.ok);
-        const err = exports.jsTypeFromAbiType(val.response.error);
+    else if ((0, transactions_1.isClarityAbiResponse)(val)) {
+        const ok = (0, exports.jsTypeFromAbiType)(val.response.ok);
+        const err = (0, exports.jsTypeFromAbiType)(val.response.error);
         return `ClarityTypes.Response<${ok}, ${err}>`;
     }
-    else if (transactions_1.isClarityAbiOptional(val)) {
-        const innerType = exports.jsTypeFromAbiType(val.optional);
+    else if ((0, transactions_1.isClarityAbiOptional)(val)) {
+        const innerType = (0, exports.jsTypeFromAbiType)(val.optional);
         return `${innerType} | null`;
     }
-    else if (transactions_1.isClarityAbiTuple(val)) {
+    else if ((0, transactions_1.isClarityAbiTuple)(val)) {
         const tupleDefs = [];
         val.tuple.forEach(({ name, type }) => {
-            const innerType = exports.jsTypeFromAbiType(type);
+            const innerType = (0, exports.jsTypeFromAbiType)(type);
             tupleDefs.push(`"${name}": ${innerType}`);
         });
         return `{
   ${tupleDefs.join(';\n  ')}
     }`;
     }
-    else if (transactions_1.isClarityAbiList(val)) {
-        const innerType = exports.jsTypeFromAbiType(val.list.type);
+    else if ((0, transactions_1.isClarityAbiList)(val)) {
+        const innerType = (0, exports.jsTypeFromAbiType)(val.list.type);
         return `${innerType}[]`;
     }
-    else if (transactions_1.isClarityAbiStringAscii(val)) {
+    else if ((0, transactions_1.isClarityAbiStringAscii)(val)) {
         return 'string';
     }
-    else if (transactions_1.isClarityAbiStringUtf8(val)) {
+    else if ((0, transactions_1.isClarityAbiStringUtf8)(val)) {
         return 'string';
     }
     else if (val === 'trait_reference') {
@@ -118,40 +72,49 @@ const jsTypeFromAbiType = (val, isArgument = false) => {
     }
 };
 exports.jsTypeFromAbiType = jsTypeFromAbiType;
-const makeTypes = (abi) => {
+// Check if it's a reserved word, and then camelCase
+function getArgName(name) {
+    const camel = (0, core_1.toCamelCase)(name);
+    const prefix = (0, reserved_words_1.check)(camel, 6) ? '_' : '';
+    return `${prefix}${camel}`;
+}
+const accessToReturnType = {
+    public: 'Public',
+    read_only: 'ReadOnly',
+    private: 'Private',
+};
+function makePureTypes(abi) {
     let typings = '';
     abi.functions.forEach((func, index) => {
-        if (func.access === 'private')
-            return;
-        let functionLine = `${core_1.toCamelCase(func.name)}: `;
+        let functionLine = `${(0, core_1.toCamelCase)(func.name)}: `;
         const args = func.args.map((arg) => {
-            return `${core_1.toCamelCase(arg.name)}: ${exports.jsTypeFromAbiType(arg.type, true)}`;
+            return `${getArgName(arg.name)}: ${(0, exports.jsTypeFromAbiType)(arg.type, true)}`;
         });
         functionLine += `(${args.join(', ')}) => `;
+        const funcType = accessToReturnType[func.access];
+        functionLine += `ContractCalls.${funcType}<`;
         if (func.access === 'public') {
             const { type } = func.outputs;
-            if (!transactions_1.isClarityAbiResponse(type))
+            if (!(0, 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}>;`;
+            const ok = (0, exports.jsTypeFromAbiType)(type.response.ok);
+            const err = (0, 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}>;`;
-            // }
+            const returnType = (0, exports.jsTypeFromAbiType)(func.outputs.type);
+            functionLine += `${returnType}>;`;
         }
         typings += `${index === 0 ? '' : '\n'}  ${functionLine}`;
     });
+    abi.maps.forEach((map) => {
+        let functionLine = `${(0, core_1.toCamelCase)(map.name)}: `;
+        const keyType = (0, exports.jsTypeFromAbiType)(map.key, true);
+        const arg = `key: ${keyType}`;
+        const valType = (0, exports.jsTypeFromAbiType)(map.value);
+        functionLine += `(${arg}) => ContractCalls.Map<${keyType}, ${valType}>;`;
+        typings += `\n  ${functionLine}`;
+    });
     return typings;
-};
-exports.makeTypes = makeTypes;
+}
+exports.makePureTypes = makePureTypes;

package/dist/generate/files.js

@@ -3,11 +3,9 @@ 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 __1 = require("..");
+const generateInterface = async ({ provider, contractFile, contractAddress, contractName, }) => {
     const receipt = await provider.runCommand([
         'launch',
         `${contractAddress}.${contractName}`,
@@ -17,7 +15,7 @@ const generateInterface = async ({ provider: _provider, contractFile, contractAd
         '--costs',
         '--assets',
     ]);
-    if (native_bin_1.hasStdErr(receipt.stderr)) {
+    if ((0, native_bin_1.hasStdErr)(receipt.stderr)) {
         throw new Error(`Error on ${contractFile}:
   ${receipt.stderr}
     `);
@@ -47,10 +45,10 @@ const generateInterface = async ({ provider: _provider, contractFile, contractAd
     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 generateInterfaceFile = ({ contractName, abi, }) => {
+    const variableName = (0, core_1.toCamelCase)(contractName, true);
+    const { clarity_version, ...rest } = abi;
+    const abiString = JSON.stringify(rest, null, 2);
     const fileContents = `import { ClarityAbi } from '@clarigen/core';
 
 // prettier-ignore
@@ -59,34 +57,39 @@ 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 generateIndexFile = ({ contractFile, contractAddress, contractName, }) => {
+    const contractTitle = (0, core_1.toCamelCase)(contractName, true);
+    const varName = (0, core_1.toCamelCase)(contractName);
     const contractType = `${contractTitle}Contract`;
-    const fileContents = `import { proxy, BaseProvider, Contract } from '@clarigen/core';
+    const interfaceVar = `${contractTitle}Interface`;
+    const fileContents = `import { pureProxy, Contract } from '@clarigen/core';
 import type { ${contractType} } from './types';
-import { ${contractTitle}Interface } from './abi';
+import { ${interfaceVar} } from './abi';
 export type { ${contractType} } from './types';
 
-export const ${varName}Contract = (provider: BaseProvider) => {
-  const contract = proxy<${contractType}>(${contractTitle}Interface, provider);
-  return contract;
-};
+export function ${varName}Contract(contractAddress: string, contractName: string) {
+  return pureProxy<${contractType}>({
+    abi: ${interfaceVar},
+    contractAddress,
+    contractName,
+  });
+}
 
 export const ${varName}Info: Contract<${contractType}> = {
   contract: ${varName}Contract,
-  address: '${address}',
+  address: '${contractAddress}',
   contractFile: '${contractFile}',
+  name: '${contractName}',
+  abi: ${interfaceVar},
 };
 `;
     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';
+    const name = (0, core_1.toCamelCase)(contractName, true);
+    const typings = (0, __1.makePureTypes)(abi);
+    const fileContents = `import { ClarityTypes, ContractCalls } from '@clarigen/core';
 
 // prettier-ignore
 export interface ${name}Contract {
@@ -97,7 +100,9 @@ ${typings}
 };
 exports.generateTypesFile = generateTypesFile;
 const generateProjectIndexFile = (config) => {
-    const imports = [];
+    const imports = [
+        "import type { ContractInstances } from '@clarigen/core';",
+    ];
     const exports = [];
     const contractMap = [];
     let accounts = '';
@@ -116,12 +121,12 @@ export const accounts = {
 };`;
     }
     config.contracts.forEach((contract) => {
-        const contractName = core_1.getContractNameFromPath(contract.file);
-        const contractVar = core_1.toCamelCase(contractName);
+        const contractName = contract.name;
+        const contractVar = (0, 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 contractInterface = `${(0, core_1.toCamelCase)(contractName, true)}Contract`;
+        const dirName = (0, path_1.dirname)(contract.file);
+        const importPath = `'./${(0, path_1.join)(dirName || '.', contractName)}'`;
         const _import = `import { ${contractInfo} } from ${importPath};`;
         imports.push(_import);
         const _export = `export type { ${contractInterface} } from ${importPath};`;
@@ -129,9 +134,10 @@ export const accounts = {
         const map = `${contractVar}: ${contractInfo},`;
         contractMap.push(map);
     });
+    const contractsType = `\nexport type Contracts = ContractInstances<typeof contracts>;\n`;
     const file = `${imports.join('\n')}
 ${exports.join('\n')}
-
+${contractsType}
 export const contracts = {
   ${contractMap.join('\n  ')}
 };${accounts}

package/dist/start.js

@@ -6,4 +6,4 @@ 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);
+(0, index_1.run)().then(flush_1.default, errors_1.handle);

package/dist/utils.js

@@ -2,55 +2,52 @@
 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({
+const generateFilesForContract = async ({ contractFile: _contractFile, outputFolder, provider, contractAddress, dirName, contractName, }) => {
+    const contractFile = (0, path_1.resolve)(process.cwd(), _contractFile);
+    const abi = await (0, files_1.generateInterface)({
         contractFile,
         provider,
         contractAddress,
+        contractName,
     });
-    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 typesFile = (0, files_1.generateTypesFile)(abi, contractName);
+    const indexFile = (0, files_1.generateIndexFile)({
+        contractFile: (0, path_1.relative)(process.cwd(), contractFile),
+        contractAddress: contractAddress,
+        contractName,
     });
-    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);
+    const abiFile = (0, files_1.generateInterfaceFile)({ contractName, abi });
+    const outputPath = (0, path_1.resolve)(outputFolder, dirName || '.', contractName);
+    await (0, promises_1.mkdir)(outputPath, { recursive: true });
+    await (0, promises_1.writeFile)((0, path_1.resolve)(outputPath, 'abi.ts'), abiFile);
+    await (0, promises_1.writeFile)((0, path_1.resolve)(outputPath, 'index.ts'), indexFile);
+    await (0, promises_1.writeFile)((0, path_1.resolve)(outputPath, 'types.ts'), typesFile);
 };
 exports.generateFilesForContract = generateFilesForContract;
 const generateProject = async (projectPath) => {
-    const configFile = await config_1.getConfigFile(projectPath);
+    const configFile = await (0, config_1.getProjectConfig)(projectPath);
     const { contractsDir, outputDir, contracts } = configFile;
-    const outputFolder = path_1.resolve(projectPath, outputDir);
-    const provider = await native_bin_1.createClarityBin();
+    const outputFolder = (0, path_1.resolve)(projectPath, outputDir);
+    const provider = await (0, 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({
+        const contractFile = (0, path_1.resolve)(projectPath, contractsDir, contract.file);
+        const dirName = (0, path_1.dirname)(contract.file);
+        await (0, exports.generateFilesForContract)({
             contractFile,
             outputFolder: outputFolder,
             provider,
             contractAddress: contract.address,
             dirName,
+            contractName: contract.name,
         });
     }
-    const indexFile = files_1.generateProjectIndexFile(configFile);
-    const indexPath = path_1.resolve(outputFolder, 'index.ts');
-    await promises_1.writeFile(indexPath, indexFile);
+    const indexFile = (0, files_1.generateProjectIndexFile)(configFile);
+    const indexPath = (0, path_1.resolve)(outputFolder, 'index.ts');
+    await (0, promises_1.writeFile)(indexPath, indexFile);
 };
 exports.generateProject = generateProject;

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": "0.3.6",
+  "version": "1.0.0-next.3",
   "license": "MIT",
   "main": "dist/index.js",
   "files": [
@@ -19,9 +19,9 @@
     "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": "rm -rf dist && tsc -b",
-    "test": "tsdx test",
+    "test": "jest",
     "lint": "tsdx lint",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit -p tsconfig-test.json",
     "prepublishOnly": "yarn build"
   },
   "bin": {
@@ -40,26 +40,28 @@
   "devDependencies": {
     "@oclif/dev-cli": "^1.26.0",
     "@oclif/errors": "^1.3.4",
+    "@types/reserved-words": "0.1.0",
     "@types/toposort": "2.0.3",
     "@vercel/ncc": "0.27.0",
     "oclif": "^1.16.1",
     "ts-node": "^9.1.1"
   },
   "dependencies": {
-    "@clarigen/core": "0.3.4",
-    "@clarigen/native-bin": "0.3.4",
+    "@clarigen/core": "1.0.0-next.3",
+    "@clarigen/native-bin": "1.0.0-next.3",
     "@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",
+    "micro-stacks": "^0.2.0",
     "ora": "5.4.0",
+    "reserved-words": "0.1.2",
     "toposort": "2.0.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b438736c231e6d6adf20a8e384f03bf522be6a64"
+  "gitHead": "4ef5ca2c7aec78bdc14072f09ada2aab6eff627a"
 }

package/src/clarinet-config.ts

@@ -2,8 +2,12 @@ import { parse } from '@ltd/j-toml';
 import { resolve } from 'path';
 import { readFile } from 'fs/promises';
 import { ConfigContract } from './config';
-import { generateWallet, getStxAddress } from '@stacks/wallet-sdk';
+import {
+  generateWallet,
+  getStxAddressFromAccount,
+} from 'micro-stacks/wallet-sdk';
 import { array as toposort } from 'toposort';
+import { StacksNetworkVersion } from 'micro-stacks/crypto';
 
 interface ClarinetConfigAccount {
   mnemonic: string;
@@ -63,14 +67,15 @@ export async function getContractsFromClarinet(
   const clarinetConfig = await getClarinetConfig(folder);
   const deployerAddress = accounts.deployer.address;
   const sortedContracts = sortClarinetContracts(clarinetConfig.contracts);
-  const contracts: ConfigContract[] = sortedContracts.map(contractName => {
+  const contracts: ConfigContract[] = sortedContracts.map((contractName) => {
     const info = clarinetConfig.contracts[contractName];
     const file = info.path.replace(/^contracts\//, '');
     return {
       file,
       address: deployerAddress,
+      name: contractName,
     };
-  })
+  });
   return contracts;
 }
 
@@ -102,12 +107,12 @@ export async function getClarinetAccounts(
   const devConfig = await getClarinetDevConfig(folder);
   const accountEntries = await Promise.all(
     Object.entries(devConfig.accounts).map(async ([key, info]) => {
-      const wallet = await generateWallet({
-        secretKey: info.mnemonic,
-        password: 'password',
-      });
+      const wallet = await generateWallet(info.mnemonic, 'password');
       const [account] = wallet.accounts;
-      const address = getStxAddress({ account });
+      const address = getStxAddressFromAccount(
+        account,
+        StacksNetworkVersion.testnetP2PKH
+      );
       return [
         key,
         {

package/src/commands/index.ts

@@ -1,6 +1,6 @@
 import { Command, flags } from '@oclif/command';
 import { generateProject } from '../utils';
-import { getConfigFile } from '../config';
+import { getProjectConfig } from '../config';
 import { watch } from 'chokidar';
 import { basename } from 'path';
 import { red, green } from 'chalk';
@@ -28,7 +28,7 @@ export class Generate extends Command {
 
     if (flags.watch) {
       const spinner = ora('Generating files').start();
-      const { contractsDir } = await getConfigFile(cwd);
+      const { contractsDir } = await getProjectConfig(cwd);
       const watcher = watch([contractsDir], {
         cwd,
       });

package/src/config.ts

@@ -1,5 +1,6 @@
 import { resolve, join, relative } from 'path';
-import { readFile } from 'fs/promises';
+import { readFile, access } from 'fs/promises';
+import { constants } from 'fs';
 import {
   ClarinetAccounts,
   getClarinetAccounts,
@@ -9,52 +10,69 @@ import {
 export interface ConfigContract {
   address: string;
   file: string;
+  name: string;
 }
 
-export interface ConfigFileBase {
+export interface ConfigFileContents {
   outputDir: string;
-}
-
-export interface ConfigFileWithClarinet extends ConfigFileBase {
   clarinet: string;
 }
 
-export interface ConfigFileRegular extends ConfigFileBase {
+export interface ConfigFile extends ConfigFileContents {
   contractsDir: string;
   contracts: ConfigContract[];
+  accounts: ClarinetAccounts;
+  clarinet: string;
 }
 
-export type ConfigFileContents = ConfigFileRegular | ConfigFileWithClarinet;
+export const defaultConfigFile: ConfigFileContents = {
+  outputDir: 'src/clarigen',
+  clarinet: '.',
+};
 
-export interface ConfigFileWithClarinetInfo extends ConfigFileRegular {
-  clarinet: string;
-  accounts: ClarinetAccounts;
+export function configFilePath(rootPath: string) {
+  return resolve(rootPath, 'clarigen.config.json');
 }
 
-export type ConfigFile = ConfigFileRegular | ConfigFileWithClarinetInfo;
-
-export async function getConfigFile(rootPath: string): Promise<ConfigFile> {
-  const fullPath = resolve(rootPath, 'clarigen.config.json');
-  const configContents = await readFile(fullPath, { encoding: 'utf-8' });
-  const configFile: ConfigFileContents = JSON.parse(configContents);
-  if (!configFile.outputDir) throw new Error('Config file missing "outputDir"');
-  if ('clarinet' in configFile) {
-    const clarinetPath = resolve(rootPath, configFile.clarinet);
-    const accounts = await getClarinetAccounts(clarinetPath);
-    const contracts = await getContractsFromClarinet(clarinetPath, accounts);
-    const contractsDir = relative(
-      process.cwd(),
-      join(configFile.clarinet, 'contracts')
-    );
+export async function configFileExists(configPath: string): Promise<boolean> {
+  try {
+    await access(configPath, constants.R_OK);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+export async function getConfigFile(
+  rootPath: string
+): Promise<ConfigFileContents> {
+  const fullPath = configFilePath(rootPath);
+  const exists = await configFileExists(fullPath);
+  if (exists) {
+    const configContents = await readFile(fullPath, { encoding: 'utf-8' });
+    const configFile: ConfigFileContents = JSON.parse(configContents);
     return {
+      ...defaultConfigFile,
       ...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;
+  return defaultConfigFile;
+}
+
+export async function getProjectConfig(rootPath: string): Promise<ConfigFile> {
+  const configFile = await getConfigFile(rootPath);
+  const clarinetPath = resolve(rootPath, configFile.clarinet || '.');
+  const accounts = await getClarinetAccounts(clarinetPath);
+  const contracts = await getContractsFromClarinet(clarinetPath, accounts);
+  const contractsDir = relative(
+    process.cwd(),
+    join(configFile.clarinet, 'contracts')
+  );
+  return {
+    ...configFile,
+    contracts,
+    contractsDir,
+    accounts,
+    clarinet: configFile.clarinet || '.',
+  };
 }

package/src/generate/declaration.ts

@@ -1,5 +1,4 @@
 import {
-  ClarityAbiType,
   isClarityAbiBuffer,
   isClarityAbiList,
   isClarityAbiOptional,
@@ -8,44 +7,10 @@ import {
   isClarityAbiStringAscii,
   isClarityAbiStringUtf8,
   isClarityAbiTuple,
-} from '@stacks/transactions';
+} from 'micro-stacks/transactions';
+import { ClarityAbiFunction, ClarityAbiType } from 'micro-stacks/clarity';
 import { toCamelCase, ClarityAbi } from '@clarigen/core';
-
-export const cvFromType = (val: ClarityAbiType) => {
-  if (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 (isClarityAbiBuffer(val)) {
-    return 'ClarityTypes.BufferCV';
-  } else if (isClarityAbiResponse(val)) {
-    return 'ClarityTypes.ResponseCV';
-  } else if (isClarityAbiOptional(val)) {
-    return 'ClarityTypes.OptionalCV';
-  } else if (isClarityAbiTuple(val)) {
-    return 'ClarityTypes.TupleCV';
-  } else if (isClarityAbiList(val)) {
-    return 'ClarityTypes.ListCV';
-  } else if (isClarityAbiStringAscii(val)) {
-    return 'ClarityTypes.StringAsciiCV';
-  } else if (isClarityAbiStringUtf8(val)) {
-    return 'ClarityTypes.StringUtf8CV';
-  } else {
-    throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);
-  }
-};
+import { check } from 'reserved-words';
 
 export const jsTypeFromAbiType = (
   val: ClarityAbiType,
@@ -72,7 +37,7 @@ export const jsTypeFromAbiType = (
       );
     }
   } else if (isClarityAbiBuffer(val)) {
-    return 'Buffer';
+    return 'Uint8Array';
   } else if (isClarityAbiResponse(val)) {
     const ok: any = jsTypeFromAbiType(val.response.ok);
     const err: any = jsTypeFromAbiType(val.response.error);
@@ -103,38 +68,49 @@ export const jsTypeFromAbiType = (
   }
 };
 
-export const makeTypes = (abi: ClarityAbi) => {
+// Check if it's a reserved word, and then camelCase
+function getArgName(name: string) {
+  const camel = toCamelCase(name);
+  const prefix = check(camel, 6) ? '_' : '';
+  return `${prefix}${camel}`;
+}
+
+const accessToReturnType = {
+  public: 'Public',
+  read_only: 'ReadOnly',
+  private: 'Private',
+} as const;
+
+export function makePureTypes(abi: ClarityAbi) {
   let typings = '';
   abi.functions.forEach((func, index) => {
-    if (func.access === 'private') return;
     let functionLine = `${toCamelCase(func.name)}: `;
     const args = func.args.map((arg) => {
-      return `${toCamelCase(arg.name)}: ${jsTypeFromAbiType(arg.type, true)}`;
+      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 (!isClarityAbiResponse(type))
         throw new Error('Expected response type for public function');
-      functionLine += 'Transaction';
       const ok = jsTypeFromAbiType(type.response.ok);
       const err = jsTypeFromAbiType(type.response.error);
-      functionLine += `<${ok}, ${err}>;`;
+      functionLine += `${ok}, ${err}>;`;
     } else {
-      const jsType = 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}>;`;
-      // }
+      const returnType = jsTypeFromAbiType(func.outputs.type);
+      functionLine += `${returnType}>;`;
     }
     typings += `${index === 0 ? '' : '\n'}  ${functionLine}`;
   });
-
+  abi.maps.forEach((map) => {
+    let functionLine = `${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 += `\n  ${functionLine}`;
+  });
   return typings;
-};
+}

package/src/generate/files.ts

@@ -1,28 +1,20 @@
-import {
-  NativeClarityBinProvider,
-  createClarityBin,
-  hasStdErr,
-} from '@clarigen/native-bin';
-import {
-  ClarityAbi,
-  toCamelCase,
-  getContractNameFromPath,
-} from '@clarigen/core';
-import { makeTypes } from './declaration';
+import { NativeClarityBinProvider, hasStdErr } from '@clarigen/native-bin';
+import { ClarityAbi, toCamelCase } from '@clarigen/core';
 import { ConfigContract, ConfigFile } from '../config';
 import { dirname, resolve, join } from 'path';
+import { makePureTypes } from '..';
 
 export const generateInterface = async ({
-  provider: _provider,
+  provider,
   contractFile,
-  contractAddress = 'S1G2081040G2081040G2081040G208105NK8PE5',
+  contractAddress,
+  contractName,
 }: {
   contractFile: string;
-  provider?: NativeClarityBinProvider;
-  contractAddress?: string;
+  provider: NativeClarityBinProvider;
+  contractAddress: string;
+  contractName: string;
 }): Promise<ClarityAbi> => {
-  const provider = _provider || (await createClarityBin());
-  const contractName = getContractNameFromPath(contractFile);
   const receipt = await provider.runCommand([
     'launch',
     `${contractAddress}.${contractName}`,
@@ -62,15 +54,15 @@ export const generateInterface = async ({
 };
 
 export const generateInterfaceFile = ({
-  contractFile,
+  contractName,
   abi,
 }: {
-  contractFile: string;
+  contractName: string;
   abi: ClarityAbi;
 }) => {
-  const contractName = getContractNameFromPath(contractFile);
   const variableName = toCamelCase(contractName, true);
-  const abiString = JSON.stringify(abi, null, 2);
+  const { clarity_version, ...rest } = abi;
+  const abiString = JSON.stringify(rest, null, 2);
 
   const fileContents = `import { ClarityAbi } from '@clarigen/core';
 
@@ -83,30 +75,37 @@ export const ${variableName}Interface: ClarityAbi = ${abiString};
 
 export const generateIndexFile = ({
   contractFile,
-  address,
+  contractAddress,
+  contractName,
 }: {
   contractFile: string;
-  address: string;
+  contractAddress: string;
+  contractName: string;
 }) => {
-  const contractName = getContractNameFromPath(contractFile);
   const contractTitle = toCamelCase(contractName, true);
   const varName = toCamelCase(contractName);
   const contractType = `${contractTitle}Contract`;
+  const interfaceVar = `${contractTitle}Interface`;
 
-  const fileContents = `import { proxy, BaseProvider, Contract } from '@clarigen/core';
+  const fileContents = `import { pureProxy, Contract } from '@clarigen/core';
 import type { ${contractType} } from './types';
-import { ${contractTitle}Interface } from './abi';
+import { ${interfaceVar} } from './abi';
 export type { ${contractType} } from './types';
 
-export const ${varName}Contract = (provider: BaseProvider) => {
-  const contract = proxy<${contractType}>(${contractTitle}Interface, provider);
-  return contract;
-};
+export function ${varName}Contract(contractAddress: string, contractName: string) {
+  return pureProxy<${contractType}>({
+    abi: ${interfaceVar},
+    contractAddress,
+    contractName,
+  });
+}
 
 export const ${varName}Info: Contract<${contractType}> = {
   contract: ${varName}Contract,
-  address: '${address}',
+  address: '${contractAddress}',
   contractFile: '${contractFile}',
+  name: '${contractName}',
+  abi: ${interfaceVar},
 };
 `;
 
@@ -115,8 +114,8 @@ export const ${varName}Info: Contract<${contractType}> = {
 
 export const generateTypesFile = (abi: ClarityAbi, contractName: string) => {
   const name = toCamelCase(contractName, true);
-  const typings = makeTypes(abi);
-  const fileContents = `import { ClarityTypes, Transaction } from '@clarigen/core';
+  const typings = makePureTypes(abi);
+  const fileContents = `import { ClarityTypes, ContractCalls } from '@clarigen/core';
 
 // prettier-ignore
 export interface ${name}Contract {
@@ -128,7 +127,9 @@ ${typings}
 };
 
 export const generateProjectIndexFile = (config: ConfigFile) => {
-  const imports: string[] = [];
+  const imports: string[] = [
+    "import type { ContractInstances } from '@clarigen/core';",
+  ];
   const exports: string[] = [];
   const contractMap: string[] = [];
 
@@ -150,7 +151,7 @@ export const accounts = {
   }
 
   config.contracts.forEach((contract) => {
-    const contractName = getContractNameFromPath(contract.file);
+    const contractName = contract.name;
     const contractVar = toCamelCase(contractName);
     const contractInfo = `${contractVar}Info`;
     const contractInterface = `${toCamelCase(contractName, true)}Contract`;
@@ -167,9 +168,11 @@ export const accounts = {
     contractMap.push(map);
   });
 
+  const contractsType = `\nexport type Contracts = ContractInstances<typeof contracts>;\n`;
+
   const file = `${imports.join('\n')}
 ${exports.join('\n')}
-
+${contractsType}
 export const contracts = {
   ${contractMap.join('\n  ')}
 };${accounts}

package/src/utils.ts

@@ -5,14 +5,13 @@ import {
   generateProjectIndexFile,
   generateTypesFile,
 } from './generate/files';
-import { getContractNameFromPath } from '@clarigen/core';
 import {
   NativeClarityBinProvider,
   createClarityBin,
 } from '@clarigen/native-bin';
 import { resolve, relative, dirname } from 'path';
 import { mkdir, writeFile } from 'fs/promises';
-import { getConfigFile } from './config';
+import { getProjectConfig } from './config';
 
 export const generateFilesForContract = async ({
   contractFile: _contractFile,
@@ -20,33 +19,32 @@ export const generateFilesForContract = async ({
   provider,
   contractAddress,
   dirName,
+  contractName,
 }: {
   contractFile: string;
-  outputFolder?: string;
-  provider?: NativeClarityBinProvider;
-  contractAddress?: string;
+  outputFolder: string;
+  provider: NativeClarityBinProvider;
+  contractAddress: string;
   dirName?: string;
+  contractName: string;
 }) => {
   const contractFile = resolve(process.cwd(), _contractFile);
-  const contractName = getContractNameFromPath(contractFile);
 
   const abi = await generateInterface({
     contractFile,
     provider,
     contractAddress,
+    contractName,
   });
   const typesFile = generateTypesFile(abi, contractName);
-  if (!contractAddress && process.env.NODE_ENV !== 'test') {
-    console.warn('Please provide an address with every contract.');
-  }
   const indexFile = generateIndexFile({
     contractFile: relative(process.cwd(), contractFile),
-    address: contractAddress || '',
+    contractAddress: contractAddress,
+    contractName,
   });
-  const abiFile = generateInterfaceFile({ contractFile, abi });
+  const abiFile = generateInterfaceFile({ contractName, abi });
 
-  const baseDir = outputFolder || resolve(process.cwd(), `tmp/${contractName}`);
-  const outputPath = resolve(baseDir, dirName || '.', contractName);
+  const outputPath = resolve(outputFolder, dirName || '.', contractName);
   await mkdir(outputPath, { recursive: true });
 
   await writeFile(resolve(outputPath, 'abi.ts'), abiFile);
@@ -55,7 +53,7 @@ export const generateFilesForContract = async ({
 };
 
 export const generateProject = async (projectPath: string) => {
-  const configFile = await getConfigFile(projectPath);
+  const configFile = await getProjectConfig(projectPath);
   const { contractsDir, outputDir, contracts } = configFile;
   const outputFolder = resolve(projectPath, outputDir);
   const provider = await createClarityBin();
@@ -69,6 +67,7 @@ export const generateProject = async (projectPath: string) => {
       provider,
       contractAddress: contract.address,
       dirName,
+      contractName: contract.name,
     });
   }
 

package/dist/commands/contract.js

@@ -1,33 +0,0 @@
-"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/src/commands/contract.ts

@@ -1,35 +0,0 @@
-import { Command, flags } from '@oclif/command';
-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' }),
-    output: flags.string({
-      char: 'o',
-      description: 'Output destination folder',
-      default: 'clarion',
-    }),
-  };
-
-  static args = [
-    {
-      name: 'contract',
-      description: 'The file path for your contract',
-    },
-  ];
-
-  async run() {
-    const { argv, flags } = this.parse(Contract);
-
-    const [contractFile] = argv;
-
-    await generateFilesForContract({
-      contractFile,
-      outputFolder: flags.output,
-    });
-  }
-}