genlayer 0.30.0 → 0.32.0

package/tests/commands/staking.test.ts

@@ -0,0 +1,211 @@
+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 {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/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", "--amount", "1000gen"]);
+
+      expect(ValidatorDepositAction).toHaveBeenCalledTimes(1);
+      expect(ValidatorDepositAction.prototype.execute).toHaveBeenCalledWith({
+        amount: "1000gen",
+      });
+    });
+  });
+
+  describe("validator-exit", () => {
+    test("calls ValidatorExitAction.execute", async () => {
+      program.parse(["node", "test", "staking", "validator-exit", "--shares", "100"]);
+
+      expect(ValidatorExitAction).toHaveBeenCalledTimes(1);
+      expect(ValidatorExitAction.prototype.execute).toHaveBeenCalledWith({
+        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",
+      });
+    });
+
+    test("works without validator option", async () => {
+      program.parse(["node", "test", "staking", "validator-claim"]);
+
+      expect(ValidatorClaimAction.prototype.execute).toHaveBeenCalledWith({});
+    });
+  });
+
+  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({});
+    });
+  });
+});

package/tests/index.test.ts

@@ -13,8 +13,8 @@ vi.mock("../src/commands/general", () => ({
   initializeGeneralCommands: vi.fn(),
 }));
 
-vi.mock("../src/commands/keygen", () => ({
-  initializeKeygenCommands: vi.fn(),
+vi.mock("../src/commands/account", () => ({
+  initializeAccountCommands: vi.fn(),
 }));
 
 vi.mock("../src/commands/contracts", () => ({
@@ -45,6 +45,10 @@ 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();

package/tests/libs/baseAction.test.ts

@@ -109,7 +109,7 @@ describe("BaseAction", () => {
 
   test("should fail the spinner with an error message", () => {
     const error = new Error("Something went wrong");
-    baseAction["failSpinner"]("Failure", error);
+    baseAction["failSpinner"]("Failure", error, false); // Don't exit for test
 
     expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Error:"));
     expect(consoleSpy).toHaveBeenCalledWith(inspect(error, {depth: null, colors: false}));
@@ -117,6 +117,12 @@ describe("BaseAction", () => {
     expect(mockSpinner.fail).toHaveBeenCalledWith(expect.stringContaining("Failure"));
   });
 
+  test("should fail the spinner and exit by default", () => {
+    const error = new Error("Fatal error");
+    expect(() => baseAction["failSpinner"]("Fatal", error)).toThrow("process exited");
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
   test("should stop the spinner", () => {
     baseAction["stopSpinner"]();
     expect(mockSpinner.stop).toHaveBeenCalled();

package/src/commands/keygen/create.ts

@@ -1,23 +0,0 @@
-import {BaseAction} from "../../lib/actions/BaseAction";
-
-export interface CreateKeypairOptions {
-  output: string;
-  overwrite: boolean;
-}
-
-export class KeypairCreator extends BaseAction {
-  constructor() {
-    super();
-  }
-
-  async createKeypairAction(options: CreateKeypairOptions) {
-    try {
-      this.startSpinner(`Creating encrypted keystore...`);
-      await this.createKeypair(options.output, options.overwrite);
-      
-      this.succeedSpinner(`Encrypted keystore successfully created and saved to: ${options.output}`);
-    } catch (error) {
-      this.failSpinner("Failed to generate keystore", error);
-    }
-  }
-}

package/src/commands/keygen/index.ts

@@ -1,39 +0,0 @@
-import { Command } from "commander";
-import { CreateKeypairOptions, KeypairCreator } from "./create";
-import { UnlockAction } from "./unlock";
-import { LockAction } from "./lock";
-
-export function initializeKeygenCommands(program: Command) {
-
-  const keygenCommand = program
-    .command("keygen")
-    .description("Manage keypair generation");
-
-  keygenCommand
-    .command("create")
-    .description("Generates a new encrypted keystore and saves it to a file")
-    .option("--output <path>", "Path to save the keystore", "./keypair.json")
-    .option("--overwrite", "Overwrite the existing file if it already exists", false)
-    .action(async (options: CreateKeypairOptions) => {
-      const keypairCreator = new KeypairCreator();
-      await keypairCreator.createKeypairAction(options);
-    });
-
-  keygenCommand
-    .command("unlock")
-    .description("Unlock your wallet by storing the decrypted private key in OS keychain")
-    .action(async () => {
-      const unlockAction = new UnlockAction();
-      await unlockAction.execute();
-    });
-
-  keygenCommand
-    .command("lock")
-    .description("Lock your wallet by removing the decrypted private key from OS keychain")
-    .action(async () => {
-      const lockAction = new LockAction();
-      await lockAction.execute();
-    });
-
-  return program;
-}

package/tests/commands/keygen.test.ts

@@ -1,123 +0,0 @@
-import { Command } from "commander";
-import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
-import { initializeKeygenCommands } from "../../src/commands/keygen";
-import { KeypairCreator } from "../../src/commands/keygen/create";
-import { UnlockAction } from "../../src/commands/keygen/unlock";
-import { LockAction } from "../../src/commands/keygen/lock";
-
-vi.mock("../../src/commands/keygen/create");
-vi.mock("../../src/commands/keygen/unlock");
-vi.mock("../../src/commands/keygen/lock");
-
-describe("keygen create command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeKeygenCommands(program);
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("keypairCreator.createKeypairAction is called with default options", async () => {
-    program.parse(["node", "test", "keygen", "create"]);
-    expect(KeypairCreator).toHaveBeenCalledTimes(1);
-    expect(KeypairCreator.prototype.createKeypairAction).toHaveBeenCalledWith({
-      output: "./keypair.json",
-      overwrite: false,
-    });
-  });
-
-  test("keypairCreator.createKeypairAction is called with custom output option", async () => {
-    program.parse(["node", "test", "keygen", "create", "--output", "./custom.json"]);
-    expect(KeypairCreator).toHaveBeenCalledTimes(1);
-    expect(KeypairCreator.prototype.createKeypairAction).toHaveBeenCalledWith({
-      output: "./custom.json",
-      overwrite: false,
-    });
-  });
-
-  test("keypairCreator.createKeypairAction is called with overwrite enabled", async () => {
-    program.parse(["node", "test", "keygen", "create", "--overwrite"]);
-    expect(KeypairCreator).toHaveBeenCalledTimes(1);
-    expect(KeypairCreator.prototype.createKeypairAction).toHaveBeenCalledWith({
-      output: "./keypair.json",
-      overwrite: true,
-    });
-  });
-
-  test("keypairCreator.createKeypairAction is called with custom output and overwrite enabled", async () => {
-    program.parse(["node", "test", "keygen", "create", "--output", "./custom.json", "--overwrite"]);
-    expect(KeypairCreator).toHaveBeenCalledTimes(1);
-    expect(KeypairCreator.prototype.createKeypairAction).toHaveBeenCalledWith({
-      output: "./custom.json",
-      overwrite: true,
-    });
-  });
-
-  test("KeypairCreator is instantiated when the command is executed", async () => {
-    program.parse(["node", "test", "keygen", "create"]);
-    expect(KeypairCreator).toHaveBeenCalledTimes(1);
-  });
-
-
-
-  test("keypairCreator.createKeypairAction is called without throwing errors for default options", async () => {
-    program.parse(["node", "test", "keygen", "create"]);
-    vi.mocked(KeypairCreator.prototype.createKeypairAction).mockReturnValue();
-    expect(() => program.parse(["node", "test", "keygen", "create"])).not.toThrow();
-  });
-});
-
-describe("keygen unlock command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeKeygenCommands(program);
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("UnlockAction is instantiated and execute is called", async () => {
-    program.parse(["node", "test", "keygen", "unlock"]);
-    expect(UnlockAction).toHaveBeenCalledTimes(1);
-    expect(UnlockAction.prototype.execute).toHaveBeenCalled();
-  });
-
-  test("UnlockAction.execute is called without throwing errors", async () => {
-    vi.mocked(UnlockAction.prototype.execute).mockResolvedValue();
-    expect(() => program.parse(["node", "test", "keygen", "unlock"])).not.toThrow();
-  });
-});
-
-describe("keygen lock command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeKeygenCommands(program);
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("LockAction is instantiated and execute is called", async () => {
-    program.parse(["node", "test", "keygen", "lock"]);
-    expect(LockAction).toHaveBeenCalledTimes(1);
-    expect(LockAction.prototype.execute).toHaveBeenCalled();
-  });
-
-  test("LockAction.execute is called without throwing errors", async () => {
-    vi.mocked(LockAction.prototype.execute).mockResolvedValue();
-    expect(() => program.parse(["node", "test", "keygen", "lock"])).not.toThrow();
-  });
-});