genlayer 0.31.0 → 0.32.1

package/tests/commands/staking.test.ts

@@ -0,0 +1,333 @@
+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", "--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({});
+    });
+  });
+
+  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/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

@@ -28,10 +28,18 @@ describe("BaseAction", () => {
   let consoleErrorSpy: any;
   let processExitSpy: any;
 
+  // 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 = {
@@ -81,8 +89,11 @@ describe("BaseAction", () => {
     vi.spyOn(baseAction as any, "getConfigByKey").mockReturnValue("./test-keypair.json");
     vi.spyOn(baseAction as any, "getFilePath").mockImplementation(() => "./test-keypair.json");
     vi.spyOn(baseAction as any, "writeConfig").mockImplementation(() => {});
-    vi.spyOn(baseAction as any, "getConfig").mockReturnValue({});
-    
+    vi.spyOn(baseAction as any, "getConfig").mockReturnValue({activeAccount: "default"});
+    vi.spyOn(baseAction as any, "resolveAccountName").mockReturnValue("default");
+    vi.spyOn(baseAction as any, "getKeystorePath").mockReturnValue("/mocked/home/.genlayer/keystores/default.json");
+    vi.spyOn(baseAction as any, "getActiveAccount").mockReturnValue("default");
+
     // Mock keychainManager methods
     vi.spyOn(baseAction["keychainManager"], "isKeychainAvailable").mockResolvedValue(false);
     vi.spyOn(baseAction["keychainManager"], "getPrivateKey").mockResolvedValue(null);
@@ -109,7 +120,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 +128,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();
@@ -256,16 +273,16 @@ describe("BaseAction", () => {
     const account = await baseAction["getAccount"](false);
 
     expect((account as any).privateKey).toBe(mockWallet.privateKey);
-    expect(existsSync).toHaveBeenCalledWith("./test-keypair.json");
-    expect(readFileSync).toHaveBeenCalledWith("./test-keypair.json", "utf-8");
+    expect(existsSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json");
+    expect(readFileSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json", "utf-8");
   });
 
   test("should return address when called with readOnly=true", async () => {
     const address = await baseAction["getAccount"](true);
-    
+
     expect(address).toBe(mockKeystoreData.address);
-    expect(existsSync).toHaveBeenCalledWith("./test-keypair.json");
-    expect(readFileSync).toHaveBeenCalledWith("./test-keypair.json", "utf-8");
+    expect(existsSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json");
+    expect(readFileSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json", "utf-8");
   });
 
   test("should create new keypair when keystore file does not exist", async () => {
@@ -279,7 +296,7 @@ describe("BaseAction", () => {
 
     expect((account as any).privateKey).toBe(mockWallet.privateKey);
     expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
-      expect.objectContaining({message: chalk.yellow("Keypair file not found. Would you like to create a new keypair?")})
+      expect.objectContaining({message: chalk.yellow("Account 'default' not found. Would you like to create it?")})
     ]));
   });
 
@@ -298,7 +315,7 @@ describe("BaseAction", () => {
     const account = await baseAction["getAccount"](false);
 
     expect((account as any).privateKey).toBe(mockWallet.privateKey);
-    expect(baseAction["keychainManager"].getPrivateKey).toHaveBeenCalled();
+    expect(baseAction["keychainManager"].getPrivateKey).toHaveBeenCalledWith("default");
     expect(inquirer.prompt).not.toHaveBeenCalled();
   });
 
@@ -314,14 +331,14 @@ describe("BaseAction", () => {
     expect((account as any).privateKey).toBe(mockWallet.privateKey);
     expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Invalid keystore format. Expected encrypted keystore file."));
     expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
-      expect.objectContaining({message: chalk.yellow("Would you like to create a new keypair?")})
+      expect.objectContaining({message: "Would you like to recreate account 'default'?"})
     ]));
   });
 
   test("should decrypt keystore successfully on first attempt", async () => {
     vi.mocked(inquirer.prompt).mockResolvedValue({password: "correct-password"});
 
-    const result = await baseAction["decryptKeystore"](mockKeystoreData);
+    const result = await baseAction["decryptKeystore"](JSON.stringify(mockKeystoreData));
 
     expect(result).toBe(mockWallet.privateKey);
     expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
@@ -333,12 +350,12 @@ describe("BaseAction", () => {
     vi.mocked(ethers.Wallet.fromEncryptedJson)
       .mockRejectedValueOnce(new Error("Incorrect password"))
       .mockResolvedValueOnce(mockWallet as any);
-    
+
     vi.mocked(inquirer.prompt)
       .mockResolvedValueOnce({password: "wrong-password"})
       .mockResolvedValueOnce({password: "correct-password"});
 
-    const result = await baseAction["decryptKeystore"](mockKeystoreData);
+    const result = await baseAction["decryptKeystore"](JSON.stringify(mockKeystoreData));
 
     expect(result).toBe(mockWallet.privateKey);
     expect(inquirer.prompt).toHaveBeenCalledTimes(2);
@@ -351,8 +368,8 @@ describe("BaseAction", () => {
     vi.mocked(ethers.Wallet.fromEncryptedJson).mockRejectedValue(new Error("Incorrect password"));
     vi.mocked(inquirer.prompt).mockResolvedValue({password: "wrong-password"});
 
-    await expect(baseAction["decryptKeystore"](mockKeystoreData)).rejects.toThrow("process exited");
-    
+    await expect(baseAction["decryptKeystore"](JSON.stringify(mockKeystoreData))).rejects.toThrow("process exited");
+
     expect(inquirer.prompt).toHaveBeenCalledTimes(3);
     expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Maximum password attempts exceeded (3/3)."));
     expect(processExitSpy).toHaveBeenCalledWith(1);
@@ -364,22 +381,22 @@ describe("BaseAction", () => {
       .mockResolvedValueOnce({password: "test-password"})
       .mockResolvedValueOnce({password: "test-password"});
 
-    const result = await baseAction["createKeypair"]("./new-keypair.json", false);
+    const result = await baseAction["createKeypairByName"]("test-account", false);
 
     expect(result).toBe(mockWallet.privateKey);
     expect(ethers.Wallet.createRandom).toHaveBeenCalled();
     expect(mockWallet.encrypt).toHaveBeenCalledWith("test-password");
     expect(writeFileSync).toHaveBeenCalled();
-    expect(baseAction["keychainManager"].removePrivateKey).toHaveBeenCalled();
+    expect(baseAction["keychainManager"].removePrivateKey).toHaveBeenCalledWith("test-account");
   });
 
-  test("should fail when file exists and overwrite is false", async () => {
+  test("should fail when account exists and overwrite is false", async () => {
     vi.mocked(existsSync).mockReturnValue(true);
 
-    await expect(baseAction["createKeypair"]("./test-keypair.json", false)).rejects.toThrow("process exited");
-    
+    await expect(baseAction["createKeypairByName"]("test-account", false)).rejects.toThrow("process exited");
+
     expect(mockSpinner.fail).toHaveBeenCalledWith(
-      chalk.red("The file at ./test-keypair.json already exists. Use the '--overwrite' option to replace it.")
+      chalk.red("Account 'test-account' already exists. Use '--overwrite' to replace it.")
     );
   });
 
@@ -389,8 +406,8 @@ describe("BaseAction", () => {
       .mockResolvedValueOnce({password: "password1"})
       .mockResolvedValueOnce({password: "password2"});
 
-    await expect(baseAction["createKeypair"]("./new-keypair.json", false)).rejects.toThrow("process exited");
-    
+    await expect(baseAction["createKeypairByName"]("test-account", false)).rejects.toThrow("process exited");
+
     expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Passwords do not match"));
   });
 
@@ -400,50 +417,62 @@ describe("BaseAction", () => {
       .mockResolvedValueOnce({password: "short"})
       .mockResolvedValueOnce({password: "short"});
 
-    await expect(baseAction["createKeypair"]("./new-keypair.json", false)).rejects.toThrow("process exited");
-    
+    await expect(baseAction["createKeypairByName"]("test-account", false)).rejects.toThrow("process exited");
+
     expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Password must be at least 8 characters long"));
   });
 
-  test("should overwrite existing file when overwrite is true", async () => {
+  test("should overwrite existing account when overwrite is true", async () => {
     vi.mocked(existsSync).mockReturnValue(true);
     vi.mocked(inquirer.prompt)
       .mockResolvedValueOnce({password: "test-password"})
       .mockResolvedValueOnce({password: "test-password"});
 
-    const result = await baseAction["createKeypair"]("./existing.json", true);
+    const result = await baseAction["createKeypairByName"]("test-account", true);
 
     expect(result).toBe(mockWallet.privateKey);
     expect(writeFileSync).toHaveBeenCalled();
-    expect(baseAction["keychainManager"].removePrivateKey).toHaveBeenCalled();
+    expect(baseAction["keychainManager"].removePrivateKey).toHaveBeenCalledWith("test-account");
   });
 
   test("should return true for valid keystore format", () => {
+    // Standard web3 keystore format
+    const validKeystore = {
+      address: "1234567890123456789012345678901234567890",
+      crypto: {cipher: "aes-128-ctr", ciphertext: "test"},
+      version: 3,
+    };
+
+    const result = baseAction["isValidKeystoreFormat"](validKeystore);
+    expect(result).toBe(true);
+  });
+
+  test("should return true for keystore with uppercase Crypto field", () => {
+    // Some tools use uppercase 'Crypto'
     const validKeystore = {
-      version: 1,
-      encrypted: "encrypted-data",
-      address: "0x1234567890123456789012345678901234567890",
+      address: "1234567890123456789012345678901234567890",
+      Crypto: {cipher: "aes-128-ctr", ciphertext: "test"},
+      version: 3,
     };
 
     const result = baseAction["isValidKeystoreFormat"](validKeystore);
     expect(result).toBe(true);
   });
 
-  test("should return false for invalid keystore version", () => {
+  test("should return false for keystore missing crypto field", () => {
     const invalidKeystore = {
-      version: 2,
-      encrypted: "encrypted-data",
-      address: "0x1234567890123456789012345678901234567890",
+      address: "1234567890123456789012345678901234567890",
+      version: 3,
     };
 
     const result = baseAction["isValidKeystoreFormat"](invalidKeystore);
     expect(result).toBe(false);
   });
 
-  test("should return false for keystore missing fields", () => {
+  test("should return false for keystore missing address", () => {
     const invalidKeystore = {
-      version: 1,
-      encrypted: "encrypted-data",
+      crypto: {cipher: "aes-128-ctr"},
+      version: 3,
     };
 
     const result = baseAction["isValidKeystoreFormat"](invalidKeystore);

package/tests/libs/configFileManager.test.ts

@@ -10,6 +10,7 @@ vi.mock("os")
 
 describe("ConfigFileManager", () => {
   const mockFolderPath = "/mocked/home/.genlayer";
+  const mockKeystoresPath = `${mockFolderPath}/keystores`;
   const mockConfigFilePath = `${mockFolderPath}/genlayer-config.json`;
 
   let configFileManager: ConfigFileManager;
@@ -17,6 +18,8 @@ describe("ConfigFileManager", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({}));
     configFileManager = new ConfigFileManager();
   });
 
@@ -26,12 +29,16 @@ describe("ConfigFileManager", () => {
 
   test("ensures folder and config file are created if they don't exist", () => {
     vi.mocked(fs.existsSync).mockReturnValue(false);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({}));
 
     new ConfigFileManager();
 
     expect(fs.existsSync).toHaveBeenCalledWith(mockFolderPath);
     expect(fs.mkdirSync).toHaveBeenCalledWith(mockFolderPath, { recursive: true });
 
+    expect(fs.existsSync).toHaveBeenCalledWith(mockKeystoresPath);
+    expect(fs.mkdirSync).toHaveBeenCalledWith(mockKeystoresPath, { recursive: true });
+
     expect(fs.existsSync).toHaveBeenCalledWith(mockConfigFilePath);
     expect(fs.writeFileSync).toHaveBeenCalledWith(mockConfigFilePath, JSON.stringify({}, null, 2));
   });
@@ -39,11 +46,11 @@ describe("ConfigFileManager", () => {
   test("does not recreate folder or config file if they exist", () => {
     vi.clearAllMocks();
     vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({}));
 
     new ConfigFileManager();
 
     expect(fs.mkdirSync).not.toHaveBeenCalled();
-    expect(fs.writeFileSync).not.toHaveBeenCalled();
   });
 
   test("getFolderPath returns the correct folder path", () => {