@clarigen/cli 1.0.0-next.9 → 2.0.1

package/dist/generate/files.js

@@ -1,147 +0,0 @@
-"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 path_1 = require("path");
-const __1 = require("..");
-const generateInterface = async ({ provider, contractFile, contractAddress, contractName, }) => {
-    const receipt = await provider.runCommand([
-        'launch',
-        `${contractAddress}.${contractName}`,
-        contractFile,
-        provider.dbFilePath,
-        '--output_analysis',
-        '--costs',
-        '--assets',
-    ]);
-    if ((0, native_bin_1.hasStdErr)(receipt.stderr)) {
-        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 = ({ 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
-export const ${variableName}Interface: ClarityAbi = ${abiString};
-`;
-    return fileContents;
-};
-exports.generateInterfaceFile = generateInterfaceFile;
-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 interfaceVar = `${contractTitle}Interface`;
-    const fileContents = `import { pureProxy, Contract } from '@clarigen/core';
-import type { ${contractType} } from './types';
-import { ${interfaceVar} } from './abi';
-export type { ${contractType} } from './types';
-
-export function ${varName}Contract(contractAddress: string, contractName: string) {
-  return pureProxy<${contractType}>({
-    abi: ${interfaceVar},
-    contractAddress,
-    contractName,
-  });
-}
-
-export const ${varName}Info: Contract<${contractType}> = {
-  contract: ${varName}Contract,
-  address: '${contractAddress}',
-  contractFile: '${contractFile}',
-  name: '${contractName}',
-  abi: ${interfaceVar},
-};
-`;
-    return fileContents;
-};
-exports.generateIndexFile = generateIndexFile;
-const generateTypesFile = (abi, contractName) => {
-    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 {
-${typings}
-}
-`;
-    return fileContents;
-};
-exports.generateTypesFile = generateTypesFile;
-const generateProjectIndexFile = (config) => {
-    const imports = [
-        "import type { ContractInstances } from '@clarigen/core';",
-    ];
-    const exports = [];
-    const contractMap = [];
-    let accounts = '';
-    if ('accounts' in config) {
-        const accountLines = Object.keys(config.accounts).map((key) => {
-            const account = config.accounts[key];
-            return `"${key}": {
-    mnemonic: "${account.mnemonic}",
-    balance: ${account.balance.toString()}n,
-    address: "${account.address}",
-  },`;
-        });
-        accounts = `\n\n// prettier-ignore
-export const accounts = {
-  ${accountLines.join('\n  ')}
-};`;
-    }
-    config.contracts.forEach((contract) => {
-        const contractName = contract.name;
-        const contractVar = (0, core_1.toCamelCase)(contractName);
-        const contractInfo = `${contractVar}Info`;
-        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};`;
-        exports.push(_export);
-        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}
-`;
-    return file;
-};
-exports.generateProjectIndexFile = generateProjectIndexFile;

package/dist/start.js

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

package/dist/utils.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateProject = exports.generateFilesForContract = void 0;
-const files_1 = require("./generate/files");
-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, contractName, }) => {
-    const contractFile = (0, path_1.resolve)(process.cwd(), _contractFile);
-    const abi = await (0, files_1.generateInterface)({
-        contractFile,
-        provider,
-        contractAddress,
-        contractName,
-    });
-    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 = (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 (0, config_1.getProjectConfig)(projectPath);
-    const { contractsDir, outputDir, contracts } = configFile;
-    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 = (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 = (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/src/clarinet-config.ts

@@ -1,127 +0,0 @@
-import { parse } from '@ltd/j-toml';
-import { resolve } from 'path';
-import { readFile } from 'fs/promises';
-import { ConfigContract } from './config';
-import {
-  generateWallet,
-  getStxAddressFromAccount,
-} from 'micro-stacks/wallet-sdk';
-import { array as toposort } from 'toposort';
-import { StacksNetworkVersion } from 'micro-stacks/crypto';
-
-interface ClarinetConfigAccount {
-  mnemonic: string;
-  balance: bigint;
-}
-
-interface ClarinetDevConfig {
-  network: {
-    name: string;
-  };
-  accounts: {
-    deployer: ClarinetConfigAccount;
-    [key: string]: ClarinetConfigAccount;
-  };
-}
-
-export async function getClarinetDevConfig(
-  folder: string
-): Promise<ClarinetDevConfig> {
-  const baseConfigPath = resolve(folder, 'settings', 'Devnet.toml');
-  const configContents = await readFile(baseConfigPath, { encoding: 'utf-8' });
-  const config = (parse(configContents, 1.0, '\n', true, {
-    longer: true,
-  }) as unknown) as ClarinetDevConfig;
-  return config;
-}
-
-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) {
-  const baseConfigPath = resolve(folder, 'Clarinet.toml');
-  const configContents = await readFile(baseConfigPath, { encoding: 'utf-8' });
-  const config = (parse(
-    configContents,
-    1.0,
-    '\n',
-    true
-  ) as unknown) as ClarinetConfig;
-  return config;
-}
-
-export async function getContractsFromClarinet(
-  folder: string,
-  accounts: ClarinetAccounts
-): Promise<ConfigContract[]> {
-  const clarinetConfig = await getClarinetConfig(folder);
-  const deployerAddress = accounts.deployer.address;
-  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;
-}
-
-export interface ClarinetAccounts {
-  deployer: ClarinetAccount;
-  [name: string]: ClarinetAccount;
-}
-
-export async function getClarinetAccounts(
-  folder: string
-): Promise<ClarinetAccounts> {
-  const devConfig = await getClarinetDevConfig(folder);
-  const accountEntries = await Promise.all(
-    Object.entries(devConfig.accounts).map(async ([key, info]) => {
-      const wallet = await generateWallet(info.mnemonic, 'password');
-      const [account] = wallet.accounts;
-      const address = getStxAddressFromAccount(
-        account,
-        StacksNetworkVersion.testnetP2PKH
-      );
-      return [
-        key,
-        {
-          ...info,
-          address,
-        },
-      ];
-    })
-  );
-  const accounts: ClarinetAccounts = Object.fromEntries(accountEntries);
-  return accounts;
-}

package/src/commands/index.ts

@@ -1,67 +0,0 @@
-import { Command, flags } from '@oclif/command';
-import { generateProject } from '../utils';
-import { getProjectConfig } 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 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 getProjectConfig(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/config.ts

@@ -1,78 +0,0 @@
-import { resolve, join, relative } from 'path';
-import { readFile, access } from 'fs/promises';
-import { constants } from 'fs';
-import {
-  ClarinetAccounts,
-  getClarinetAccounts,
-  getContractsFromClarinet,
-} from './clarinet-config';
-
-export interface ConfigContract {
-  address: string;
-  file: string;
-  name: string;
-}
-
-export interface ConfigFileContents {
-  outputDir: string;
-  clarinet: string;
-}
-
-export interface ConfigFile extends ConfigFileContents {
-  contractsDir: string;
-  contracts: ConfigContract[];
-  accounts: ClarinetAccounts;
-  clarinet: string;
-}
-
-export const defaultConfigFile: ConfigFileContents = {
-  outputDir: 'src/clarigen',
-  clarinet: '.',
-};
-
-export function configFilePath(rootPath: string) {
-  return resolve(rootPath, 'clarigen.config.json');
-}
-
-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,
-    };
-  }
-  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,116 +0,0 @@
-import {
-  isClarityAbiBuffer,
-  isClarityAbiList,
-  isClarityAbiOptional,
-  isClarityAbiPrimitive,
-  isClarityAbiResponse,
-  isClarityAbiStringAscii,
-  isClarityAbiStringUtf8,
-  isClarityAbiTuple,
-} from 'micro-stacks/transactions';
-import { ClarityAbiFunction, ClarityAbiType } from 'micro-stacks/clarity';
-import { toCamelCase, ClarityAbi } from '@clarigen/core';
-import { check } from 'reserved-words';
-
-export const jsTypeFromAbiType = (
-  val: ClarityAbiType,
-  isArgument = false
-): string => {
-  if (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 (isClarityAbiBuffer(val)) {
-    return 'Uint8Array';
-  } else if (isClarityAbiResponse(val)) {
-    const ok: any = jsTypeFromAbiType(val.response.ok);
-    const err: any = jsTypeFromAbiType(val.response.error);
-    return `ClarityTypes.Response<${ok}, ${err}>`;
-  } else if (isClarityAbiOptional(val)) {
-    const innerType = jsTypeFromAbiType(val.optional);
-    return `${innerType} | null`;
-  } else if (isClarityAbiTuple(val)) {
-    const tupleDefs: string[] = [];
-    val.tuple.forEach(({ name, type }) => {
-      const innerType = jsTypeFromAbiType(type);
-      tupleDefs.push(`"${name}": ${innerType}`);
-    });
-    return `{
-  ${tupleDefs.join(';\n  ')}
-    }`;
-  } else if (isClarityAbiList(val)) {
-    const innerType: any = jsTypeFromAbiType(val.list.type);
-    return `${innerType}[]`;
-  } else if (isClarityAbiStringAscii(val)) {
-    return 'string';
-  } else if (isClarityAbiStringUtf8(val)) {
-    return 'string';
-  } else if (val === 'trait_reference') {
-    return 'string';
-  } else {
-    throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);
-  }
-};
-
-// 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) => {
-    let functionLine = `${toCamelCase(func.name)}: `;
-    const args = func.args.map((arg) => {
-      return `${getArgName(arg.name)}: ${jsTypeFromAbiType(arg.type, true)}`;
-    });
-    functionLine += `(${args.join(', ')}) => `;
-    const funcType = accessToReturnType[func.access];
-    functionLine += `ContractCalls.${funcType}<`;
-    if (func.access === 'public') {
-      const { type } = func.outputs;
-      if (!isClarityAbiResponse(type))
-        throw new Error('Expected response type for public function');
-      const ok = jsTypeFromAbiType(type.response.ok);
-      const err = jsTypeFromAbiType(type.response.error);
-      functionLine += `${ok}, ${err}>;`;
-    } else {
-      const returnType = jsTypeFromAbiType(func.outputs.type);
-      functionLine += `${returnType}>;`;
-    }
-    typings += `${index === 0 ? '' : '\n'}  ${functionLine}`;
-  });
-  abi.maps.forEach((map) => {
-    let functionLine = `${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;
-}