genlayer 0.7.0 → 0.8.1-beta.0

package/tests/actions/deploy.test.ts

@@ -0,0 +1,139 @@
+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(),
+    waitForTransactionReceipt: 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");
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue({data: {contractAddress: '0xdasdsadasdasdada'}});
+
+    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/actions/getSetReset.test.ts

@@ -0,0 +1,101 @@
+import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import { ConfigActions } from "../../src/commands/config/getSetReset";
+import { ConfigFileManager } from "../../src/lib/config/ConfigFileManager";
+
+vi.mock("../../src/lib/config/ConfigFileManager");
+
+describe("ConfigActions", () => {
+  let configActions: ConfigActions;
+
+  beforeEach(() => {
+    configActions = new ConfigActions();
+    vi.clearAllMocks();
+  });
+
+  new ConfigFileManager();
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("set method writes key-value pair to the configuration", () => {
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.set("defaultNetwork=testnet");
+
+    expect(configActions["configManager"].writeConfig).toHaveBeenCalledWith("defaultNetwork", "testnet");
+    expect(consoleLogSpy).toHaveBeenCalledWith("Configuration updated: defaultNetwork=testnet");
+  });
+
+  test("set method throws error for invalid format", () => {
+    const consoleErrorSpy = vi.spyOn(console, "error");
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+
+    expect(() => configActions.set("invalidFormat")).toThrowError("process.exit");
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith("Invalid format. Use key=value.");
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test("get method retrieves value for a specific key", () => {
+    vi.mocked(ConfigFileManager.prototype.getConfigByKey).mockReturnValue("testnet");
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.get("defaultNetwork");
+
+    expect(configActions["configManager"].getConfigByKey).toHaveBeenCalledWith("defaultNetwork");
+    expect(consoleLogSpy).toHaveBeenCalledWith("defaultNetwork=testnet");
+  });
+
+  test("get method prints message when key has no value", () => {
+    vi.mocked(ConfigFileManager.prototype.getConfigByKey).mockReturnValue(null);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.get("nonexistentKey");
+
+    expect(configActions["configManager"].getConfigByKey).toHaveBeenCalledWith("nonexistentKey");
+    expect(consoleLogSpy).toHaveBeenCalledWith("No value set for key: nonexistentKey");
+  });
+
+  test("get method retrieves the entire configuration when no key is provided", () => {
+    const mockConfig = { defaultNetwork: "testnet" };
+    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue(mockConfig);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.get();
+
+    expect(configActions["configManager"].getConfig).toHaveBeenCalledTimes(1);
+    expect(consoleLogSpy).toHaveBeenCalledWith("Current configuration:", JSON.stringify(mockConfig, null, 2));
+  });
+
+  test("reset method removes key from configuration", () => {
+    const mockConfig = { defaultNetwork: "testnet" };
+    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue(mockConfig);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.reset("defaultNetwork");
+
+    expect(configActions["configManager"].getConfig).toHaveBeenCalledTimes(1);
+    expect(configActions["configManager"].writeConfig).toHaveBeenCalledWith("defaultNetwork", undefined);
+    expect(consoleLogSpy).toHaveBeenCalledWith("Configuration key reset: defaultNetwork");
+  });
+
+  test("reset method prints message when key does not exist", () => {
+    const mockConfig = {};
+    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue(mockConfig);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.reset("nonexistentKey");
+
+    expect(configActions["configManager"].getConfig).toHaveBeenCalledTimes(1);
+    expect(configActions["configManager"].writeConfig).not.toHaveBeenCalled();
+    expect(consoleLogSpy).toHaveBeenCalledWith("Key does not exist in the configuration: nonexistentKey");
+  });
+});

package/tests/commands/call.test.ts

@@ -0,0 +1,91 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeContractsCommands } from "../../src/commands/contracts";
+import { CallAction } from "../../src/commands/contracts/call";
+
+vi.mock("../../src/commands/contracts/call");
+
+describe("call command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeContractsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("CallAction.call is called with default options", async () => {
+    program.parse(["node", "test", "call", "0xMockedContract", "getData"]);
+    expect(CallAction).toHaveBeenCalledTimes(1);
+    expect(CallAction.prototype.call).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      method: "getData",
+      args: [],
+      type: "read",
+    });
+  });
+
+  test("CallAction.call is called with positional arguments", async () => {
+    program.parse([
+      "node",
+      "test",
+      "call",
+      "0xMockedContract",
+      "updateData",
+      "--args",
+      "1",
+      "2",
+      "Hello",
+    ]);
+    expect(CallAction).toHaveBeenCalledTimes(1);
+    expect(CallAction.prototype.call).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      method: "updateData",
+      args: ["1", "2", "Hello"],
+      type: "read",
+    });
+  });
+
+  test("CallAction.call is called with write type", async () => {
+    program.parse([
+      "node",
+      "test",
+      "call",
+      "0xMockedContract",
+      "updateData",
+      "--type",
+      "write",
+    ]);
+    expect(CallAction).toHaveBeenCalledTimes(1);
+    expect(CallAction.prototype.call).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      method: "updateData",
+      args: [],
+      type: "write",
+    });
+  });
+
+  test("CallAction is instantiated when the call command is executed", async () => {
+    program.parse(["node", "test", "call", "0xMockedContract", "getData"]);
+    expect(CallAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const callCommand = program.commands.find((cmd) => cmd.name() === "call");
+    callCommand?.exitOverride();
+    expect(() => program.parse(["node", "test", "call", "0xMockedContract", "getData", "--unknown"]))
+      .toThrowError("error: unknown option '--unknown'");
+  });
+
+  test("CallAction.call is called without throwing errors for valid options", async () => {
+    program.parse(["node", "test", "call", "0xMockedContract", "getData"]);
+    vi.mocked(CallAction.prototype.call).mockResolvedValueOnce(undefined);
+    expect(() =>
+      program.parse(["node", "test", "call", "0xMockedContract", "getData"])
+    ).not.toThrow();
+  });
+});

package/tests/commands/config.test.ts

@@ -0,0 +1,54 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeConfigCommands } from "../../src/commands/config";
+import { ConfigActions } from "../../src/commands/config/getSetReset";
+
+vi.mock("../../src/commands/config/getSetReset");
+
+describe("config commands", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeConfigCommands(program);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("ConfigActions.set is called with the correct key-value pair", async () => {
+    program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.set).toHaveBeenCalledWith("defaultNetwork=testnet");
+  });
+
+  test("ConfigActions.get is called with a specific key", async () => {
+    program.parse(["node", "test", "config", "get", "defaultNetwork"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.get).toHaveBeenCalledWith("defaultNetwork");
+  });
+
+  test("ConfigActions.get is called without a key", async () => {
+    program.parse(["node", "test", "config", "get"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.get).toHaveBeenCalledWith(undefined);
+  });
+
+  test("ConfigActions.reset is called with the correct key", async () => {
+    program.parse(["node", "test", "config", "reset", "defaultNetwork"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.reset).toHaveBeenCalledWith("defaultNetwork");
+  });
+
+  test("ConfigActions is instantiated when the command is executed", async () => {
+    program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+  });
+
+  test("ConfigActions.set is called without throwing errors for valid input", async () => {
+    program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"]);
+    vi.mocked(ConfigActions.prototype.set).mockReturnValue();
+    expect(() => program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"])).not.toThrow();
+  });
+});

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,14 @@ vi.mock("../src/commands/keygen", () => ({
   initializeKeygenCommands: vi.fn(),
 }));
 
+vi.mock("../src/commands/contracts", () => ({
+  initializeContractsCommands: vi.fn(),
+}));
+
+vi.mock("../src/commands/config", () => ({
+  initializeConfigCommands: vi.fn(),
+}));
+
 
 describe("CLI", () => {
   it("should initialize CLI", () => {

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/*"],