genlayer 0.38.9 → 0.38.10

package/tests/commands/schema.test.ts

@@ -0,0 +1,67 @@
+import { Command } from "commander";
+import { SchemaAction } from "../../src/commands/contracts/schema";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeContractsCommands } from "../../src/commands/contracts";
+
+vi.mock("../../src/commands/contracts/schema");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
+
+describe("schema command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeContractsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("SchemaAction.schema is called with default options", async () => {
+    program.parse(["node", "test", "schema", "0xMockedContract"]);
+    expect(SchemaAction).toHaveBeenCalledTimes(1);
+    expect(SchemaAction.prototype.schema).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+    });
+  });
+
+  test("SchemaAction.schema is called with custom RPC URL", async () => {
+    program.parse([
+      "node",
+      "test",
+      "schema",
+      "0xMockedContract",
+      "--rpc",
+      "https://custom-rpc-url.com"
+    ]);
+    expect(SchemaAction).toHaveBeenCalledTimes(1);
+    expect(SchemaAction.prototype.schema).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      rpc: "https://custom-rpc-url.com"
+    });
+  });
+
+  test("SchemaAction is instantiated when the schema command is executed", async () => {
+    program.parse(["node", "test", "schema", "0xMockedContract"]);
+    expect(SchemaAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const schemaCommand = program.commands.find((cmd) => cmd.name() === "schema");
+    schemaCommand?.exitOverride();
+    expect(() => program.parse(["node", "test", "schema", "0xMockedContract", "--unknown"]))
+      .toThrowError("error: unknown option '--unknown'");
+  });
+
+  test("SchemaAction.schema is called without throwing errors for valid options", async () => {
+    program.parse(["node", "test", "schema", "0xMockedContract"]);
+    vi.mocked(SchemaAction.prototype.schema).mockResolvedValueOnce(undefined);
+    expect(() =>
+      program.parse(["node", "test", "schema", "0xMockedContract"])
+    ).not.toThrow();
+  });
+}); 

package/tests/commands/staking.test.ts

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

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

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

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

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