genlayer 0.31.0 → 0.32.1

package/tests/libs/keychainManager.test.ts

@@ -41,17 +41,17 @@ describe("KeychainManager", () => {
       const privateKey = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
       vi.mocked(keytar.setPassword).mockResolvedValue();
 
-      await keychainManager.storePrivateKey(privateKey);
+      await keychainManager.storePrivateKey("main", privateKey);
 
-      expect(keytar.setPassword).toHaveBeenCalledWith("genlayer-cli", "default-user", privateKey);
+      expect(keytar.setPassword).toHaveBeenCalledWith("genlayer-cli", "account:main", privateKey);
     });
 
     test("handles storage error", async () => {
       const privateKey = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
       vi.mocked(keytar.setPassword).mockRejectedValue(new Error("Storage failed"));
 
-      await expect(keychainManager.storePrivateKey(privateKey)).rejects.toThrow("Storage failed");
-      expect(keytar.setPassword).toHaveBeenCalledWith("genlayer-cli", "default-user", privateKey);
+      await expect(keychainManager.storePrivateKey("main", privateKey)).rejects.toThrow("Storage failed");
+      expect(keytar.setPassword).toHaveBeenCalledWith("genlayer-cli", "account:main", privateKey);
     });
   });
 
@@ -60,26 +60,26 @@ describe("KeychainManager", () => {
       const expectedKey = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
       vi.mocked(keytar.getPassword).mockResolvedValue(expectedKey);
 
-      const result = await keychainManager.getPrivateKey();
+      const result = await keychainManager.getPrivateKey("main");
 
       expect(result).toBe(expectedKey);
-      expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "default-user");
+      expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
     });
 
     test("returns null when private key does not exist", async () => {
       vi.mocked(keytar.getPassword).mockResolvedValue(null);
 
-      const result = await keychainManager.getPrivateKey();
+      const result = await keychainManager.getPrivateKey("main");
 
       expect(result).toBeNull();
-      expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "default-user");
+      expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
     });
 
     test("handles retrieval error", async () => {
       vi.mocked(keytar.getPassword).mockRejectedValue(new Error("Retrieval failed"));
 
-      await expect(keychainManager.getPrivateKey()).rejects.toThrow("Retrieval failed");
-      expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "default-user");
+      await expect(keychainManager.getPrivateKey("main")).rejects.toThrow("Retrieval failed");
+      expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
     });
   });
 
@@ -87,26 +87,66 @@ describe("KeychainManager", () => {
     test("successfully removes private key", async () => {
       vi.mocked(keytar.deletePassword).mockResolvedValue(true);
 
-      const result = await keychainManager.removePrivateKey();
+      const result = await keychainManager.removePrivateKey("main");
 
       expect(result).toBe(true);
-      expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "default-user");
+      expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
     });
 
     test("returns false when key does not exist", async () => {
       vi.mocked(keytar.deletePassword).mockResolvedValue(false);
 
-      const result = await keychainManager.removePrivateKey();
+      const result = await keychainManager.removePrivateKey("main");
 
       expect(result).toBe(false);
-      expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "default-user");
+      expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
     });
 
     test("handles removal error", async () => {
       vi.mocked(keytar.deletePassword).mockRejectedValue(new Error("Removal failed"));
 
-      await expect(keychainManager.removePrivateKey()).rejects.toThrow("Removal failed");
-      expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "default-user");
+      await expect(keychainManager.removePrivateKey("main")).rejects.toThrow("Removal failed");
+      expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
+    });
+  });
+
+  describe("listUnlockedAccounts", () => {
+    test("returns list of unlocked account names", async () => {
+      vi.mocked(keytar.findCredentials).mockResolvedValue([
+        {account: "account:main", password: "key1"},
+        {account: "account:validator", password: "key2"},
+        {account: "other:something", password: "key3"},
+      ]);
+
+      const result = await keychainManager.listUnlockedAccounts();
+
+      expect(result).toEqual(["main", "validator"]);
+    });
+
+    test("returns empty array when no accounts", async () => {
+      vi.mocked(keytar.findCredentials).mockResolvedValue([]);
+
+      const result = await keychainManager.listUnlockedAccounts();
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("isAccountUnlocked", () => {
+    test("returns true when account is unlocked", async () => {
+      vi.mocked(keytar.getPassword).mockResolvedValue("some-key");
+
+      const result = await keychainManager.isAccountUnlocked("main");
+
+      expect(result).toBe(true);
+    });
+
+    test("returns false when account is locked", async () => {
+      vi.mocked(keytar.getPassword).mockResolvedValue(null);
+
+      const result = await keychainManager.isAccountUnlocked("main");
+
+      expect(result).toBe(false);
     });
   });
 }); 

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/src/commands/keygen/lock.ts

@@ -1,31 +0,0 @@
-import { BaseAction } from "../../lib/actions/BaseAction";
-
-export class LockAction extends BaseAction {
-  async execute(): Promise<void> {
-    this.startSpinner("Checking keychain availability...");
-
-    const keychainAvailable = await this.keychainManager.isKeychainAvailable();
-    if (!keychainAvailable) {
-      this.failSpinner("OS keychain is not available. This command requires a supported keychain (e.g. macOS Keychain, Windows Credential Manager, or GNOME Keyring).");
-      return;
-    }
-
-    this.setSpinnerText("Checking for cached private key...");
-
-    const hasCachedKey = await this.keychainManager.getPrivateKey();
-    if (!hasCachedKey) {
-      this.succeedSpinner("Wallet is already locked (no cached key found in OS keychain).");
-      return;
-    }
-
-    this.setSpinnerText("Removing private key from OS keychain...");
-
-    try {
-      await this.keychainManager.removePrivateKey();
-      
-      this.succeedSpinner("Wallet locked successfully! Your private key has been removed from the OS keychain.");
-    } catch (error) {
-      this.failSpinner("Failed to lock wallet.", error);
-    }
-  }
-} 

package/src/commands/keygen/unlock.ts

@@ -1,41 +0,0 @@
-import { BaseAction } from "../../lib/actions/BaseAction";
-import { readFileSync, existsSync } from "fs";
-import { ethers } from "ethers";
-
-export class UnlockAction extends BaseAction {
-  async execute(): Promise<void> {
-    this.startSpinner("Checking keychain availability...");
-
-    const keychainAvailable = await this.keychainManager.isKeychainAvailable();
-    if (!keychainAvailable) {
-      this.failSpinner("OS keychain is not available. This command requires a supported keychain (e.g. macOS Keychain, Windows Credential Manager, or GNOME Keyring).");
-      return;
-    }
-
-    this.setSpinnerText("Checking for existing keystore...");
-
-    const keypairPath = this.getConfigByKey("keyPairPath");
-    if (!keypairPath || !existsSync(keypairPath)) {
-      this.failSpinner("No keystore file found. Please create a keypair first using 'genlayer keygen create'.");
-      return;
-    }
-
-    const keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
-    if (!this.isValidKeystoreFormat(keystoreData)) {
-      this.failSpinner("Invalid keystore format. Expected encrypted keystore file.");
-      return;
-    }
-
-    this.stopSpinner();
-
-    try {
-      const password = await this.promptPassword("Enter password to decrypt keystore:");
-      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
-      
-      await this.keychainManager.storePrivateKey(wallet.privateKey);
-      this.succeedSpinner("Wallet unlocked successfully! Your private key is now stored securely in the OS keychain.");
-    } catch (error) {
-      this.failSpinner("Failed to unlock wallet.", error);
-    }
-  }
-} 

package/src/lib/interfaces/KeystoreData.ts

@@ -1,5 +0,0 @@
-export interface KeystoreData {
-    version: number;
-    encrypted: string;
-    address: string;
-  }

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();
-  });
-});