genlayer 0.12.1 → 0.12.2-beta.0

package/docker-compose.yml

@@ -93,7 +93,7 @@ services:
         max-file: "3"
 
   ollama:
-    image: ollama/ollama:0.5.7
+    image: ollama/ollama:0.5.11
     ports:
       - 11434:11434
     container_name: ollama

package/esbuild.config.dev.js

@@ -0,0 +1,18 @@
+export default {
+  context: {
+    tsconfig: "./tsconfig.json",
+    entryPoints: ["src/index.ts"],
+    bundle: true,
+    outfile: "dist/index.js",
+    platform: "node",
+    target: "es2020",
+    format: "esm",
+    define: { "import.meta.url": "import.meta.url" },
+    banner: {
+      js: `const _importMetaUrl = new URL(import.meta.url).pathname;`,
+    },
+    external: ["commander", "dockerode", "dotenv", "ethers", "inquirer", "update-check", "ssh2", "esbuild"]
+
+  },
+  watch: true,
+};

package/esbuild.config.js

@@ -1,13 +1,18 @@
-const esbuild = require("esbuild");
+/* eslint-disable no-undef -- Allow process and console in ignored file */
+
+import esbuild from "esbuild";
+
 const isProduction = process.env.NODE_ENV === "production";
-const config = require(isProduction ? "./esbuild.config.prod" : "./esbuild.config.dev");
+const config = isProduction
+  ? await import("./esbuild.config.prod.js")
+  : await import("./esbuild.config.dev.js");
 
 const run = async () => {
-  if (config.watch) {
-    const context = await esbuild.context(config.context);
+  if (config.default.watch) {
+    const context = await esbuild.context(config.default.context);
     await context.watch();
   } else {
-    await esbuild.build(config.context);
+    await esbuild.build(config.default.context);
   }
 };
 

package/esbuild.config.prod.js

@@ -0,0 +1,16 @@
+export default {
+  context: {
+    tsconfig: "./tsconfig.json",
+    entryPoints: ["src/index.ts"],
+    bundle: true,
+    outfile: "dist/index.js",
+    platform: "node",
+    target: "es2020",
+    define: { "import.meta.url": "_importMetaUrl" },
+    banner: {
+      js: `const _importMetaUrl = new URL(import.meta.url).pathname;`,
+    },
+    external: ["commander", "dockerode", "dotenv", "ethers", "inquirer", "update-check", "ssh2", "esbuild"]
+  },
+  watch: false,
+};

package/eslint.config.js

@@ -0,0 +1,59 @@
+import js from "@eslint/js";
+import tseslint from "@typescript-eslint/eslint-plugin";
+import tsparser from "@typescript-eslint/parser";
+import prettier from "eslint-config-prettier";
+import importPlugin from "eslint-plugin-import";
+
+export default [
+  js.configs.recommended,
+  prettier,
+  {
+    languageOptions: {
+      parser: tsparser,
+      parserOptions: {
+        project: ["./tsconfig.json"],
+        sourceType: "module",
+      },
+    },
+    ignores: [
+      "**/dist/**/*",
+      "esbuild.config.js",
+      "esbuild.config.dev.js",
+      "esbuild.config.prod.js",
+      "jest.config.js",
+      "eslint.config.js",
+      "Config.js",
+      "commitLint.config.ts",
+      "scripts/postinstall.js"
+    ],
+    plugins: {
+      "@typescript-eslint": tseslint,
+      import: importPlugin,
+    },
+    rules: {
+      "import/namespace": "off",
+      "@typescript-eslint/no-empty-function": "off",
+      "@typescript-eslint/no-empty-interface": "off",
+      "no-constant-condition": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "prefer-const": "off",
+      "@typescript-eslint/no-non-null-assertion": "off",
+      "@typescript-eslint/ban-ts-ignore": "off",
+      "@typescript-eslint/no-loss-of-precision": "off",
+      "@typescript-eslint/ban-types": "off",
+      "@typescript-eslint/ban-ts-comment": "off",
+      "@typescript-eslint/no-non-null-asserted-optional-chain": "off",
+      "@typescript-eslint/no-var-requires": "off",
+      "import/export": "off",
+      "no-fallthrough": "off",
+      "@typescript-eslint/explicit-module-boundary-types": "off",
+      "@typescript-eslint/no-floating-promises": ["error"],
+      "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+    },
+    settings: {
+      "import/resolver": {
+        typescript: {},
+      },
+    },
+  },
+];

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "genlayer",
-  "version": "0.12.1",
+  "version": "0.12.2-beta.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
+  "type": "module",
   "bin": {
     "genlayer": "./dist/index.js"
   },
@@ -34,7 +35,7 @@
   },
   "homepage": "https://github.com/yeagerai/genlayer-cli#readme",
   "devDependencies": {
-    "@release-it/conventional-changelog": "^8.0.1",
+    "@release-it/conventional-changelog": "^10.0.0",
     "@types/dockerode": "^3.3.31",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^22.0.0",
@@ -44,26 +45,28 @@
     "@typescript-eslint/parser": "^8.0.0",
     "@vitest/coverage-v8": "^2.1.4",
     "cross-env": "^7.0.3",
-    "esbuild": "^0.24.0",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
+    "esbuild": ">=0.25.0",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^10.0.0",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.29.1",
-    "jsdom": "^25.0.1",
+    "jsdom": "^26.0.0",
     "prettier": "^3.2.5",
-    "release-it": "^17.2.0",
+    "release-it": "^18.0.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.4.5"
   },
   "dependencies": {
-    "commander": "^12.0.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
     "dockerode": "^4.0.2",
     "dotenv": "^16.4.5",
     "ethers": "^6.13.4",
     "genlayer-js": "^0.6.0",
-    "inquirer": "^9.3.7",
+    "inquirer": "^12.0.0",
     "node-fetch": "^3.0.0",
     "open": "^10.1.0",
+    "ora": "^8.2.0",
     "update-check": "^1.5.4",
     "uuid": "^11.0.0",
     "viem": "^2.21.54",

package/scripts/postinstall.js

@@ -1,16 +1,20 @@
 #!/usr/bin/env node
+/* eslint-disable no-undef -- Allow process and console in ignored file */
 
-const fs = require('fs');
-const path = require('path');
+import { existsSync, copyFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
 
-const envExamplePath = path.resolve(__dirname, '../.env.example');
-const envPath = path.resolve(__dirname, '../.env');
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const envExamplePath = resolve(__dirname, '../.env.example');
+const envPath = resolve(__dirname, '../.env');
 
 try {
-  if (fs.existsSync(envPath)) {
+  if (existsSync(envPath)) {
     console.log(`⚠️  .env file already exists. Skipping creation.`);
   } else {
-    fs.copyFileSync(envExamplePath, envPath);
+    copyFileSync(envExamplePath, envPath);
     console.log(`✅  .env file created successfully from .env.example.`);
   }
 } catch (error) {

package/src/commands/config/getSetReset.ts

@@ -1,44 +1,51 @@
-import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
+import { BaseAction } from "../../lib/actions/BaseAction";
 
-export class ConfigActions {
-  private configManager: ConfigFileManager;
+export class ConfigActions extends BaseAction {
 
   constructor() {
-    this.configManager = new ConfigFileManager();
+    super();
   }
 
   set(keyValue: string): void {
     const [key, value] = keyValue.split("=");
+    this.startSpinner(`Updating configuration: ${key}`);
+
     if (!key || value === undefined) {
-      console.error("Invalid format. Use key=value.");
-      process.exit(1);
+      this.failSpinner("Invalid format. Use 'key=value'.");
+      return;
     }
-    this.configManager.writeConfig(key, value);
-    console.log(`Configuration updated: ${key}=${value}`);
+
+    this.writeConfig(key, value);
+    this.succeedSpinner(`Configuration successfully updated`);
   }
 
   get(key?: string): void {
+    this.startSpinner(key ? `Retrieving value for: ${key}` : "Retrieving all configurations");
+
     if (key) {
-      const value = this.configManager.getConfigByKey(key);
+      const value = this.getConfigByKey(key);
       if (value === null) {
-        console.log(`No value set for key: ${key}`);
+        this.failSpinner(`No configuration found for '${key}'.`);
       } else {
-        console.log(`${key}=${value}`);
+        this.succeedSpinner(`Configuration successfully retrieved`, `${key}=${value}`);
       }
     } else {
-      const config = this.configManager.getConfig();
-      console.log("Current configuration:", JSON.stringify(config, null, 2));
+      const config = this.getConfig();
+      this.succeedSpinner("All configurations successfully retrieved", JSON.stringify(config, null, 2));
     }
   }
 
   reset(key: string): void {
-    const config = this.configManager.getConfig();
-    if (config[key] === undefined) {
-      console.log(`Key does not exist in the configuration: ${key}`);
+    this.startSpinner(`Resetting configuration: ${key}`);
+
+    const config = this.getConfig();
+    if (!(key in config)) {
+      this.failSpinner(`Configuration key '${key}' does not exist.`);
       return;
     }
+
     delete config[key];
-    this.configManager.writeConfig(key, undefined);
-    console.log(`Configuration key reset: ${key}`);
+    this.writeConfig(key, undefined);
+    this.succeedSpinner(`Configuration successfully reset`);
   }
 }

package/src/commands/contracts/deploy.ts

@@ -1,20 +1,25 @@
 import fs from "fs";
+import path from "path";
 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";
+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 {
+export class DeployAction extends BaseAction {
   private genlayerClient: GenLayerClient<typeof simulator>;
+  private readonly deployDir = path.resolve(process.cwd(), "deploy");
 
   constructor() {
+    super();
     this.genlayerClient = createClient({
       chain: simulator,
       endpoint: process.env.VITE_JSON_RPC_SERVER_URL,
@@ -29,44 +34,119 @@ 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
+      }
+      await module.default(this.genlayerClient);
+      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;
+      this.startSpinner("Setting up the deployment environment...");
+      await this.genlayerClient.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 result = await this.genlayerClient.waitForTransactionReceipt({hash, retries: 15, interval: 2000})
+      const hash = (await this.genlayerClient.deployContract(deployParams)) as any;
+      const result = await this.genlayerClient.waitForTransactionReceipt({
+        hash,
+        retries: 15,
+        interval: 2000,
+        status: TransactionStatus.ACCEPTED,
+      });
 
-      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

@@ -12,7 +12,11 @@ export function initializeContractsCommands(program: Command) {
     .option("--args <args...>", "Positional arguments for the contract (space-separated, use quotes for multi-word arguments)", [])
     .action(async (options: DeployOptions) => {
       const deployer = new DeployAction();
-      await deployer.deploy(options);
+      if(options.contract){
+        await deployer.deploy(options);
+      }else {
+        await deployer.deployScripts();
+      }
     });
 
   program

package/src/commands/general/index.ts

@@ -1,8 +1,8 @@
 import { Command } from "commander";
 
 import simulatorService from "../../lib/services/simulator";
-import { initAction, InitActionOptions } from "./init";
-import { startAction, StartActionOptions } from "./start";
+import { InitAction, InitActionOptions } from "./init";
+import { StartAction, StartActionOptions } from "./start";
 import {localnetCompatibleVersion} from "../../lib/config/simulator";
 import {StopAction} from "./stop";
 
@@ -14,7 +14,10 @@ export function initializeGeneralCommands(program: Command) {
     .option("--headless", "Headless mode", false)
     .option("--reset-db", "Reset Database", false)
     .option("--localnet-version <localnetVersion>", "Select a specific localnet version", localnetCompatibleVersion)
-    .action((options: InitActionOptions) => initAction(options, simulatorService));
+    .action(async (options: InitActionOptions) => {
+      const initAction = new InitAction();
+      await initAction.execute(options)
+    });
 
   program
     .command("up")
@@ -23,7 +26,10 @@ export function initializeGeneralCommands(program: Command) {
     .option("--numValidators <numValidators>", "Number of validators", "5")
     .option("--headless", "Headless mode", false)
     .option("--reset-db", "Reset Database", false)
-    .action((options: StartActionOptions) => startAction(options, simulatorService));
+    .action(async (options: StartActionOptions) => {
+      const startAction = new StartAction();
+      await startAction.execute(options);
+    });
 
   program
     .command("stop")