genlayer 0.12.4 → 0.13.0

package/esbuild.config.dev.js

@@ -11,8 +11,7 @@ export default {
     banner: {
       js: `const _importMetaUrl = new URL(import.meta.url).pathname;`,
     },
-    external: ["commander", "dockerode", "dotenv", "ethers", "inquirer", "update-check", "ssh2"]
-
+    external: ["commander", "dockerode", "dotenv", "ethers", "inquirer", "update-check", "ssh2", "fs-extra", "esbuild"]
   },
   watch: true,
 };

package/esbuild.config.prod.js

@@ -11,7 +11,7 @@ export default {
     banner: {
       js: `const _importMetaUrl = new URL(import.meta.url).pathname;`,
     },
-    external: ["commander", "dockerode", "dotenv", "ethers", "inquirer", "update-check", "ssh2"]
+    external: ["commander", "dockerode", "dotenv", "ethers", "inquirer", "update-check", "ssh2", "fs-extra", "esbuild"]
   },
   watch: false,
 };

package/eslint.config.js

@@ -24,7 +24,8 @@ export default [
       "eslint.config.js",
       "Config.js",
       "commitLint.config.ts",
-      "scripts/postinstall.js"
+      "scripts/postinstall.js",
+      "templates/**/*"
     ],
     plugins: {
       "@typescript-eslint": tseslint,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.12.4",
+  "version": "0.13.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "type": "module",
@@ -37,6 +37,7 @@
   "devDependencies": {
     "@release-it/conventional-changelog": "^10.0.0",
     "@types/dockerode": "^3.3.31",
+    "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^22.0.0",
     "@types/sinon": "^17.0.3",
@@ -45,7 +46,7 @@
     "@typescript-eslint/parser": "^8.0.0",
     "@vitest/coverage-v8": "^2.1.4",
     "cross-env": "^7.0.3",
-    "esbuild": "^0.25.0",
+    "esbuild": ">=0.25.0",
     "eslint": "^9.0.0",
     "eslint-config-prettier": "^10.0.0",
     "eslint-import-resolver-typescript": "^3.6.1",
@@ -62,7 +63,8 @@
     "dockerode": "^4.0.2",
     "dotenv": "^16.4.5",
     "ethers": "^6.13.4",
-    "genlayer-js": "^0.6.0",
+    "fs-extra": "^11.3.0",
+    "genlayer-js": "^0.9.0",
     "inquirer": "^12.0.0",
     "node-fetch": "^3.0.0",
     "open": "^10.1.0",

package/src/commands/contracts/call.ts

@@ -1,21 +1,14 @@
-import { createClient, createAccount } from "genlayer-js";
 import { simulator } from "genlayer-js/chains";
 import type { GenLayerClient } from "genlayer-js/types";
-import { getPrivateKey } from "../../lib/accounts/getPrivateKey";
+import { BaseAction } from "../../lib/actions/BaseAction";
 
 export interface CallOptions {
   args: any[];
 }
 
-export class CallAction {
-  private genlayerClient: GenLayerClient<typeof simulator>;
-
+export class CallAction extends BaseAction{
   constructor() {
-    this.genlayerClient = createClient({
-      chain: simulator,
-      endpoint: process.env.VITE_JSON_RPC_SERVER_URL,
-      account: createAccount(getPrivateKey() as any),
-    });
+    super();
   }
 
   async call({
@@ -27,61 +20,58 @@ export class CallAction {
     method: string;
     args: any[];
   }): Promise<void> {
-    console.log(`Calling method ${method} on contract at ${contractAddress}...`);
+    const client = await this.getClient();
+    this.startSpinner(`Calling method ${method} on contract at ${contractAddress}...`);
 
-    const contractSchema = await this.genlayerClient.getContractSchema(contractAddress);
+    const contractSchema = await client.getContractSchema(contractAddress);
 
     if(!contractSchema.methods.hasOwnProperty(method)){
-      console.error(`method ${method} not found.`);
-      process.exit(1);
+      this.failSpinner(`method ${method} not found.`);
+      return
     }
 
     const readonly = contractSchema.methods[method as any].readonly;
 
-    try {
-      if (readonly) {
-        await this.executeRead(contractAddress, method, args);
-      } else {
-        await this.executeWrite(contractAddress, method, args);
-      }
-    } catch (error) {
-      console.error("Error calling contract method:", error);
-      throw error;
+    if (readonly) {
+      await this.executeRead(contractAddress, method, args);
+      return
     }
+
+    await this.executeWrite(contractAddress, method, args);
   }
 
   private async executeRead(contractAddress: string, method: string, args: any[]): Promise<void> {
     try {
-      const result = await this.genlayerClient.readContract({
+      const client = await this.getClient();
+      const result = await client.readContract({
         address: contractAddress as any,
         functionName: method,
         args,
       });
-      console.log("Read result:", result);
+      this.succeedSpinner("Read operation successfully executed", result);
     } catch (error) {
-      console.error("Error during read operation:", error);
-      throw error;
+      this.failSpinner("Error during read operation", error);
     }
   }
 
   private async executeWrite(contractAddress: string, method: string, args: any[]): Promise<void> {
     try {
-      const hash = await this.genlayerClient.writeContract({
+      const client = await this.getClient();
+      const hash = await client.writeContract({
         address: contractAddress as any,
         functionName: method,
         args,
         value: 0n,
       });
-      const result = await this.genlayerClient.waitForTransactionReceipt({
+      const result = await client.waitForTransactionReceipt({
         hash,
         retries: 15,
         interval: 2000,
       });
-      console.log("Write transaction hash:", hash);
-      console.log("Result:", result);
+      this.log("Write transaction hash:", hash);
+      this.succeedSpinner("Write operation successfully executed", result);
     } catch (error) {
-      console.error("Error during write operation:", error);
-      throw error;
+      this.failSpinner("Error during write operation", error);
     }
   }
 }

package/src/commands/contracts/deploy.ts

@@ -1,25 +1,22 @@
 import fs from "fs";
-import { createClient, createAccount } from "genlayer-js";
+import path from "path";
 import { simulator } from "genlayer-js/chains";
 import type { GenLayerClient } from "genlayer-js/types";
-import { getPrivateKey } from "../../lib/accounts/getPrivateKey";
+import { BaseAction } from "../../lib/actions/BaseAction";
+import { pathToFileURL } from "url";
+import { TransactionStatus } from "genlayer-js/types";
+import { buildSync } from "esbuild";
 
 export interface DeployOptions {
   contract?: string;
-  // network: string;
   args?: any[];
-  kwargs?: string;
 }
 
-export class DeployAction {
-  private genlayerClient: GenLayerClient<typeof simulator>;
+export class DeployAction extends BaseAction {
+  private readonly deployDir = path.resolve(process.cwd(), "deploy");
 
   constructor() {
-    this.genlayerClient = createClient({
-      chain: simulator,
-      endpoint: process.env.VITE_JSON_RPC_SERVER_URL,
-      account: createAccount(getPrivateKey() as any),
-    });
+    super();
   }
 
   private readContractCode(contractPath: string): string {
@@ -29,44 +26,123 @@ export class DeployAction {
     return fs.readFileSync(contractPath, "utf-8");
   }
 
-  async deploy(options: DeployOptions): Promise<void> {
-
-    const argsUsed = options.args && options.args.length > 0;
-    const kwargsUsed = options.kwargs && options.kwargs.trim() !== "";
+  private async executeTsScript(filePath: string): Promise<void> {
+    const outFile = filePath.replace(/\.ts$/, ".compiled.js");
+    this.startSpinner(`Transpiling TypeScript file: ${filePath}`);
+    try {
+      buildSync({
+        entryPoints: [filePath],
+        outfile: outFile,
+        bundle: false,
+        platform: "node",
+        format: "esm",
+        target: "es2020",
+        sourcemap: false,
+      });
+     await this.executeJsScript(filePath, outFile);
+    } catch (error) {
+      this.failSpinner(`Error executing: ${filePath}`, error);
+    } finally {
+      fs.unlinkSync(outFile);
+    }
+  }
 
-    if (argsUsed && kwargsUsed) {
-      throw new Error("Invalid usage: Please specify either `args` or `kwargs`, but not both.");
+  private async executeJsScript(filePath: string, transpiledFilePath?: string): Promise<void> {
+    this.startSpinner(`Executing file: ${filePath}`);
+    try {
+      const module = await import(pathToFileURL(transpiledFilePath || filePath).href);
+      if (!module.default || typeof module.default !== "function") {
+        this.failSpinner(`No "default" function found in: ${filePath}`);
+        return
+      }
+      const client = await this.getClient();
+      await module.default(client);
+      this.succeedSpinner(`Successfully executed: ${filePath}`);
+    } catch (error) {
+      this.failSpinner(`Error executing: ${filePath}`, error);
     }
+  }
 
-    if (!options.contract) {
-      console.error("No contract specified for deployment.");
+  async deployScripts() {
+    this.startSpinner("Searching for deploy scripts...");
+    if (!fs.existsSync(this.deployDir)) {
+      this.failSpinner("No deploy folder found.");
       return;
     }
+    const files = fs.readdirSync(this.deployDir)
+      .filter(file => file.endsWith(".ts") || file.endsWith(".js"))
+      .sort((a, b) => {
+        const numA = parseInt(a.split("_")[0]);
+        const numB = parseInt(b.split("_")[0]);
 
-    const contractCode = this.readContractCode(options.contract);
+        if (!isNaN(numA) && !isNaN(numB)) return numA - numB;
+        if (!isNaN(numA)) return -1;
+        if (!isNaN(numB)) return 1;
+        return a.localeCompare(b);
+      });
 
-    if (!contractCode) {
-      console.error("Contract code is empty.");
+    if (files.length === 0) {
+      this.failSpinner("No deploy scripts found.");
       return;
     }
 
-    const leaderOnly = false;
-    let deployParams: any = { code: contractCode, args: options.args, leaderOnly };
+    this.setSpinnerText(`Found ${files.length} deploy scripts. Executing...`);
 
-    console.log("Starting contract deployment...");
-    console.log("Deployment Parameters:", deployParams);
+    for (const file of files) {
+      const filePath = path.resolve(this.deployDir, file);
+      this.setSpinnerText(`Executing script: ${filePath}`);
+      try {
+        if (file.endsWith(".ts")) {
+          await this.executeTsScript(filePath);
+        } else {
+          await this.executeJsScript(filePath);
+        }
+      } catch (error) {
+        this.failSpinner(`Error executing script: ${filePath}`, error);
+      }
+    }
+  }
 
+  async deploy(options: DeployOptions): Promise<void> {
     try {
-      const hash = await this.genlayerClient.deployContract(deployParams) as any;
+      const client = await this.getClient();
+      this.startSpinner("Setting up the deployment environment...");
+      await client.initializeConsensusSmartContract();
+
+      if (!options.contract) {
+        this.failSpinner("No contract specified for deployment.");
+        return;
+      }
+      this.setSpinnerText("Reading contract code...");
+      const contractCode = this.readContractCode(options.contract);
+
+      if (!contractCode) {
+        this.failSpinner("Contract code is empty.");
+        return;
+      }
+
+      const leaderOnly = false;
+      const deployParams: any = { code: contractCode, args: options.args, leaderOnly };
+
+      this.setSpinnerText("Starting contract deployment...");
+      this.log("Deployment Parameters:", deployParams);
+
+      const hash = (await client.deployContract(deployParams)) as any;
+      const result = await client.waitForTransactionReceipt({
+        hash,
+        retries: 15,
+        interval: 2000,
+        status: TransactionStatus.ACCEPTED,
+      });
 
-      const result = await this.genlayerClient.waitForTransactionReceipt({hash, retries: 15, interval: 2000})
+      this.log("Deployment Receipt:", result);
 
-      console.log("Contract deployed successfully.");
-      console.log("Transaction Hash:", hash);
-      console.log("Contract Address:", result.data?.contract_address);
+      this.succeedSpinner("Contract deployed successfully.", {
+        "Transaction Hash": hash,
+        "Contract Address": result.data?.contract_address,
+      });
     } catch (error) {
-      console.error("Error deploying contract:", error);
-      throw new Error("Contract deployment failed.");
+      this.failSpinner("Error deploying contract", error);
     }
   }
 }

package/src/commands/contracts/index.ts

@@ -2,6 +2,13 @@ import { Command } from "commander";
 import { DeployAction, DeployOptions } from "./deploy";
 import { CallAction, CallOptions } from "./call";
 
+function parseArg(value: string, previous: any[] = []): any[] {
+  if (value === "true") return [...previous, true];
+  if (value === "false") return [...previous, false];
+  if (!isNaN(Number(value))) return [...previous, Number(value)];
+  return [...previous, value];
+}
+
 export function initializeContractsCommands(program: Command) {
 
   program
@@ -9,16 +16,20 @@ export function initializeContractsCommands(program: Command) {
     .description("Deploy intelligent contracts")
     .option("--contract <contractPath>", "Path to the smart contract to deploy")
     // .option("--network <networkName>", "Specify the network (e.g., testnet)", "localnet")
-    .option("--args <args...>", "Positional arguments for the contract (space-separated, use quotes for multi-word arguments)", [])
+    .option("--args <args...>", "Positional arguments for the contract (space-separated, use quotes for multi-word arguments)", parseArg, [])
     .action(async (options: DeployOptions) => {
       const deployer = new DeployAction();
-      await deployer.deploy(options);
+      if(options.contract){
+        await deployer.deploy(options);
+      }else {
+        await deployer.deployScripts();
+      }
     });
 
   program
     .command("call <contractAddress> <method>")
     .description("Call a contract method")
-    .option("--args <args...>", "Positional arguments for the method (space-separated, use quotes for multi-word arguments)", [])
+    .option("--args <args...>", "Positional arguments for the method (space-separated, use quotes for multi-word arguments)", parseArg, [])
     .action(async (contractAddress: string, method: string, options: CallOptions) => {
       const caller = new CallAction();
       await caller.call({ contractAddress, method, ...options });

package/src/commands/general/init.ts

@@ -94,7 +94,6 @@ export class InitAction extends BaseAction {
       const selectedLlmProviders = llmProvidersAnswer.selectedLlmProviders as AiProviders[];
 
       let defaultOllamaModel = this.getConfig().defaultOllamaModel;
-      AI_PROVIDERS_CONFIG.ollama.hint = `(This will download and run a local instance of ${defaultOllamaModel})`;
       const aiProvidersEnvVars: Record<string, string> = {};
       const configurableAiProviders = selectedLlmProviders.filter(
         (provider: AiProviders) => AI_PROVIDERS_CONFIG[provider].envVar

package/src/commands/keygen/create.ts

@@ -1,5 +1,3 @@
-import { writeFileSync, existsSync } from "fs";
-import { ethers } from "ethers";
 import { BaseAction } from "../../lib/actions/BaseAction";
 
 export interface CreateKeypairOptions {
@@ -7,36 +5,18 @@ export interface CreateKeypairOptions {
   overwrite: boolean;
 }
 
-export class KeypairCreator extends BaseAction{
-
+export class KeypairCreator extends BaseAction {
   constructor() {
-    super()
+    super();
   }
 
   createKeypairAction(options: CreateKeypairOptions) {
     try {
       this.startSpinner(`Creating keypair...`);
-      const outputPath = this.getFilePath(options.output);
-
-      if(existsSync(outputPath) && !options.overwrite) {
-        this.failSpinner(
-          `The file at ${outputPath} already exists. Use the '--overwrite' option to replace it.`
-        );
-        return;
-      }
-
-      const wallet = ethers.Wallet.createRandom();
-      const keypairData = {
-        address: wallet.address,
-        privateKey: wallet.privateKey,
-      };
-
-      writeFileSync(outputPath, JSON.stringify(keypairData, null, 2));
-
-      this.writeConfig('keyPairPath', outputPath);
-      this.succeedSpinner(`Keypair successfully created and saved to: ${outputPath}`);
+      this.keypairManager.createKeypair(options.output, options.overwrite);
+      this.succeedSpinner(`Keypair successfully created and saved to: ${options.output}`);
     } catch (error) {
-      this.failSpinner("Failed to generate keypair:", error);
+      this.failSpinner("Failed to generate keypair", error);
     }
   }
 }

package/src/commands/scaffold/index.ts

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { NewAction } from "./new";
+
+export function initializeScaffoldCommands(program: Command) {
+  program
+    .command("new <projectName>")
+    .description("Create a new GenLayer project using the default template")
+    .option("--path <directory>", "Specify the directory for the new project", ".")
+    .option("--overwrite", "Overwrite existing directory if it exists", false)
+    .action(async (projectName, options) => {
+      const newProjectAction = new NewAction();
+      await newProjectAction.createProject(projectName, options);
+    });
+
+  return program;
+}

package/src/commands/scaffold/new.ts

@@ -0,0 +1,34 @@
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import { BaseAction } from "../../lib/actions/BaseAction";
+
+export class NewAction extends BaseAction {
+  private templatePath: string;
+
+  constructor() {
+    super();
+    const __filename = fileURLToPath(import.meta.url);
+    const basePath = path.resolve(path.dirname(__filename), "..");
+    this.templatePath = path.join(basePath, "templates", "default");
+  }
+
+  async createProject(projectName: string, options: { path: string; overwrite: boolean }) {
+    const targetPath = path.resolve(options.path, projectName);
+
+    if (fs.existsSync(targetPath) && !options.overwrite) {
+      return this.failSpinner(
+        `Project directory "${targetPath}" already exists. Use --overwrite to replace it.`
+      );
+    }
+
+    this.startSpinner(`Creating new GenLayer project: ${projectName}`);
+
+    try {
+      fs.copySync(this.templatePath, targetPath);
+      this.succeedSpinner(`Project "${projectName}" created successfully at ${targetPath}`);
+    } catch (error) {
+      this.failSpinner(`Error creating project "${projectName}"`, error);
+    }
+  }
+}

package/src/index.ts

@@ -8,6 +8,7 @@ import { initializeContractsCommands } from "../src/commands/contracts";
 import { initializeConfigCommands } from "../src/commands/config";
 import {initializeValidatorCommands} from "../src/commands/validators";
 import { initializeUpdateCommands } from "../src/commands/update";
+import { initializeScaffoldCommands } from "../src/commands/scaffold";
 
 export function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
@@ -17,6 +18,7 @@ export function initializeCLI() {
   initializeConfigCommands(program);
   initializeUpdateCommands(program)
   initializeValidatorCommands(program);
+  initializeScaffoldCommands(program);
   program.parse(process.argv);
 }
 

package/src/lib/accounts/KeypairManager.ts

@@ -0,0 +1,43 @@
+import { writeFileSync, existsSync, readFileSync } from "fs";
+import { ethers } from "ethers";
+import path from "path";
+import { ConfigFileManager } from "../config/ConfigFileManager";
+
+export class KeypairManager extends ConfigFileManager {
+  constructor() {
+    super();
+  }
+
+  getPrivateKey(): string | undefined {
+    const keypairPath = this.getConfigByKey("keyPairPath");
+
+    if (!keypairPath || !existsSync(keypairPath)) {
+      return ""
+    }
+
+    const keypairData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+
+    if (!keypairData.privateKey) {
+      return ""
+    }
+
+    return keypairData.privateKey;
+  }
+
+  createKeypair(outputPath = "./keypair.json", overwrite: boolean = false): void {
+    const finalOutputPath = this.getFilePath(outputPath);
+
+    if(existsSync(finalOutputPath) && !overwrite) {
+      throw new Error(`The file at ${finalOutputPath} already exists. Use the '--overwrite' option to replace it.`);
+    }
+
+    const wallet = ethers.Wallet.createRandom();
+    const keypairData = {
+      address: wallet.address,
+      privateKey: wallet.privateKey,
+    };
+
+    writeFileSync(finalOutputPath, JSON.stringify(keypairData, null, 2));
+    this.writeConfig('keyPairPath', finalOutputPath);
+  }
+} 

package/src/lib/actions/BaseAction.ts

@@ -2,14 +2,41 @@ import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
 import ora, { Ora } from "ora";
 import chalk from "chalk";
 import inquirer from "inquirer";
-
+import { KeypairManager } from "../accounts/KeypairManager";
+import { createClient, createAccount } from "genlayer-js";
+import { localnet } from "genlayer-js/chains";
+import type { GenLayerClient } from "genlayer-js/types";
 
 export class BaseAction extends ConfigFileManager {
+  protected keypairManager: KeypairManager;
   private spinner: Ora;
+  private _genlayerClient: GenLayerClient<typeof localnet> | null = null;
 
   constructor() {
     super()
     this.spinner = ora({ text: "", spinner: "dots" });
+    this.keypairManager = new KeypairManager();
+  }
+
+  protected async getClient(): Promise<GenLayerClient<typeof localnet>> {
+    if (!this._genlayerClient) {
+      this._genlayerClient = createClient({
+        chain: localnet,
+        endpoint: process.env.VITE_JSON_RPC_SERVER_URL,
+        account: createAccount(await this.getPrivateKey() as any),
+      });
+    }
+    return this._genlayerClient;
+  }
+
+  protected async getPrivateKey() {
+    const privateKey = this.keypairManager.getPrivateKey();
+    if (privateKey) {
+      return privateKey;
+    }
+    await this.confirmPrompt("Keypair file not found. Would you like to create a new keypair?");
+    this.keypairManager.createKeypair();
+    return this.keypairManager.getPrivateKey();
   }
 
   protected async confirmPrompt(message: string): Promise<void> {
@@ -47,27 +74,27 @@ export class BaseAction extends ConfigFileManager {
 
   protected log(message: string, data?: any): void {
     console.log(chalk.white(`\n${message}`));
-    if (data) console.log(this.formatOutput(data));
+    if (data !== undefined) console.log(this.formatOutput(data));
   }
 
   protected logSuccess(message: string, data?: any): void {
     console.log(chalk.green(`\n✔ ${message}`));
-    if (data) console.log(chalk.green(this.formatOutput(data)));
+    if (data !== undefined) console.log(chalk.green(this.formatOutput(data)));
   }
 
   protected logInfo(message: string, data?: any): void {
     console.log(chalk.blue(`\nℹ ${message}`));
-    if (data) console.log(chalk.blue(this.formatOutput(data)));
+    if (data !== undefined) console.log(chalk.blue(this.formatOutput(data)));
   }
 
   protected logWarning(message: string, data?: any): void {
     console.log(chalk.yellow(`\n⚠ ${message}`));
-    if (data) console.log(chalk.yellow(this.formatOutput(data)));
+    if (data !== undefined) console.log(chalk.yellow(this.formatOutput(data)));
   }
 
   protected logError(message: string, error?: any): void {
     console.error(chalk.red(`\n✖ ${message}`));
-    if (error) console.error(chalk.red(this.formatOutput(error)));
+    if (error !== undefined) console.error(chalk.red(this.formatOutput(error)));
   }
 
   protected startSpinner(message: string) {
@@ -76,7 +103,7 @@ export class BaseAction extends ConfigFileManager {
   }
 
   protected succeedSpinner(message: string, data?: any): void {
-    if (data) this.log('Result:', data);
+    if (data !== undefined) this.log('Result:', data);
     this.spinner.succeed(chalk.green(message));
   }
 

package/src/lib/config/simulator.ts

@@ -1,4 +1,4 @@
-export const localnetCompatibleVersion = "v0.42.0";
+export const localnetCompatibleVersion = "v0.51.0";
 export const DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
 export const CONTAINERS_NAME_PREFIX = "/genlayer-";
 export const IMAGES_NAME_PREFIX = "yeagerai";
@@ -32,7 +32,7 @@ export type AiProvidersConfigType = {
 export const AI_PROVIDERS_CONFIG: AiProvidersConfigType = {
   ollama: {
     name: "Ollama",
-    hint: "(This will download and run a local instance of Llama 3)",
+    hint: "(By default, this will download and run a local instance of Llama 3)",
     cliOptionValue: "ollama",
   },
   openai: {