genlayer 0.32.0 → 0.32.2

package/tests/actions/unlock.test.ts

@@ -1,28 +1,44 @@
 import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
 import {UnlockAccountAction} from "../../src/commands/account/unlock";
-import {readFileSync, existsSync} from "fs";
+import {readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync, unlinkSync, copyFileSync} from "fs";
 import {ethers} from "ethers";
 import inquirer from "inquirer";
+import os from "os";
 
 vi.mock("fs");
 vi.mock("ethers");
 vi.mock("inquirer");
+vi.mock("os");
 
 describe("UnlockAccountAction", () => {
   let unlockAction: UnlockAccountAction;
+  // Standard web3 keystore format
   const mockKeystoreData = {
-    version: 1,
-    encrypted: '{"address":"test","crypto":{"cipher":"aes-128-ctr"}}',
-    address: "0x1234567890123456789012345678901234567890"
+    address: "1234567890123456789012345678901234567890",
+    crypto: {
+      cipher: "aes-128-ctr",
+      ciphertext: "test",
+      cipherparams: {iv: "test"},
+      kdf: "scrypt",
+      kdfparams: {},
+      mac: "test"
+    },
+    version: 3
   };
   const mockWallet = {
     privateKey: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"
   };
+  const mockKeystorePath = "/mocked/home/.genlayer/keystores/default.json";
 
   beforeEach(() => {
     vi.clearAllMocks();
+    // Setup mocks before creating the action (needed for constructor)
+    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify({activeAccount: "default"}));
+
     unlockAction = new UnlockAccountAction();
-    
+
     // Mock the BaseAction methods
     vi.spyOn(unlockAction as any, "startSpinner").mockImplementation(() => {});
     vi.spyOn(unlockAction as any, "setSpinnerText").mockImplementation(() => {});
@@ -30,13 +46,14 @@ describe("UnlockAccountAction", () => {
     vi.spyOn(unlockAction as any, "succeedSpinner").mockImplementation(() => {});
     vi.spyOn(unlockAction as any, "failSpinner").mockImplementation(() => {});
     vi.spyOn(unlockAction as any, "promptPassword").mockResolvedValue("test-password");
-    vi.spyOn(unlockAction as any, "getConfigByKey").mockReturnValue("./test-keypair.json");
+    vi.spyOn(unlockAction as any, "getKeystorePath").mockReturnValue(mockKeystorePath);
+    vi.spyOn(unlockAction as any, "resolveAccountName").mockReturnValue("default");
     vi.spyOn(unlockAction as any, "isValidKeystoreFormat").mockReturnValue(true);
-    
+
     // Mock keychainManager
     vi.spyOn(unlockAction["keychainManager"], "isKeychainAvailable").mockResolvedValue(true);
     vi.spyOn(unlockAction["keychainManager"], "storePrivateKey").mockResolvedValue();
-    
+
     // Mock fs and ethers
     vi.mocked(existsSync).mockReturnValue(true);
     vi.mocked(readFileSync).mockReturnValue(JSON.stringify(mockKeystoreData));
@@ -52,15 +69,15 @@ describe("UnlockAccountAction", () => {
 
     expect(unlockAction["startSpinner"]).toHaveBeenCalledWith("Checking keychain availability...");
     expect(unlockAction["keychainManager"].isKeychainAvailable).toHaveBeenCalled();
-    expect(unlockAction["setSpinnerText"]).toHaveBeenCalledWith("Checking for existing account...");
-    expect(unlockAction["getConfigByKey"]).toHaveBeenCalledWith("keyPairPath");
-    expect(existsSync).toHaveBeenCalledWith("./test-keypair.json");
+    expect(unlockAction["setSpinnerText"]).toHaveBeenCalledWith("Checking for account 'default'...");
+    expect(unlockAction["getKeystorePath"]).toHaveBeenCalledWith("default");
+    expect(existsSync).toHaveBeenCalledWith(mockKeystorePath);
     expect(unlockAction["stopSpinner"]).toHaveBeenCalled();
-    expect(unlockAction["promptPassword"]).toHaveBeenCalledWith("Enter password to unlock account:");
-    expect(readFileSync).toHaveBeenCalledWith("./test-keypair.json", "utf-8");
-    expect(ethers.Wallet.fromEncryptedJson).toHaveBeenCalledWith(mockKeystoreData.encrypted, "test-password");
-    expect(unlockAction["keychainManager"].storePrivateKey).toHaveBeenCalledWith(mockWallet.privateKey);
-    expect(unlockAction["succeedSpinner"]).toHaveBeenCalledWith("Account unlocked! Private key cached in OS keychain.");
+    expect(unlockAction["promptPassword"]).toHaveBeenCalledWith("Enter password to unlock 'default':");
+    expect(readFileSync).toHaveBeenCalledWith(mockKeystorePath, "utf-8");
+    expect(ethers.Wallet.fromEncryptedJson).toHaveBeenCalledWith(JSON.stringify(mockKeystoreData), "test-password");
+    expect(unlockAction["keychainManager"].storePrivateKey).toHaveBeenCalledWith("default", mockWallet.privateKey);
+    expect(unlockAction["succeedSpinner"]).toHaveBeenCalledWith("Account 'default' unlocked! Private key cached in OS keychain.");
   });
 
   test("fails when keychain is not available", async () => {
@@ -73,21 +90,12 @@ describe("UnlockAccountAction", () => {
     expect(unlockAction["keychainManager"].storePrivateKey).not.toHaveBeenCalled();
   });
 
-  test("fails when no keystore file is found", async () => {
-    vi.spyOn(unlockAction as any, "getConfigByKey").mockReturnValue(null);
-
-    await unlockAction.execute();
-
-    expect(unlockAction["failSpinner"]).toHaveBeenCalledWith("No account found. Run 'genlayer account create' first.");
-    expect(unlockAction["promptPassword"]).not.toHaveBeenCalled();
-  });
-
   test("fails when keystore file does not exist", async () => {
     vi.mocked(existsSync).mockReturnValue(false);
 
     await unlockAction.execute();
 
-    expect(unlockAction["failSpinner"]).toHaveBeenCalledWith("No account found. Run 'genlayer account create' first.");
+    expect(unlockAction["failSpinner"]).toHaveBeenCalledWith("Account 'default' not found. Run 'genlayer account create --name default' first.");
     expect(unlockAction["promptPassword"]).not.toHaveBeenCalled();
   });
 
@@ -118,4 +126,14 @@ describe("UnlockAccountAction", () => {
 
     expect(unlockAction["failSpinner"]).toHaveBeenCalledWith("Failed to unlock account.", mockError);
   });
+
+  test("uses account option when provided", async () => {
+    vi.spyOn(unlockAction as any, "resolveAccountName").mockReturnValue("validator");
+    vi.spyOn(unlockAction as any, "getKeystorePath").mockReturnValue("/mocked/home/.genlayer/keystores/validator.json");
+
+    await unlockAction.execute({account: "validator"});
+
+    expect(unlockAction["accountOverride"]).toBe("validator");
+    expect(unlockAction["setSpinnerText"]).toHaveBeenCalledWith("Checking for account 'validator'...");
+  });
 }); 

package/tests/commands/account.test.ts

@@ -8,6 +8,12 @@ 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;
@@ -22,51 +28,54 @@ describe("account create command", () => {
     vi.restoreAllMocks();
   });
 
-  test("CreateAccountAction.execute is called with default options", async () => {
-    program.parse(["node", "test", "account", "create"]);
+  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({
-      output: "./keypair.json",
+      name: "main",
       overwrite: false,
+      setActive: true,
     });
   });
 
-  test("CreateAccountAction.execute is called with custom output option", async () => {
-    program.parse(["node", "test", "account", "create", "--output", "./custom.json"]);
+  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({
-      output: "./custom.json",
+      name: "validator",
       overwrite: false,
+      setActive: true,
     });
   });
 
   test("CreateAccountAction.execute is called with overwrite enabled", async () => {
-    program.parse(["node", "test", "account", "create", "--overwrite"]);
+    program.parse(["node", "test", "account", "create", "--name", "main", "--overwrite"]);
     expect(CreateAccountAction).toHaveBeenCalledTimes(1);
     expect(CreateAccountAction.prototype.execute).toHaveBeenCalledWith({
-      output: "./keypair.json",
+      name: "main",
       overwrite: true,
+      setActive: true,
     });
   });
 
-  test("CreateAccountAction.execute is called with custom output and overwrite enabled", async () => {
-    program.parse(["node", "test", "account", "create", "--output", "./custom.json", "--overwrite"]);
+  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({
-      output: "./custom.json",
-      overwrite: true,
+      name: "operator",
+      overwrite: false,
+      setActive: false,
     });
   });
 
   test("CreateAccountAction is instantiated when the command is executed", async () => {
-    program.parse(["node", "test", "account", "create"]);
+    program.parse(["node", "test", "account", "create", "--name", "main"]);
     expect(CreateAccountAction).toHaveBeenCalledTimes(1);
   });
 
-  test("CreateAccountAction.execute is called without throwing errors for default options", async () => {
-    program.parse(["node", "test", "account", "create"]);
+  test("CreateAccountAction.execute is called without throwing errors", async () => {
     vi.mocked(CreateAccountAction.prototype.execute).mockReturnValue(Promise.resolve());
-    expect(() => program.parse(["node", "test", "account", "create"])).not.toThrow();
+    expect(() => program.parse(["node", "test", "account", "create", "--name", "main"])).not.toThrow();
   });
 });
 
@@ -86,7 +95,15 @@ describe("account unlock command", () => {
   test("UnlockAccountAction is instantiated and execute is called", async () => {
     program.parse(["node", "test", "account", "unlock"]);
     expect(UnlockAccountAction).toHaveBeenCalledTimes(1);
-    expect(UnlockAccountAction.prototype.execute).toHaveBeenCalled();
+    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 () => {
@@ -111,7 +128,15 @@ describe("account lock command", () => {
   test("LockAccountAction is instantiated and execute is called", async () => {
     program.parse(["node", "test", "account", "lock"]);
     expect(LockAccountAction).toHaveBeenCalledTimes(1);
-    expect(LockAccountAction.prototype.execute).toHaveBeenCalled();
+    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 () => {

package/tests/commands/network.test.ts

@@ -18,43 +18,43 @@ describe("network commands", () => {
   });
 
   test("NetworkActions.setNetwork is called with the correct network name", async () => {
-    program.parse(["node", "test", "network", "localnet"]);
+    program.parse(["node", "test", "network", "set", "localnet"]);
     expect(NetworkActions).toHaveBeenCalledTimes(1);
     expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("localnet");
   });
 
   test("NetworkActions.setNetwork is called with testnet-asimov", async () => {
-    program.parse(["node", "test", "network", "testnet-asimov"]);
+    program.parse(["node", "test", "network", "set", "testnet-asimov"]);
     expect(NetworkActions).toHaveBeenCalledTimes(1);
     expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("testnet-asimov");
   });
 
   test("NetworkActions.setNetwork is called with studionet", async () => {
-    program.parse(["node", "test", "network", "studionet"]);
+    program.parse(["node", "test", "network", "set", "studionet"]);
     expect(NetworkActions).toHaveBeenCalledTimes(1);
     expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("studionet");
   });
 
   test("NetworkActions.setNetwork is called without a network name", async () => {
-    program.parse(["node", "test", "network"]);
+    program.parse(["node", "test", "network", "set"]);
     expect(NetworkActions).toHaveBeenCalledTimes(1);
     expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith(undefined);
   });
 
   test("NetworkActions is instantiated when the command is executed", async () => {
-    program.parse(["node", "test", "network", "localnet"]);
+    program.parse(["node", "test", "network", "set", "localnet"]);
     expect(NetworkActions).toHaveBeenCalledTimes(1);
   });
 
   test("NetworkActions.setNetwork is called without throwing errors for valid network", async () => {
-    program.parse(["node", "test", "network", "localnet"]);
+    program.parse(["node", "test", "network", "set", "localnet"]);
     vi.mocked(NetworkActions.prototype.setNetwork).mockResolvedValue();
-    expect(() => program.parse(["node", "test", "network", "localnet"])).not.toThrow();
+    expect(() => program.parse(["node", "test", "network", "set", "localnet"])).not.toThrow();
   });
 
-  test("NetworkActions.setNetwork is called with empty string", async () => {
-    program.parse(["node", "test", "network", ""]);
+  test("NetworkActions.showInfo is called for network info", async () => {
+    program.parse(["node", "test", "network", "info"]);
     expect(NetworkActions).toHaveBeenCalledTimes(1);
-    expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("");
+    expect(NetworkActions.prototype.showInfo).toHaveBeenCalled();
   });
 });

package/tests/commands/staking.test.ts

@@ -5,6 +5,9 @@ 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";
@@ -14,6 +17,9 @@ 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");
@@ -208,4 +214,120 @@ describe("staking commands", () => {
       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",
+      });
+    });
+  });
 });