genlayer 0.8.0 → 0.9.0

package/docker-compose.yml

@@ -142,3 +142,10 @@ services:
         condition: service_healthy
       webrequest:
         condition: service_healthy
+
+  hardhat:
+    image: yeagerai/simulator-hardhat
+    ports:
+      - "${HARDHAT_PORT:-8545}:8545"
+    environment:
+      - HARDHAT_NETWORK=hardhat

package/esbuild.config.dev

@@ -5,7 +5,7 @@ module.exports = {
     bundle: true, // Bundle all dependencies
     outfile: "dist/index.js", // Output file
     platform: "node",
-    target: "es6",
+    target: "es2020",
     define: { 'import.meta.url': '_importMetaUrl' },
     banner: {
       js: "const _importMetaUrl=require('url').pathToFileURL(__filename)",

package/esbuild.config.prod

@@ -5,7 +5,7 @@ module.exports = {
     bundle: true, // Bundle all dependencies
     outfile: "dist/index.js", // Output file
     platform: "node",
-    target: "es6",
+    target: "es2020",
     define: { 'import.meta.url': '_importMetaUrl' },
     banner: {
       js: "const _importMetaUrl=require('url').pathToFileURL(__filename)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {
@@ -60,11 +60,13 @@
     "dockerode": "^4.0.2",
     "dotenv": "^16.4.5",
     "ethers": "^6.13.4",
+    "genlayer-js": "^0.4.7",
     "inquirer": "^9.2.19",
     "node-fetch": "^2.7.0",
     "open": "^10.1.0",
     "update-check": "^1.5.4",
     "uuid": "^9.0.1",
+    "viem": "^2.21.54",
     "vitest": "^2.1.4"
   }
 }

package/src/commands/contracts/deploy.ts

@@ -0,0 +1,69 @@
+import fs from "fs";
+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";
+
+export interface DeployOptions {
+  contract?: string;
+  // network: string;
+  args?: any[];
+  kwargs?: string;
+}
+
+export class DeployAction {
+  private genlayerClient: GenLayerClient<typeof simulator>;
+
+  constructor() {
+    this.genlayerClient = createClient({
+      chain: simulator,
+      endpoint: process.env.VITE_JSON_RPC_SERVER_URL,
+      account: createAccount(getPrivateKey() as any),
+    });
+  }
+
+  private readContractCode(contractPath: string): string {
+    if (!fs.existsSync(contractPath)) {
+      throw new Error(`Contract file not found: ${contractPath}`);
+    }
+    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() !== "";
+
+    if (argsUsed && kwargsUsed) {
+      throw new Error("Invalid usage: Please specify either `args` or `kwargs`, but not both.");
+    }
+
+    if (!options.contract) {
+      console.error("No contract specified for deployment.");
+      return;
+    }
+
+    const contractCode = this.readContractCode(options.contract);
+
+    if (!contractCode) {
+      console.error("Contract code is empty.");
+      return;
+    }
+
+    const leaderOnly = false;
+    let deployParams: any = { code: contractCode, args: options.args, leaderOnly };
+
+    console.log("Starting contract deployment...");
+    console.log("Deployment Parameters:", deployParams);
+
+    try {
+      const result = await this.genlayerClient.deployContract(deployParams);
+
+      console.log("Contract deployed successfully.");
+      console.log("Transaction Hash:", result);
+    } catch (error) {
+      console.error("Error deploying contract:", error);
+      throw new Error("Contract deployment failed.");
+    }
+  }
+}

package/src/commands/contracts/index.ts

@@ -0,0 +1,18 @@
+import { Command } from "commander";
+import { DeployAction, DeployOptions } from "../contracts/deploy";
+
+export function initializeContractsCommands(program: Command) {
+
+  program
+    .command("deploy")
+    .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)", [])
+    .action(async (options: DeployOptions) => {
+      const deployer = new DeployAction();
+      await deployer.deploy(options);
+    });
+
+  return program;
+}

package/src/commands/general/index.ts

@@ -1,5 +1,4 @@
 import { Command } from "commander";
-
 import simulatorService from "../../lib/services/simulator";
 import { initAction, InitActionOptions } from "./init";
 import { startAction, StartActionOptions } from "./start";
@@ -11,7 +10,7 @@ export function initializeGeneralCommands(program: Command) {
     .option("--numValidators <numValidators>", "Number of validators", "5")
     .option("--headless", "Headless mode", false)
     .option("--reset-db", "Reset Database", false)
-    .option("--localnet-version <localnetVersion>", "Select a specific localnet version", 'latest')
+    .option("--localnet-version <localnetVersion>", "Select a specific localnet version", "latest")
     .action((options: InitActionOptions) => initAction(options, simulatorService));
 
   program

package/src/index.ts

@@ -4,12 +4,14 @@ import {version} from "../package.json";
 import {CLI_DESCRIPTION} from "../src/lib/config/text";
 import { initializeGeneralCommands } from "../src/commands/general";
 import { initializeKeygenCommands } from "../src/commands/keygen";
+import { initializeContractsCommands } from "../src/commands/contracts";
 import { initializeConfigCommands } from "../src/commands/config";
 
 export function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
   initializeGeneralCommands(program);
   initializeKeygenCommands(program);
+  initializeContractsCommands(program);
   initializeConfigCommands(program);
   program.parse(process.argv);
 }

package/src/lib/accounts/getPrivateKey.ts

@@ -0,0 +1,21 @@
+import fs from "fs";
+import { ConfigFileManager } from "../config/ConfigFileManager";
+
+export function getPrivateKey(): string {
+  const configFileManager: ConfigFileManager = new ConfigFileManager();
+  const keypairPath = configFileManager.getConfigByKey("keyPairPath");
+
+  if (!keypairPath || !fs.existsSync(keypairPath)) {
+    console.error("Keypair file not found. Please generate or specify a valid keypair path.");
+    process.exit(1);
+  }
+
+  const keypairData = JSON.parse(fs.readFileSync(keypairPath, "utf-8"));
+
+  if (!keypairData.privateKey) {
+    console.error("Invalid keypair file. Private key is missing.");
+    process.exit(1);
+  }
+
+  return keypairData.privateKey;
+}

package/tests/actions/deploy.test.ts

@@ -0,0 +1,137 @@
+import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+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";
+
+vi.mock("fs");
+vi.mock("genlayer-js");
+vi.mock("../../src/lib/accounts/getPrivateKey");
+
+describe("Deploy Action", () => {
+  let deployer: DeployAction;
+  const mockClient = {
+    deployContract: vi.fn(),
+  };
+
+  const mockPrivateKey = "mocked_private_key";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(createClient).mockReturnValue(mockClient as any);
+    vi.mocked(createAccount).mockReturnValue({ privateKey: mockPrivateKey } as any);
+    vi.mocked(getPrivateKey).mockReturnValue(mockPrivateKey);
+    deployer = new DeployAction();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("reads contract code successfully", () => {
+    const contractPath = "/mocked/contract/path";
+    const contractContent = "contract code";
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
+
+    const result = deployer["readContractCode"](contractPath);
+
+    expect(fs.existsSync).toHaveBeenCalledWith(contractPath);
+    expect(fs.readFileSync).toHaveBeenCalledWith(contractPath, "utf-8");
+    expect(result).toBe(contractContent);
+  });
+
+  test("throws error if contract file is missing", () => {
+    const contractPath = "/mocked/contract/path";
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    expect(() => deployer["readContractCode"](contractPath)).toThrowError(
+      `Contract file not found: ${contractPath}`
+    );
+    expect(fs.existsSync).toHaveBeenCalledWith(contractPath);
+  });
+
+
+  test("deploys contract with args", async () => {
+    const options: DeployOptions = {
+      contract: "/mocked/contract/path",
+      args: [1, 2, 3],
+    };
+    const contractContent = "contract code";
+
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
+    vi.mocked(mockClient.deployContract).mockResolvedValue("mocked_tx_hash");
+
+    await deployer.deploy(options);
+
+    expect(fs.readFileSync).toHaveBeenCalledWith(options.contract, "utf-8");
+    expect(mockClient.deployContract).toHaveBeenCalledWith({
+      code: contractContent,
+      args: [1, 2, 3],
+      leaderOnly: false,
+    });
+    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 = {
+    };
+
+    await deployer.deploy(options);
+
+    expect(fs.readFileSync).not.toHaveBeenCalled();
+    expect(mockClient.deployContract).not.toHaveBeenCalled();
+  });
+
+  test("handles deployment errors", async () => {
+    const options: DeployOptions = {
+      contract: "/mocked/contract/path",
+      args: [1, 2, 3],
+    };
+    const contractContent = "contract code";
+
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
+    vi.mocked(mockClient.deployContract).mockRejectedValue(
+      new Error("Mocked deployment error")
+    );
+
+    await expect(deployer.deploy(options)).rejects.toThrowError(
+      "Contract deployment failed."
+    );
+
+    expect(fs.readFileSync).toHaveBeenCalledWith(options.contract, "utf-8");
+    expect(mockClient.deployContract).toHaveBeenCalled();
+  });
+
+  test("throws error if 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(fs.existsSync).toHaveBeenCalledWith(options.contract);
+    expect(fs.readFileSync).toHaveBeenCalledWith(options.contract, "utf-8");
+    expect(mockClient.deployContract).not.toHaveBeenCalled();
+  });
+});

package/tests/commands/deploy.test.ts

@@ -0,0 +1,69 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeContractsCommands } from "../../src/commands/contracts";
+import { DeployAction } from "../../src/commands/contracts/deploy";
+
+vi.mock("../../src/commands/contracts/deploy");
+
+describe("deploy command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeContractsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("DeployAction.deploy is called with default options", async () => {
+    program.parse(["node", "test", "deploy", "--contract", "./path/to/contract"]);
+    expect(DeployAction).toHaveBeenCalledTimes(1);
+    expect(DeployAction.prototype.deploy).toHaveBeenCalledWith({
+      contract: "./path/to/contract",
+      args: [],
+    });
+  });
+
+  test("DeployAction.deploy is called with positional arguments", async () => {
+    program.parse([
+      "node",
+      "test",
+      "deploy",
+      "--contract",
+      "./path/to/contract",
+      "--args",
+      "1",
+      "2",
+      "3",
+    ]);
+    expect(DeployAction).toHaveBeenCalledTimes(1);
+    expect(DeployAction.prototype.deploy).toHaveBeenCalledWith({
+      contract: "./path/to/contract",
+      args: ["1", "2", "3"]
+    });
+  });
+
+  test("DeployAction is instantiated when the deploy command is executed", async () => {
+    program.parse(["node", "test", "deploy", "--contract", "./path/to/contract"]);
+    expect(DeployAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const deployCommand = program.commands.find((cmd) => cmd.name() === "deploy");
+    deployCommand?.exitOverride();
+    expect(() => program.parse(["node", "test", "deploy", "--unknown"])).toThrowError(
+      "error: unknown option '--unknown'"
+    );
+  });
+
+  test("DeployAction.deploy is called without throwing errors for valid options", async () => {
+    program.parse(["node", "test", "deploy", "--contract", "./path/to/contract"]);
+    vi.mocked(DeployAction.prototype.deploy).mockResolvedValueOnce(undefined);
+    expect(() =>
+      program.parse(["node", "test", "deploy", "--contract", "./path/to/contract"])
+    ).not.toThrow();
+  });
+});

package/tests/index.test.ts

@@ -17,6 +17,10 @@ vi.mock("../src/commands/keygen", () => ({
   initializeKeygenCommands: vi.fn(),
 }));
 
+vi.mock("../src/commands/contracts", () => ({
+  initializeContractsCommands: vi.fn(),
+}));
+
 vi.mock("../src/commands/config", () => ({
   initializeConfigCommands: vi.fn(),
 }));

package/tests/libs/getPrivateKey.test.ts

@@ -0,0 +1,96 @@
+import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import fs from "fs";
+import { getPrivateKey } from "../../src/lib/accounts/getPrivateKey";
+import { ConfigFileManager } from "../../src/lib/config/ConfigFileManager";
+
+vi.mock("fs");
+vi.mock("../../src/lib/config/ConfigFileManager");
+
+describe("getPrivateKey", () => {
+  new ConfigFileManager();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("returns the private key if the file exists and is valid", () => {
+    const mockPath = "/mocked/path/keypair.json";
+    const mockPrivateKey = "0xMockedPrivateKey";
+    const mockKeypairData = { privateKey: mockPrivateKey };
+
+    vi.mocked(ConfigFileManager.prototype.getConfigByKey).mockReturnValue(mockPath);
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockKeypairData));
+
+    const privateKey = getPrivateKey();
+
+    expect(ConfigFileManager.prototype.getConfigByKey).toHaveBeenCalledWith("keyPairPath");
+    expect(fs.existsSync).toHaveBeenCalledWith(mockPath);
+    expect(fs.readFileSync).toHaveBeenCalledWith(mockPath, "utf-8");
+    expect(privateKey).toBe(mockPrivateKey);
+  });
+
+  test("exits if the keypair path is missing in the config", () => {
+    const consoleErrorSpy = vi.spyOn(console, "error");
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+
+    vi.mocked(ConfigFileManager.prototype.getConfigByKey).mockReturnValue(null);
+
+    expect(() => getPrivateKey()).toThrowError("process.exit");
+
+    expect(ConfigFileManager.prototype.getConfigByKey).toHaveBeenCalledWith("keyPairPath");
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      "Keypair file not found. Please generate or specify a valid keypair path."
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test("exits if the keypair file does not exist", () => {
+    const consoleErrorSpy = vi.spyOn(console, "error");
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+
+    const mockPath = "/mocked/path/keypair.json";
+
+    vi.mocked(ConfigFileManager.prototype.getConfigByKey).mockReturnValue(mockPath);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    expect(() => getPrivateKey()).toThrowError("process.exit");
+
+    expect(ConfigFileManager.prototype.getConfigByKey).toHaveBeenCalledWith("keyPairPath");
+    expect(fs.existsSync).toHaveBeenCalledWith(mockPath);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      "Keypair file not found. Please generate or specify a valid keypair path."
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test("exits if the private key is missing in the keypair file", () => {
+    const consoleErrorSpy = vi.spyOn(console, "error");
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+
+    const mockPath = "/mocked/path/keypair.json";
+    const mockKeypairData = { notPrivateKey: "SomeOtherData" }; // Invalid keypair data
+
+    vi.mocked(ConfigFileManager.prototype.getConfigByKey).mockReturnValue(mockPath);
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockKeypairData));
+
+    expect(() => getPrivateKey()).toThrowError("process.exit");
+
+    expect(ConfigFileManager.prototype.getConfigByKey).toHaveBeenCalledWith("keyPairPath");
+    expect(fs.existsSync).toHaveBeenCalledWith(mockPath);
+    expect(fs.readFileSync).toHaveBeenCalledWith(mockPath, "utf-8");
+    expect(consoleErrorSpy).toHaveBeenCalledWith("Invalid keypair file. Private key is missing.");
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+});

package/tsconfig.json

@@ -27,7 +27,7 @@
     /* Modules */
     "module": "ES2022" /* Specify what module code is generated. */,
     // "rootDir":  /* Specify the root folder within your source files. */,
-    "moduleResolution": "node" /* Specify how TypeScript looks up a file from a given module specifier. */,
+    "moduleResolution": "bundler" /* Specify how TypeScript looks up a file from a given module specifier. */,
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     "paths": {
       "@/*": ["./src/*"],