genlayer 0.34.0 → 0.34.3

package/tests/actions/write.test.ts

@@ -1,102 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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 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'");
-  });
-}); 

package/tests/commands/call.test.ts

@@ -1,78 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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();
-  });
-});