genlayer 0.38.8 → 0.38.10

package/tests/actions/write.test.ts

@@ -0,0 +1,102 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import {WriteAction} from "../../src/commands/contracts/write";
+
+vi.mock("genlayer-js");
+
+describe("WriteAction", () => {
+  let writeAction: WriteAction;
+  const mockClient = {
+    writeContract: vi.fn(),
+    waitForTransactionReceipt: vi.fn(),
+    initializeConsensusSmartContract: 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);
+    writeAction = new WriteAction();
+    vi.spyOn(writeAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+
+    vi.spyOn(writeAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(writeAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(writeAction as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(writeAction as any, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("calls writeContract successfully", async () => {
+    const options = {args: [42, "Update"]};
+    const mockHash = "0xMockedTransactionHash";
+    const mockReceipt = {status: "success"};
+
+    vi.mocked(mockClient.writeContract).mockResolvedValue(mockHash);
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await writeAction.write({
+      contractAddress: "0xMockedContract",
+      method: "updateData",
+      ...options,
+    });
+
+    expect(mockClient.writeContract).toHaveBeenCalledWith({
+      address: "0xMockedContract",
+      functionName: "updateData",
+      args: [42, "Update"],
+      value: 0n,
+    });
+    expect(writeAction["log"]).toHaveBeenCalledWith("Write Transaction Hash:", mockHash);
+    expect(writeAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Write operation successfully executed",
+      mockReceipt,
+    );
+  });
+
+  test("handles writeContract errors", async () => {
+    vi.mocked(mockClient.writeContract).mockRejectedValue(new Error("Mocked write error"));
+
+    await writeAction.write({contractAddress: "0xMockedContract", method: "updateData", args: [1]});
+
+    expect(writeAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error during write operation",
+      expect.any(Error),
+    );
+  });
+
+  test("uses custom RPC URL for write operations", async () => {
+    const options = {args: [42, "Update"], rpc: "https://custom-rpc-url.com"};
+    const mockHash = "0xMockedTransactionHash";
+    const mockReceipt = {status: "success"};
+
+    vi.mocked(mockClient.writeContract).mockResolvedValue(mockHash);
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await writeAction.write({
+      contractAddress: "0xMockedContract",
+      method: "updateData",
+      ...options,
+    });
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: "https://custom-rpc-url.com",
+      }),
+    );
+    expect(mockClient.writeContract).toHaveBeenCalledWith({
+      address: "0xMockedContract",
+      functionName: "updateData",
+      args: [42, "Update"],
+      value: 0n,
+    });
+    expect(writeAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Write operation successfully executed",
+      mockReceipt,
+    );
+  });
+});

package/tests/commands/account.test.ts

@@ -0,0 +1,146 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeAccountCommands } from "../../src/commands/account";
+import { CreateAccountAction } from "../../src/commands/account/create";
+import { UnlockAccountAction } from "../../src/commands/account/unlock";
+import { LockAccountAction } from "../../src/commands/account/lock";
+
+vi.mock("../../src/commands/account/create");
+vi.mock("../../src/commands/account/unlock");
+vi.mock("../../src/commands/account/lock");
+vi.mock("../../src/commands/account/show");
+vi.mock("../../src/commands/account/import");
+vi.mock("../../src/commands/account/send");
+vi.mock("../../src/commands/account/list");
+vi.mock("../../src/commands/account/use");
+vi.mock("../../src/commands/account/remove");
+
+describe("account create command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeAccountCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("CreateAccountAction.execute is called with name option", async () => {
+    program.parse(["node", "test", "account", "create", "--name", "main"]);
+    expect(CreateAccountAction).toHaveBeenCalledTimes(1);
+    expect(CreateAccountAction.prototype.execute).toHaveBeenCalledWith({
+      name: "main",
+      overwrite: false,
+      setActive: true,
+    });
+  });
+
+  test("CreateAccountAction.execute is called with custom name option", async () => {
+    program.parse(["node", "test", "account", "create", "--name", "validator"]);
+    expect(CreateAccountAction).toHaveBeenCalledTimes(1);
+    expect(CreateAccountAction.prototype.execute).toHaveBeenCalledWith({
+      name: "validator",
+      overwrite: false,
+      setActive: true,
+    });
+  });
+
+  test("CreateAccountAction.execute is called with overwrite enabled", async () => {
+    program.parse(["node", "test", "account", "create", "--name", "main", "--overwrite"]);
+    expect(CreateAccountAction).toHaveBeenCalledTimes(1);
+    expect(CreateAccountAction.prototype.execute).toHaveBeenCalledWith({
+      name: "main",
+      overwrite: true,
+      setActive: true,
+    });
+  });
+
+  test("CreateAccountAction.execute is called with no-set-active option", async () => {
+    program.parse(["node", "test", "account", "create", "--name", "operator", "--no-set-active"]);
+    expect(CreateAccountAction).toHaveBeenCalledTimes(1);
+    expect(CreateAccountAction.prototype.execute).toHaveBeenCalledWith({
+      name: "operator",
+      overwrite: false,
+      setActive: false,
+    });
+  });
+
+  test("CreateAccountAction is instantiated when the command is executed", async () => {
+    program.parse(["node", "test", "account", "create", "--name", "main"]);
+    expect(CreateAccountAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("CreateAccountAction.execute is called without throwing errors", async () => {
+    vi.mocked(CreateAccountAction.prototype.execute).mockReturnValue(Promise.resolve());
+    expect(() => program.parse(["node", "test", "account", "create", "--name", "main"])).not.toThrow();
+  });
+});
+
+describe("account unlock command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeAccountCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("UnlockAccountAction is instantiated and execute is called", async () => {
+    program.parse(["node", "test", "account", "unlock"]);
+    expect(UnlockAccountAction).toHaveBeenCalledTimes(1);
+    expect(UnlockAccountAction.prototype.execute).toHaveBeenCalledWith({});
+  });
+
+  test("UnlockAccountAction.execute is called with account option", async () => {
+    program.parse(["node", "test", "account", "unlock", "--account", "validator"]);
+    expect(UnlockAccountAction).toHaveBeenCalledTimes(1);
+    expect(UnlockAccountAction.prototype.execute).toHaveBeenCalledWith({
+      account: "validator",
+    });
+  });
+
+  test("UnlockAccountAction.execute is called without throwing errors", async () => {
+    vi.mocked(UnlockAccountAction.prototype.execute).mockResolvedValue();
+    expect(() => program.parse(["node", "test", "account", "unlock"])).not.toThrow();
+  });
+});
+
+describe("account lock command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeAccountCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("LockAccountAction is instantiated and execute is called", async () => {
+    program.parse(["node", "test", "account", "lock"]);
+    expect(LockAccountAction).toHaveBeenCalledTimes(1);
+    expect(LockAccountAction.prototype.execute).toHaveBeenCalledWith({});
+  });
+
+  test("LockAccountAction.execute is called with account option", async () => {
+    program.parse(["node", "test", "account", "lock", "--account", "validator"]);
+    expect(LockAccountAction).toHaveBeenCalledTimes(1);
+    expect(LockAccountAction.prototype.execute).toHaveBeenCalledWith({
+      account: "validator",
+    });
+  });
+
+  test("LockAccountAction.execute is called without throwing errors", async () => {
+    vi.mocked(LockAccountAction.prototype.execute).mockResolvedValue();
+    expect(() => program.parse(["node", "test", "account", "lock"])).not.toThrow();
+  });
+});

package/tests/commands/appeal.test.ts

@@ -0,0 +1,97 @@
+import {Command} from "commander";
+import {AppealAction} from "../../src/commands/transactions/appeal";
+import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
+import {initializeTransactionsCommands} from "../../src/commands/transactions";
+
+vi.mock("../../src/commands/transactions/appeal");
+
+describe("appeal command", () => {
+  let program: Command;
+  const mockTxId = "0x1234567890123456789012345678901234567890123456789012345678901234";
+
+  beforeEach(() => {
+    program = new Command();
+    initializeTransactionsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("AppealAction.appeal is called with default options", async () => {
+    program.parse(["node", "test", "appeal", mockTxId]);
+    expect(AppealAction).toHaveBeenCalledTimes(1);
+    expect(AppealAction.prototype.appeal).toHaveBeenCalledWith({
+      txId: mockTxId,
+    });
+  });
+
+  test("AppealAction.appeal is called with custom RPC URL", async () => {
+    program.parse([
+      "node",
+      "test",
+      "appeal",
+      mockTxId,
+      "--rpc",
+      "https://custom-rpc-url-for-appeal.com",
+    ]);
+    expect(AppealAction).toHaveBeenCalledTimes(1);
+    expect(AppealAction.prototype.appeal).toHaveBeenCalledWith({
+      txId: mockTxId,
+      rpc: "https://custom-rpc-url-for-appeal.com",
+    });
+  });
+
+  test("AppealAction.appeal is called with --bond option", async () => {
+    program.parse(["node", "test", "appeal", mockTxId, "--bond", "500gen"]);
+    expect(AppealAction.prototype.appeal).toHaveBeenCalledWith({
+      txId: mockTxId,
+      bond: "500gen",
+    });
+  });
+
+  test("AppealAction is instantiated when the appeal command is executed", async () => {
+    program.parse(["node", "test", "appeal", mockTxId]);
+    expect(AppealAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const appealCommand = program.commands.find(cmd => cmd.name() === "appeal");
+    appealCommand?.exitOverride();
+    expect(() =>
+      program.parse(["node", "test", "appeal", mockTxId, "--invalid-option"]),
+    ).toThrowError("error: unknown option '--invalid-option'");
+  });
+});
+
+describe("appeal-bond command", () => {
+  let program: Command;
+  const mockTxId = "0x1234567890123456789012345678901234567890123456789012345678901234";
+
+  beforeEach(() => {
+    program = new Command();
+    initializeTransactionsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("AppealAction.appealBond is called with txId", async () => {
+    program.parse(["node", "test", "appeal-bond", mockTxId]);
+    expect(AppealAction).toHaveBeenCalledTimes(1);
+    expect(AppealAction.prototype.appealBond).toHaveBeenCalledWith({
+      txId: mockTxId,
+    });
+  });
+
+  test("AppealAction.appealBond is called with custom RPC URL", async () => {
+    program.parse(["node", "test", "appeal-bond", mockTxId, "--rpc", "https://custom.com"]);
+    expect(AppealAction.prototype.appealBond).toHaveBeenCalledWith({
+      txId: mockTxId,
+      rpc: "https://custom.com",
+    });
+  });
+});

package/tests/commands/call.test.ts

@@ -0,0 +1,78 @@
+import { Command } from "commander";
+import { CallAction } from "../../src/commands/contracts/call";
+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;
+
+  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: []
+    });
+  });
+
+  test("CallAction.call is called with positional arguments", async () => {
+    program.parse([
+      "node",
+      "test",
+      "call",
+      "0xMockedContract",
+      "updateData",
+      "--args",
+      "1",
+      "2",
+      "Hello",
+      "false",
+      "true",
+      "--rpc",
+      "https://custom-rpc-url.com"
+    ]);
+    expect(CallAction).toHaveBeenCalledTimes(1);
+    expect(CallAction.prototype.call).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      method: "updateData",
+      args: [1, 2, "Hello", false, true],
+      rpc: "https://custom-rpc-url.com"
+    });
+  });
+
+  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/code.test.ts

@@ -0,0 +1,69 @@
+import { Command } from "commander";
+import { CodeAction } from "../../src/commands/contracts/code";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeContractsCommands } from "../../src/commands/contracts";
+
+vi.mock("../../src/commands/contracts/code");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
+
+describe("code command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeContractsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("CodeAction.code is called with default options", async () => {
+    program.parse(["node", "test", "code", "0xMockedContract"]);
+    expect(CodeAction).toHaveBeenCalledTimes(1);
+    expect(CodeAction.prototype.code).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+    });
+  });
+
+  test("CodeAction.code is called with custom RPC URL", async () => {
+    program.parse([
+      "node",
+      "test",
+      "code",
+      "0xMockedContract",
+      "--rpc",
+      "https://custom-rpc-url.com"
+    ]);
+    expect(CodeAction).toHaveBeenCalledTimes(1);
+    expect(CodeAction.prototype.code).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      rpc: "https://custom-rpc-url.com"
+    });
+  });
+
+  test("CodeAction is instantiated when the code command is executed", async () => {
+    program.parse(["node", "test", "code", "0xMockedContract"]);
+    expect(CodeAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const codeCommand = program.commands.find((cmd) => cmd.name() === "code");
+    codeCommand?.exitOverride();
+    expect(() => program.parse(["node", "test", "code", "0xMockedContract", "--unknown"]))
+      .toThrowError("error: unknown option '--unknown'");
+  });
+
+  test("CodeAction.code is called without throwing errors for valid options", async () => {
+    program.parse(["node", "test", "code", "0xMockedContract"]);
+    vi.mocked(CodeAction.prototype.code).mockResolvedValueOnce(undefined as any);
+    expect(() =>
+      program.parse(["node", "test", "code", "0xMockedContract"])
+    ).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,83 @@
+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");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
+
+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",
+      "--rpc",
+      "https://custom-rpc-url.com"
+    ]);
+    expect(DeployAction).toHaveBeenCalledTimes(1);
+    expect(DeployAction.prototype.deploy).toHaveBeenCalledWith({
+      contract: "./path/to/contract",
+      args: [1, 2, 3],
+      rpc: "https://custom-rpc-url.com"
+    });
+  });
+
+  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();
+  });
+
+  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();
+  });
+});