genlayer 0.33.1 → 0.34.1

package/tests/commands/staking.test.ts

@@ -1,329 +0,0 @@
-import {Command} from "commander";
-import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
-import {initializeStakingCommands} from "../../src/commands/staking";
-import {ValidatorJoinAction} from "../../src/commands/staking/validatorJoin";
-import {ValidatorDepositAction} from "../../src/commands/staking/validatorDeposit";
-import {ValidatorExitAction} from "../../src/commands/staking/validatorExit";
-import {ValidatorClaimAction} from "../../src/commands/staking/validatorClaim";
-import {ValidatorPrimeAction} from "../../src/commands/staking/validatorPrime";
-import {SetOperatorAction} from "../../src/commands/staking/setOperator";
-import {SetIdentityAction} from "../../src/commands/staking/setIdentity";
-import {DelegatorJoinAction} from "../../src/commands/staking/delegatorJoin";
-import {DelegatorExitAction} from "../../src/commands/staking/delegatorExit";
-import {DelegatorClaimAction} from "../../src/commands/staking/delegatorClaim";
-import {StakingInfoAction} from "../../src/commands/staking/stakingInfo";
-
-vi.mock("../../src/commands/staking/validatorJoin");
-vi.mock("../../src/commands/staking/validatorDeposit");
-vi.mock("../../src/commands/staking/validatorExit");
-vi.mock("../../src/commands/staking/validatorClaim");
-vi.mock("../../src/commands/staking/validatorPrime");
-vi.mock("../../src/commands/staking/setOperator");
-vi.mock("../../src/commands/staking/setIdentity");
-vi.mock("../../src/commands/staking/delegatorJoin");
-vi.mock("../../src/commands/staking/delegatorExit");
-vi.mock("../../src/commands/staking/delegatorClaim");
-vi.mock("../../src/commands/staking/stakingInfo");
-
-describe("staking commands", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeStakingCommands(program);
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe("validator-join", () => {
-    test("calls ValidatorJoinAction.execute with amount", async () => {
-      program.parse(["node", "test", "staking", "validator-join", "--amount", "42000gen"]);
-
-      expect(ValidatorJoinAction).toHaveBeenCalledTimes(1);
-      expect(ValidatorJoinAction.prototype.execute).toHaveBeenCalledWith({
-        amount: "42000gen",
-      });
-    });
-
-    test("calls ValidatorJoinAction.execute with operator", async () => {
-      program.parse([
-        "node",
-        "test",
-        "staking",
-        "validator-join",
-        "--amount",
-        "42000gen",
-        "--operator",
-        "0xOperator",
-      ]);
-
-      expect(ValidatorJoinAction.prototype.execute).toHaveBeenCalledWith({
-        amount: "42000gen",
-        operator: "0xOperator",
-      });
-    });
-
-    test("accepts staking-address option", async () => {
-      program.parse([
-        "node",
-        "test",
-        "staking",
-        "validator-join",
-        "--amount",
-        "42000",
-        "--staking-address",
-        "0xStaking",
-      ]);
-
-      expect(ValidatorJoinAction.prototype.execute).toHaveBeenCalledWith(
-        expect.objectContaining({stakingAddress: "0xStaking"}),
-      );
-    });
-  });
-
-  describe("validator-deposit", () => {
-    test("calls ValidatorDepositAction.execute", async () => {
-      program.parse(["node", "test", "staking", "validator-deposit", "--validator", "0x1234567890123456789012345678901234567890", "--amount", "1000gen"]);
-
-      expect(ValidatorDepositAction).toHaveBeenCalledTimes(1);
-      expect(ValidatorDepositAction.prototype.execute).toHaveBeenCalledWith({
-        validator: "0x1234567890123456789012345678901234567890",
-        amount: "1000gen",
-      });
-    });
-  });
-
-  describe("validator-exit", () => {
-    test("calls ValidatorExitAction.execute", async () => {
-      program.parse(["node", "test", "staking", "validator-exit", "--validator", "0x1234567890123456789012345678901234567890", "--shares", "100"]);
-
-      expect(ValidatorExitAction).toHaveBeenCalledTimes(1);
-      expect(ValidatorExitAction.prototype.execute).toHaveBeenCalledWith({
-        validator: "0x1234567890123456789012345678901234567890",
-        shares: "100",
-      });
-    });
-  });
-
-  describe("validator-claim", () => {
-    test("calls ValidatorClaimAction.execute", async () => {
-      program.parse(["node", "test", "staking", "validator-claim", "--validator", "0xValidator"]);
-
-      expect(ValidatorClaimAction).toHaveBeenCalledTimes(1);
-      expect(ValidatorClaimAction.prototype.execute).toHaveBeenCalledWith({
-        validator: "0xValidator",
-      });
-    });
-  });
-
-  describe("delegator-join", () => {
-    test("calls DelegatorJoinAction.execute", async () => {
-      program.parse([
-        "node",
-        "test",
-        "staking",
-        "delegator-join",
-        "--validator",
-        "0xValidator",
-        "--amount",
-        "42gen",
-      ]);
-
-      expect(DelegatorJoinAction).toHaveBeenCalledTimes(1);
-      expect(DelegatorJoinAction.prototype.execute).toHaveBeenCalledWith({
-        validator: "0xValidator",
-        amount: "42gen",
-      });
-    });
-  });
-
-  describe("delegator-exit", () => {
-    test("calls DelegatorExitAction.execute", async () => {
-      program.parse([
-        "node",
-        "test",
-        "staking",
-        "delegator-exit",
-        "--validator",
-        "0xValidator",
-        "--shares",
-        "50",
-      ]);
-
-      expect(DelegatorExitAction).toHaveBeenCalledTimes(1);
-      expect(DelegatorExitAction.prototype.execute).toHaveBeenCalledWith({
-        validator: "0xValidator",
-        shares: "50",
-      });
-    });
-  });
-
-  describe("delegator-claim", () => {
-    test("calls DelegatorClaimAction.execute", async () => {
-      program.parse([
-        "node",
-        "test",
-        "staking",
-        "delegator-claim",
-        "--validator",
-        "0xValidator",
-        "--delegator",
-        "0xDelegator",
-      ]);
-
-      expect(DelegatorClaimAction).toHaveBeenCalledTimes(1);
-      expect(DelegatorClaimAction.prototype.execute).toHaveBeenCalledWith({
-        validator: "0xValidator",
-        delegator: "0xDelegator",
-      });
-    });
-  });
-
-  describe("validator-info", () => {
-    test("calls StakingInfoAction.getValidatorInfo", async () => {
-      program.parse(["node", "test", "staking", "validator-info", "--validator", "0xValidator"]);
-
-      expect(StakingInfoAction).toHaveBeenCalledTimes(1);
-      expect(StakingInfoAction.prototype.getValidatorInfo).toHaveBeenCalledWith({
-        validator: "0xValidator",
-      });
-    });
-  });
-
-  describe("epoch-info", () => {
-    test("calls StakingInfoAction.getEpochInfo", async () => {
-      program.parse(["node", "test", "staking", "epoch-info"]);
-
-      expect(StakingInfoAction).toHaveBeenCalledTimes(1);
-      expect(StakingInfoAction.prototype.getEpochInfo).toHaveBeenCalledWith({});
-    });
-  });
-
-  describe("active-validators", () => {
-    test("calls StakingInfoAction.listActiveValidators", async () => {
-      program.parse(["node", "test", "staking", "active-validators"]);
-
-      expect(StakingInfoAction).toHaveBeenCalledTimes(1);
-      expect(StakingInfoAction.prototype.listActiveValidators).toHaveBeenCalledWith({});
-    });
-  });
-
-  describe("validator-prime", () => {
-    test("calls ValidatorPrimeAction.execute", async () => {
-      program.parse(["node", "test", "staking", "validator-prime", "--validator", "0xValidator"]);
-
-      expect(ValidatorPrimeAction).toHaveBeenCalledTimes(1);
-      expect(ValidatorPrimeAction.prototype.execute).toHaveBeenCalledWith({
-        validator: "0xValidator",
-      });
-    });
-  });
-
-  describe("set-operator", () => {
-    test("calls SetOperatorAction.execute", async () => {
-      program.parse([
-        "node",
-        "test",
-        "staking",
-        "set-operator",
-        "--validator",
-        "0xValidator",
-        "--operator",
-        "0xOperator",
-      ]);
-
-      expect(SetOperatorAction).toHaveBeenCalledTimes(1);
-      expect(SetOperatorAction.prototype.execute).toHaveBeenCalledWith({
-        validator: "0xValidator",
-        operator: "0xOperator",
-      });
-    });
-  });
-
-  describe("set-identity", () => {
-    test("calls SetIdentityAction.execute with required fields", async () => {
-      program.parse([
-        "node",
-        "test",
-        "staking",
-        "set-identity",
-        "--validator",
-        "0xValidator",
-        "--moniker",
-        "My Validator",
-      ]);
-
-      expect(SetIdentityAction).toHaveBeenCalledTimes(1);
-      expect(SetIdentityAction.prototype.execute).toHaveBeenCalledWith({
-        validator: "0xValidator",
-        moniker: "My Validator",
-      });
-    });
-
-    test("calls SetIdentityAction.execute with all optional fields", async () => {
-      program.parse([
-        "node",
-        "test",
-        "staking",
-        "set-identity",
-        "--validator",
-        "0xValidator",
-        "--moniker",
-        "My Validator",
-        "--website",
-        "https://example.com",
-        "--twitter",
-        "myhandle",
-        "--github",
-        "mygithub",
-      ]);
-
-      expect(SetIdentityAction.prototype.execute).toHaveBeenCalledWith({
-        validator: "0xValidator",
-        moniker: "My Validator",
-        website: "https://example.com",
-        twitter: "myhandle",
-        github: "mygithub",
-      });
-    });
-  });
-
-  describe("delegation-info", () => {
-    test("calls StakingInfoAction.getStakeInfo", async () => {
-      program.parse([
-        "node",
-        "test",
-        "staking",
-        "delegation-info",
-        "--validator",
-        "0xValidator",
-      ]);
-
-      expect(StakingInfoAction).toHaveBeenCalledTimes(1);
-      expect(StakingInfoAction.prototype.getStakeInfo).toHaveBeenCalledWith({
-        validator: "0xValidator",
-      });
-    });
-
-    test("calls StakingInfoAction.getStakeInfo with delegator", async () => {
-      program.parse([
-        "node",
-        "test",
-        "staking",
-        "delegation-info",
-        "--validator",
-        "0xValidator",
-        "--delegator",
-        "0xDelegator",
-      ]);
-
-      expect(StakingInfoAction.prototype.getStakeInfo).toHaveBeenCalledWith({
-        validator: "0xValidator",
-        delegator: "0xDelegator",
-      });
-    });
-  });
-});

package/tests/commands/stop.test.ts

@@ -1,27 +0,0 @@
-import { Command } from "commander";
-import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
-import { initializeGeneralCommands } from "../../src/commands/general";
-import { StopAction } from "../../src/commands/general/stop";
-
-vi.mock("../../src/commands/general/stop");
-
-describe("stop command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeGeneralCommands(program);
-
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("doesn't require arguments or options", async () => {
-    expect(() => program.parse(["node", "test", "stop"])).not.toThrow();
-    expect(StopAction).toHaveBeenCalledTimes(1);
-    expect(StopAction.prototype.stop).toHaveBeenCalledWith();
-  });
-});

package/tests/commands/up.test.ts

@@ -1,105 +0,0 @@
-import { Command } from "commander";
-import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
-import { initializeGeneralCommands } from "../../src/commands/general";
-import { getCommand, getCommandOption } from "../utils";
-import { StartAction } from "../../src/commands/general/start";
-
-vi.mock("../../src/commands/general/start");
-
-describe("up command", () => {
-  let upCommand: Command;
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeGeneralCommands(program);
-
-    upCommand = getCommand(program, "up");
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("doesn't require arguments or options", async () => {
-    expect(() => program.parse(["node", "test", "up"])).not.toThrow();
-    expect(StartAction).toHaveBeenCalledTimes(1);
-    expect(StartAction.prototype.execute).toHaveBeenCalledWith(
-      expect.objectContaining({
-        resetValidators: false,
-        numValidators: "5",
-        headless: false,
-        resetDb: false,
-        ollama: false,
-      })
-    );
-  });
-
-  test("option --reset-validators is accepted", async () => {
-    expect(() => program.parse(["node", "test", "up", "--reset-validators"])).not.toThrow();
-  });
-
-  test("option --reset-validators default value is false", async () => {
-    const resetValidatorsOption = getCommandOption(upCommand, "--reset-validators");
-    expect(resetValidatorsOption?.defaultValue).toBe(false);
-  });
-
-  test("option --numValidators is accepted", async () => {
-    expect(() => program.parse(["node", "test", "up", "--numValidators", "10"])).not.toThrow();
-  });
-
-  test("option --numValidators default value is 5", async () => {
-    const numValidatorsOption = getCommandOption(upCommand, "--numValidators");
-    expect(numValidatorsOption?.defaultValue).toBe("5");
-  });
-
-  test("unrecognized option is not accepted", async () => {
-    upCommand?.exitOverride();
-    expect(() => program.parse(["node", "test", "up", "-unknown"])).toThrowError(
-      "error: unknown option '-unknown'"
-    );
-    expect(() => program.parse(["node", "test", "up", "--unknownOption"])).toThrowError(
-      "error: unknown option '--unknownOption'"
-    );
-  });
-
-  test("action is called with default options", async () => {
-    program.parse(["node", "test", "up"]);
-    expect(StartAction).toHaveBeenCalledTimes(1);
-    expect(StartAction.prototype.execute).toHaveBeenCalledWith(
-      expect.objectContaining({
-        resetValidators: false,
-        numValidators: "5",
-        headless: false,
-        resetDb: false,
-        ollama: false,
-      })
-    );
-  });
-
-  test("action is called with custom options", async () => {
-    program.parse([
-      "node",
-      "test",
-      "up",
-      "--reset-validators",
-      "--numValidators",
-      "10",
-      "--headless",
-      "--reset-db",
-      "--ollama",
-    ]);
-
-    expect(StartAction).toHaveBeenCalledTimes(1);
-    expect(StartAction.prototype.execute).toHaveBeenCalledWith(
-      expect.objectContaining({
-        resetValidators: true,
-        numValidators: "10",
-        headless: true,
-        resetDb: true,
-        ollama: true,
-      })
-    );
-  });
-});

package/tests/commands/update.test.ts

@@ -1,45 +0,0 @@
-import { Command } from "commander";
-import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
-import { initializeUpdateCommands } from "../../src/commands/update";
-import { OllamaAction } from "../../src/commands/update/ollama";
-
-vi.mock("../../src/commands/update/ollama");
-
-describe("ollama command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeUpdateCommands(program);
-
-    const mockConfig = { defaultOllamaModel: "default-model" };
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("OllamaAction.updateModel is called with model option", async () => {
-    program.parse(["node", "test", "update", "ollama", "--model", "mocked_model"]);
-    expect(OllamaAction).toHaveBeenCalledTimes(1);
-    expect(OllamaAction.prototype.updateModel).toHaveBeenCalledWith("mocked_model");
-  });
-
-  test("OllamaAction.updateModel is called with default model", async () => {
-    program.parse(["node", "test", "update", "ollama"]);
-    expect(OllamaAction).toHaveBeenCalledTimes(1);
-    expect(OllamaAction.prototype.updateModel).toHaveBeenCalledWith("");
-  });
-
-  test("OllamaAction.removeModel is called with model option", async () => {
-    program.parse(["node", "test", "update", "ollama", "--model", "mocked_model", "--remove"]);
-    expect(OllamaAction).toHaveBeenCalledTimes(1);
-    expect(OllamaAction.prototype.removeModel).toHaveBeenCalledWith("mocked_model");
-  });
-
-  test("OllamaAction.removeModel is called with default model", async () => {
-    program.parse(["node", "test", "update", "ollama", "--remove"]);
-    expect(OllamaAction).toHaveBeenCalledTimes(1);
-    expect(OllamaAction.prototype.removeModel).toHaveBeenCalledWith("");
-  });
-});

package/tests/commands/write.test.ts

@@ -1,76 +0,0 @@
-import {Command} from "commander";
-import {WriteAction} from "../../src/commands/contracts/write";
-import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
-import {initializeContractsCommands} from "../../src/commands/contracts";
-
-vi.mock("../../src/commands/contracts/write");
-vi.mock("esbuild", () => ({
-  buildSync: vi.fn(),
-}));
-
-describe("write command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeContractsCommands(program);
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("WriteAction.write is called with default options", async () => {
-    program.parse(["node", "test", "write", "0xMockedContract", "setData"]);
-    expect(WriteAction).toHaveBeenCalledTimes(1);
-    expect(WriteAction.prototype.write).toHaveBeenCalledWith({
-      contractAddress: "0xMockedContract",
-      method: "setData",
-      args: [],
-    });
-  });
-
-  test("WriteAction.write is called with positional arguments and options", async () => {
-    program.parse([
-      "node",
-      "test",
-      "write",
-      "0xMockedContract",
-      "updateCounter",
-      "--args",
-      "100",
-      "someString",
-      "true",
-      "--rpc",
-      "https://custom-rpc-url-for-write.com",
-    ]);
-    expect(WriteAction).toHaveBeenCalledTimes(1);
-    expect(WriteAction.prototype.write).toHaveBeenCalledWith({
-      contractAddress: "0xMockedContract",
-      method: "updateCounter",
-      args: [100, "someString", true],
-      rpc: "https://custom-rpc-url-for-write.com",
-    });
-  });
-
-  test("WriteAction is instantiated when the write command is executed", async () => {
-    program.parse(["node", "test", "write", "0xMockedContract", "anotherMethod"]);
-    expect(WriteAction).toHaveBeenCalledTimes(1);
-  });
-
-  test("throws error for unrecognized options", async () => {
-    const writeCommand = program.commands.find(cmd => cmd.name() === "write");
-    writeCommand?.exitOverride();
-    expect(() =>
-      program.parse(["node", "test", "write", "0xMockedContract", "someMethod", "--invalid-option"]),
-    ).toThrowError("error: unknown option '--invalid-option'");
-  });
-
-  test("WriteAction.write is called without throwing errors for valid options", async () => {
-    program.parse(["node", "test", "write", "0xMockedContract", "validMethod"]);
-    vi.mocked(WriteAction.prototype.write).mockResolvedValueOnce(undefined);
-    // Need to parse again inside expect to ensure the mockResolvedValueOnce is used for the assertion context
-    expect(() => program.parse(["node", "test", "write", "0xMockedContract", "validMethod"])).not.toThrow();
-  });
-});

package/tests/index.test.ts

@@ -1,56 +0,0 @@
-import {describe, it, vi, expect} from "vitest";
-import {initializeCLI} from "../src/index";
-
-vi.mock("commander", () => ({
-  program: {
-    version: vi.fn().mockReturnThis(),
-    description: vi.fn().mockReturnThis(),
-    parse: vi.fn(),
-  },
-}));
-
-vi.mock("../src/commands/general", () => ({
-  initializeGeneralCommands: vi.fn(),
-}));
-
-vi.mock("../src/commands/account", () => ({
-  initializeAccountCommands: vi.fn(),
-}));
-
-vi.mock("../src/commands/contracts", () => ({
-  initializeContractsCommands: vi.fn(),
-}));
-
-vi.mock("../src/commands/config", () => ({
-  initializeConfigCommands: vi.fn(),
-}));
-
-vi.mock("../src/commands/localnet", () => ({
-  initializeValidatorCommands: vi.fn(),
-}));
-
-vi.mock("../src/commands/update", () => ({
-  initializeUpdateCommands: vi.fn(),
-}));
-
-vi.mock("../src/commands/scaffold", () => ({
-  initializeScaffoldCommands: vi.fn(),
-}));
-
-vi.mock("../src/commands/network", () => ({
-  initializeNetworkCommands: vi.fn(),
-}));
-
-vi.mock("../src/commands/transactions", () => ({
-  initializeTransactionsCommands: vi.fn(),
-}));
-
-vi.mock("../src/commands/staking", () => ({
-  initializeStakingCommands: vi.fn(),
-}));
-
-describe("CLI", () => {
-  it("should initialize CLI", () => {
-    expect(initializeCLI).not.toThrow();
-  });
-});