@clarigen/cli 0.3.3 → 1.0.0-next.10

package/src/clarinet-config.ts

@@ -2,7 +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;
@@ -30,13 +35,17 @@ export async function getClarinetDevConfig(
   return config;
 }
 
-interface ClarinetConfig {
-  contracts: {
-    [name: string]: {
-      path: string;
-      dependsOn: string[];
-    };
-  };
+export interface ClarinetContract {
+  path: string;
+  depends_on: string[];
+}
+
+export interface ClarinetContracts {
+  [name: string]: ClarinetContract;
+}
+
+export interface ClarinetConfig {
+  contracts: ClarinetContracts;
 }
 
 export async function getClarinetConfig(folder: string) {
@@ -57,18 +66,32 @@ export async function getContractsFromClarinet(
 ): Promise<ConfigContract[]> {
   const clarinetConfig = await getClarinetConfig(folder);
   const deployerAddress = accounts.deployer.address;
-  const contracts: ConfigContract[] = Object.entries(
-    clarinetConfig.contracts
-  ).map(([contractName, info]) => {
+  const sortedContracts = sortClarinetContracts(clarinetConfig.contracts);
+  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;
 }
 
+export function sortClarinetContracts(contractsConfig: ClarinetContracts) {
+  const edges: [string, string][] = [];
+  const nodes: string[] = [];
+  Object.entries(contractsConfig).forEach(([contractName, info]) => {
+    nodes.push(contractName);
+    info.depends_on.forEach((dependency) =>
+      edges.push([contractName, dependency])
+    );
+  });
+  const sorted = toposort(nodes, edges).reverse();
+  return sorted;
+}
+
 export interface ClarinetAccount extends ClarinetConfigAccount {
   address: string;
 }
@@ -84,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/clarinet-config.js

@@ -1,57 +0,0 @@
-"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

@@ -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',
-    },
-];