@clarigen/cli 1.0.0-next.21 → 1.0.0-next.25

package/src/config.ts

@@ -3,9 +3,11 @@ import { readFile, access } from 'fs/promises';
 import { constants } from 'fs';
 import {
   ClarinetAccounts,
+  ClarinetConfig,
   getClarinetAccounts,
   getClarinetConfig,
   getContractsFromClarinet,
+  getContractsFromDeployment,
 } from './clarinet-config';
 
 export interface ConfigContract {
@@ -66,7 +68,12 @@ export async function getProjectConfig(rootPath: string): Promise<ConfigFile> {
   const clarinetPath = resolve(rootPath, configFile.clarinet);
   const clarinet = await getClarinetConfig(clarinetPath);
   const accounts = await getClarinetAccounts(clarinetPath);
-  const contracts = getContractsFromClarinet(clarinet, accounts);
+  let contracts: ConfigContract[];
+  try {
+    contracts = await getContractsFromDeployment(clarinetPath);
+  } catch (error) {
+    contracts = getContractsFromClarinet(clarinet, accounts);
+  }
   const contractsDir = relative(
     process.cwd(),
     join(configFile.clarinet, 'contracts')

package/src/contract.ts

@@ -0,0 +1,65 @@
+import { mkdir } from 'fs/promises';
+import { relative, resolve } from 'path';
+import { SessionContract } from './deno-run';
+import { generateMarkdownDoc } from './docs';
+import {
+  generateTypesFile,
+  generateIndexFile,
+  generateInterfaceFile,
+} from './generate/files';
+import { ContractMeta } from './utils';
+import { writeFile } from './writer';
+
+export const generateFilesForContractWithSession = async ({
+  outputFolder,
+  sessionContract,
+  dirName,
+  docsPath,
+  contractFile,
+}: {
+  outputFolder: string;
+  sessionContract: SessionContract;
+  dirName?: string;
+  docsPath?: string;
+  contractFile: string;
+}): Promise<ContractMeta> => {
+  const contractIdentifier = sessionContract.contract_id;
+  const [contractAddress, contractName] = contractIdentifier.split('.');
+
+  const abi = sessionContract.contract_interface;
+  const variables = [];
+
+  const typesFile = generateTypesFile(abi, contractName);
+  const indexFile = generateIndexFile({
+    contractFile: relative(process.cwd(), contractFile),
+    contractAddress: contractAddress,
+    contractName,
+  });
+  const abiFile = generateInterfaceFile({ contractName, abi });
+
+  if (typeof docsPath !== 'undefined') {
+    await generateMarkdownDoc({
+      contractFile,
+      contractName,
+      abi,
+      docsPath,
+      dirName,
+    });
+  }
+
+  const outputPath = resolve(outputFolder, dirName || '.', contractName);
+  await mkdir(outputPath, { recursive: true });
+
+  await writeFile(resolve(outputPath, 'abi.ts'), abiFile);
+  await writeFile(resolve(outputPath, 'index.ts'), indexFile);
+  await writeFile(resolve(outputPath, 'types.ts'), typesFile);
+
+  return {
+    abi,
+    contractFile,
+    contractName,
+    dirName,
+    contractAddress,
+    variables,
+  };
+};

package/src/deno-run.ts

@@ -0,0 +1,35 @@
+import { exec as _exec } from 'child_process';
+import { promisify } from 'util';
+import { homedir } from 'os';
+import { resolve } from 'path';
+import { ClarityAbi } from '@clarigen/core';
+
+const exec = promisify(_exec);
+
+export interface SessionContract {
+  contract_id: string;
+  contract_interface: ClarityAbi;
+  source: string;
+  dependencies: string[];
+}
+
+export interface Session {
+  session_id: number;
+  accounts: any[];
+  contracts: SessionContract[];
+}
+
+export async function getClarinetSession(cwd?: string): Promise<Session> {
+  const scriptPath =
+    'https://raw.githubusercontent.com/mechanismHQ/clarigen-deno/main/src/cli/print.ts';
+  const command = `clarinet run ${scriptPath}`;
+  try {
+    const result = await exec(command, { cwd });
+    const sessionJSON = result.stdout.split('\n')[1];
+    const session = JSON.parse(sessionJSON);
+    return session as Session;
+  } catch (error) {
+    console.error(`Error getting clarinet session`);
+    throw error;
+  }
+}

package/src/generate/deployment.ts

@@ -0,0 +1,45 @@
+import { load } from 'js-yaml';
+import { mkdir, readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import type { ConfigFile } from '../config';
+import { writeFile } from '../writer';
+import { DeploymentPlan } from '@clarigen/core';
+
+export async function parseDeployment(path: string): Promise<DeploymentPlan> {
+  const contents = await readFile(path, { encoding: 'utf-8' });
+  const parsed = load(contents);
+  return parsed as DeploymentPlan;
+}
+
+export async function generateDeployment(network: string, config: ConfigFile) {
+  const file = `default.${network}-plan.yaml`;
+  const deploymentPath = resolve(
+    process.cwd(),
+    config.clarinet,
+    'deployments',
+    file
+  );
+  if (existsSync(deploymentPath)) {
+    const plan = await parseDeployment(deploymentPath);
+    const varName = `${network}Deployment`;
+    const contents = `export const ${varName} = ${JSON.stringify(
+      plan
+    )} as const;
+    `;
+    const outputFile = resolve(
+      config.outputDir,
+      'deployments',
+      `${network}.ts`
+    );
+    await writeFile(outputFile, contents);
+  }
+}
+
+export async function generateDeployments(config: ConfigFile) {
+  const networks = ['devnet', 'simnet', 'testnet', 'mainnet'];
+  const folder = resolve(process.cwd(), config.outputDir, 'deployments');
+  await mkdir(folder, { recursive: true });
+  const generates = networks.map((n) => generateDeployment(n, config));
+  await Promise.all(generates);
+}

package/src/generate/files.ts

@@ -107,7 +107,7 @@ export const accounts = {
     const contractInfo = `${contractVar}Info`;
     const contractInterface = `${toCamelCase(contractName, true)}Contract`;
     const dirName = dirname(contract.file);
-    const importPath = `'./${join(dirName || '.', contractName)}'`;
+    const importPath = `'./${contractName}'`;
 
     const _import = `import { ${contractInfo} } from ${importPath};`;
     imports.push(_import);

package/src/utils.ts

@@ -18,6 +18,9 @@ import { generateContractMeta, generateSingleFile } from './generate/single';
 import { writeFile } from './writer';
 import { getVariables, TypedAbiVariable } from './generate/vars';
 import { ClarityAbiVariable } from 'micro-stacks/clarity';
+import { generateDeployments } from './generate/deployment';
+import { getClarinetSession } from './deno-run';
+import { generateFilesForContractWithSession } from './contract';
 
 export interface ContractMeta {
   abi: ClarityAbi;
@@ -100,18 +103,27 @@ export const generateProject = async (projectPath: string) => {
   const outputFolder = resolve(projectPath, outputDir);
   const provider = await createClarityBin();
   const metas: ContractMeta[] = [];
+  const session = await getClarinetSession(
+    resolve(projectPath, configFile.clarinet)
+  );
   // this needs to be serial
-  for (const contract of contracts) {
-    const contractFile = resolve(projectPath, contractsDir, contract.file);
-    const dirName = dirname(contract.file);
-    const meta = await generateFilesForContract({
-      contractFile,
-      outputFolder: outputFolder,
-      provider,
-      contractAddress: contract.address,
-      dirName,
-      contractName: contract.name,
+  for (const contract of session.contracts) {
+    const configContract = contracts.find(
+      (c) => c.name === contract.contract_id.split('.')[1]
+    );
+    if (typeof configContract === 'undefined') {
+      throw new Error(`No config contract found for ${contract.contract_id}`);
+    }
+    const contractFile = resolve(
+      projectPath,
+      configFile.clarinet,
+      configContract.file
+    );
+    const meta = await generateFilesForContractWithSession({
+      sessionContract: contract,
+      outputFolder,
       docsPath: configFile.docs,
+      contractFile,
     });
     metas.push(meta);
   }
@@ -125,4 +137,5 @@ export const generateProject = async (projectPath: string) => {
   const singleFile = await generateSingleFile(configFile, metas);
   const singlePath = resolve(outputFolder, 'single.ts');
   await writeFile(singlePath, singleFile);
+  await generateDeployments(configFile);
 };