genlayer 0.12.2-beta.2 → 0.12.2

package/esbuild.config.dev.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", "esbuild"]
+    external: ["commander", "dockerode", "dotenv", "ethers", "inquirer", "update-check", "ssh2"]
 
   },
   watch: true,

package/esbuild.config.prod.js

@@ -6,12 +6,11 @@ export default {
     outfile: "dist/index.js",
     platform: "node",
     target: "es2020",
-    format: "esm",
-    define: { "import.meta.url": "import.meta.url" },
+    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"]
+    external: ["commander", "dockerode", "dotenv", "ethers", "inquirer", "update-check", "ssh2"]
   },
   watch: false,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.12.2-beta.2",
+  "version": "0.12.2",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "type": "module",
@@ -45,7 +45,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",

package/src/commands/contracts/deploy.ts

@@ -1,25 +1,20 @@
 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 extends BaseAction {
+export class DeployAction {
   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,
@@ -34,119 +29,44 @@ export class DeployAction extends BaseAction {
     return fs.readFileSync(contractPath, "utf-8");
   }
 
-  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);
-    }
-  }
+  async deploy(options: DeployOptions): Promise<void> {
 
-  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);
+    const argsUsed = options.args && options.args.length > 0;
+    const kwargsUsed = options.kwargs && options.kwargs.trim() !== "";
+
+    if (argsUsed && kwargsUsed) {
+      throw new Error("Invalid usage: Please specify either `args` or `kwargs`, but not both.");
     }
-  }
 
-  async deployScripts() {
-    this.startSpinner("Searching for deploy scripts...");
-    if (!fs.existsSync(this.deployDir)) {
-      this.failSpinner("No deploy folder found.");
+    if (!options.contract) {
+      console.error("No contract specified for deployment.");
       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]);
 
-        if (!isNaN(numA) && !isNaN(numB)) return numA - numB;
-        if (!isNaN(numA)) return -1;
-        if (!isNaN(numB)) return 1;
-        return a.localeCompare(b);
-      });
+    const contractCode = this.readContractCode(options.contract);
 
-    if (files.length === 0) {
-      this.failSpinner("No deploy scripts found.");
+    if (!contractCode) {
+      console.error("Contract code is empty.");
       return;
     }
 
-    this.setSpinnerText(`Found ${files.length} deploy scripts. Executing...`);
+    const leaderOnly = false;
+    let deployParams: any = { code: contractCode, args: options.args, leaderOnly };
 
-    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);
-      }
-    }
-  }
+    console.log("Starting contract deployment...");
+    console.log("Deployment Parameters:", deployParams);
 
-  async deploy(options: DeployOptions): Promise<void> {
     try {
-      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 hash = await this.genlayerClient.deployContract(deployParams) as any;
 
-      const hash = (await this.genlayerClient.deployContract(deployParams)) as any;
-      const result = await this.genlayerClient.waitForTransactionReceipt({
-        hash,
-        retries: 15,
-        interval: 2000,
-        status: TransactionStatus.ACCEPTED,
-      });
+      const result = await this.genlayerClient.waitForTransactionReceipt({hash, retries: 15, interval: 2000})
 
-      this.succeedSpinner("Contract deployed successfully.", {
-        "Transaction Hash": hash,
-        "Contract Address": result.data?.contract_address,
-      });
+      console.log("Contract deployed successfully.");
+      console.log("Transaction Hash:", hash);
+      console.log("Contract Address:", result.data?.contract_address);
     } catch (error) {
-      this.failSpinner("Error deploying contract", error);
+      console.error("Error deploying contract:", error);
+      throw new Error("Contract deployment failed.");
     }
   }
 }

package/src/commands/contracts/index.ts

@@ -12,11 +12,7 @@ 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();
-      if(options.contract){
-        await deployer.deploy(options);
-      }else {
-        await deployer.deployScripts();
-      }
+      await deployer.deploy(options);
     });
 
   program

package/src/commands/general/init.ts

@@ -94,6 +94,7 @@ 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/lib/config/simulator.ts

@@ -1,4 +1,4 @@
-export const localnetCompatibleVersion = "v0.35.2";
+export const localnetCompatibleVersion = "v0.42.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: "(By default, this will download and run a local instance of Llama 3)",
+    hint: "(This will download and run a local instance of Llama 3)",
     cliOptionValue: "ollama",
   },
   openai: {

package/tests/actions/deploy.test.ts

@@ -3,22 +3,16 @@ import fs from "fs";
 import { createClient, createAccount } from "genlayer-js";
 import { DeployAction, DeployOptions } from "../../src/commands/contracts/deploy";
 import { getPrivateKey } from "../../src/lib/accounts/getPrivateKey";
-import { buildSync } from "esbuild";
-import { pathToFileURL } from "url";
 
 vi.mock("fs");
 vi.mock("genlayer-js");
-vi.mock("esbuild", () => ({
-  buildSync: vi.fn(),
-}));
 vi.mock("../../src/lib/accounts/getPrivateKey");
 
-describe("DeployAction", () => {
+describe("Deploy Action", () => {
   let deployer: DeployAction;
   const mockClient = {
     deployContract: vi.fn(),
-    waitForTransactionReceipt: vi.fn(),
-    initializeConsensusSmartContract: vi.fn(),
+    waitForTransactionReceipt: vi.fn()
   };
 
   const mockPrivateKey = "mocked_private_key";
@@ -29,12 +23,6 @@ describe("DeployAction", () => {
     vi.mocked(createAccount).mockReturnValue({ privateKey: mockPrivateKey } as any);
     vi.mocked(getPrivateKey).mockReturnValue(mockPrivateKey);
     deployer = new DeployAction();
-
-    vi.spyOn(deployer as any, "startSpinner").mockImplementation(() => {});
-    vi.spyOn(deployer as any, "succeedSpinner").mockImplementation(() => {});
-    vi.spyOn(deployer as any, "failSpinner").mockImplementation(() => {});
-    vi.spyOn(deployer as any, "setSpinnerText").mockImplementation(() => {});
-    vi.spyOn(deployer as any, "log").mockImplementation(() => {});
   });
 
   afterEach(() => {
@@ -64,6 +52,7 @@ describe("DeployAction", () => {
     expect(fs.existsSync).toHaveBeenCalledWith(contractPath);
   });
 
+
   test("deploys contract with args", async () => {
     const options: DeployOptions = {
       contract: "/mocked/contract/path",
@@ -74,9 +63,7 @@ describe("DeployAction", () => {
     vi.mocked(fs.existsSync).mockReturnValue(true);
     vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
     vi.mocked(mockClient.deployContract).mockResolvedValue("mocked_tx_hash");
-    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue({
-      data: { contract_address: "0xdasdsadasdasdada" },
-    });
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue({data: {contractAddress: '0xdasdsadasdasdada'}});
 
     await deployer.deploy(options);
 
@@ -86,15 +73,31 @@ describe("DeployAction", () => {
       args: [1, 2, 3],
       leaderOnly: false,
     });
-    expect(mockClient.deployContract).toHaveReturnedWith(Promise.resolve("mocked_tx_hash"));
+    expect(mockClient.deployContract).toHaveResolvedWith("mocked_tx_hash");
+  });
+
+  test("throws error for both args and kwargs", async () => {
+    const options: DeployOptions = {
+      contract: "/mocked/contract/path",
+      args: [1, 2, 3],
+      kwargs: "key1=value1,key2=42",
+    };
+
+    await expect(deployer.deploy(options)).rejects.toThrowError(
+      "Invalid usage: Please specify either `args` or `kwargs`, but not both."
+    );
+
+    expect(fs.readFileSync).not.toHaveBeenCalled();
+    expect(mockClient.deployContract).not.toHaveBeenCalled();
   });
 
   test("throws error for missing contract", async () => {
-    const options: DeployOptions = {};
+    const options: DeployOptions = {
+    };
 
     await deployer.deploy(options);
 
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith("No contract specified for deployment.");
+    expect(fs.readFileSync).not.toHaveBeenCalled();
     expect(mockClient.deployContract).not.toHaveBeenCalled();
   });
 
@@ -111,13 +114,15 @@ describe("DeployAction", () => {
       new Error("Mocked deployment error")
     );
 
-    await deployer.deploy(options);
+    await expect(deployer.deploy(options)).rejects.toThrowError(
+      "Contract deployment failed."
+    );
 
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith("Error deploying contract", expect.any(Error));
+    expect(fs.readFileSync).toHaveBeenCalledWith(options.contract, "utf-8");
     expect(mockClient.deployContract).toHaveBeenCalled();
   });
 
-  test("handles empty contract code", async () => {
+  test("throws error if contract code is empty", async () => {
     const options: DeployOptions = {
       contract: "/mocked/contract/path",
     };
@@ -127,183 +132,8 @@ describe("DeployAction", () => {
 
     await deployer.deploy(options);
 
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith("Contract code is empty.");
+    expect(fs.existsSync).toHaveBeenCalledWith(options.contract);
+    expect(fs.readFileSync).toHaveBeenCalledWith(options.contract, "utf-8");
     expect(mockClient.deployContract).not.toHaveBeenCalled();
   });
-
-  test("deployScripts executes scripts in order", async () => {
-    vi.mocked(fs.existsSync).mockReturnValue(true);
-    vi.mocked(fs.readdirSync).mockReturnValue([
-      "1_first.ts",
-      "2_second.js",
-      "10_last.ts",
-    ] as any);
-
-    vi.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
-    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
-
-    await deployer.deployScripts();
-
-    expect(deployer["setSpinnerText"]).toHaveBeenCalledWith("Found 3 deploy scripts. Executing...");
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringMatching(/1_first.ts/));
-    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(expect.stringMatching(/2_second.js/));
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringMatching(/10_last.ts/));
-  });
-
-  test("executeTsScript transpiles and executes TypeScript", async () => {
-    const filePath = "/mocked/script.ts";
-    const outFile = "/mocked/script.compiled.js";
-
-    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
-    vi.mocked(buildSync).mockImplementation((() => {}) as any);
-
-    await deployer["executeTsScript"](filePath);
-
-    expect(deployer["startSpinner"]).toHaveBeenCalledWith(`Transpiling TypeScript file: ${filePath}`);
-    expect(buildSync).toHaveBeenCalledWith({
-      entryPoints: [filePath],
-      outfile: outFile,
-      bundle: false,
-      platform: "node",
-      format: "esm",
-      target: "es2020",
-      sourcemap: false,
-    });
-
-    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(filePath, outFile);
-    expect(fs.unlinkSync).toHaveBeenCalledWith(outFile);
-  });
-
-  test("deployScripts fails when deploy folder is missing", async () => {
-    vi.mocked(fs.existsSync).mockReturnValue(false);
-
-    await deployer.deployScripts();
-
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith("No deploy folder found.");
-  });
-
-  test("deployScripts sorts and executes scripts correctly", async () => {
-    vi.mocked(fs.existsSync).mockReturnValue(true);
-    vi.mocked(fs.readdirSync).mockReturnValue([
-      "10_last.ts",
-      "2_second.js",
-      "1_first.ts"
-    ] as any);
-
-    vi.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
-    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
-
-    await deployer.deployScripts();
-
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("1_first.ts"));
-    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(expect.stringContaining("2_second.js"));
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("10_last.ts"));
-  });
-
-  test("deployScripts fails when no scripts are found", async () => {
-    vi.mocked(fs.existsSync).mockReturnValue(true);
-    vi.mocked(fs.readdirSync).mockReturnValue([]);
-
-    await deployer.deployScripts();
-
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith("No deploy scripts found.");
-  });
-
-  test("deployScripts handles script execution errors", async () => {
-    vi.mocked(fs.existsSync).mockReturnValue(true);
-    vi.mocked(fs.readdirSync).mockReturnValue(["1_failing.ts"] as any);
-    vi.spyOn(deployer as any, "executeTsScript").mockRejectedValue(new Error("Script error"));
-
-    await deployer.deployScripts();
-
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
-      expect.stringContaining("Error executing script:"),
-      expect.any(Error)
-    );
-  });
-
-  test("executeJsScript fails gracefully", async () => {
-    const filePath = "/mocked/script.js";
-
-    await deployer["executeJsScript"](filePath);
-
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
-      expect.stringContaining("Error executing:"),
-      expect.any(Error)
-    );
-  });
-
-  test("deploy fails when contract code is empty", async () => {
-    const options: DeployOptions = { contract: "/mocked/contract/path" };
-
-    vi.mocked(fs.existsSync).mockReturnValue(true);
-    vi.mocked(fs.readFileSync).mockReturnValue("");
-
-    await deployer.deploy(options);
-
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith("Contract code is empty.");
-  });
-
-  test("deployScripts correctly sorts mixed numbered and non-numbered scripts", async () => {
-    vi.mocked(fs.existsSync).mockReturnValue(true);
-    vi.mocked(fs.readdirSync).mockReturnValue([
-      "script.ts",
-      "2alpha_script.ts",
-      "3alpha_script.ts",
-      "blpha_script.ts",
-      "clpha_script.ts"
-    ] as any);
-
-    vi.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
-    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
-
-    await deployer.deployScripts();
-
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("script.ts"));
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("2alpha_script.ts"));
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("3alpha_script.ts"));
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("blpha_script.ts"));
-    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("clpha_script.ts"));
-  });
-
-  test("executeJsScript fails if module has no default export", async () => {
-    const filePath = "/mocked/script.js";
-
-    vi.doMock(pathToFileURL(filePath).href, () => ({ default: "Not a function" }));
-
-    await deployer["executeJsScript"](filePath);
-
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
-      expect.stringContaining("No \"default\" function found in:"),
-    );
-  });
-
-  test("executeJsScript successfully executes a script", async () => {
-    const filePath = "/mocked/script.js";
-    const mockFn = vi.fn(); // This mock function simulates the script execution
-
-    vi.doMock(pathToFileURL(filePath).href, () => ({ default: mockFn }));
-
-    await deployer["executeJsScript"](filePath);
-
-    expect(mockFn).toHaveBeenCalledWith(deployer["genlayerClient"]);
-
-    expect(deployer["succeedSpinner"]).toHaveBeenCalledWith(`Successfully executed: ${filePath}`);
-  });
-
-  test("executeTsScript fails when buildSync throws an error", async () => {
-    const filePath = "/mocked/script.ts";
-    const error = new Error("Build failed");
-
-    vi.mocked(buildSync).mockImplementation(() => {
-      throw error; // Simulate an error during transpilation
-    });
-
-    await deployer["executeTsScript"](filePath);
-
-    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
-      `Error executing: ${filePath}`,
-      error
-    );
-  });
 });

package/tests/commands/call.test.ts

@@ -4,9 +4,6 @@ import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
 import { initializeContractsCommands } from "../../src/commands/contracts";
 
 vi.mock("../../src/commands/contracts/call");
-vi.mock("esbuild", () => ({
-  buildSync: vi.fn(),
-}));
 
 describe("call command", () => {
   let program: Command;

package/tests/commands/deploy.test.ts

@@ -4,9 +4,6 @@ import { initializeContractsCommands } from "../../src/commands/contracts";
 import { DeployAction } from "../../src/commands/contracts/deploy";
 
 vi.mock("../../src/commands/contracts/deploy");
-vi.mock("esbuild", () => ({
-  buildSync: vi.fn(),
-}));
 
 describe("deploy command", () => {
   let program: Command;
@@ -69,12 +66,4 @@ describe("deploy command", () => {
       program.parse(["node", "test", "deploy", "--contract", "./path/to/contract"])
     ).not.toThrow();
   });
-
-  test("DeployAction.deployScripts is called without throwing errors", async () => {
-    program.parse(["node", "test", "deploy"]);
-    vi.mocked(DeployAction.prototype.deployScripts).mockResolvedValueOnce(undefined);
-    expect(() =>
-      program.parse(["node", "test", "deploy"])
-    ).not.toThrow();
-  });
 });