genlayer 0.18.5 → 0.20.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.20.0 (2025-07-09)
+
+### Features
+
+* use keystore to store private keys ([#235](https://github.com/yeagerai/genlayer-cli/issues/235)) ([f18f2af](https://github.com/yeagerai/genlayer-cli/commit/f18f2afbc35c2dd988908d51ffce6b0523cfee81))
+
+## 0.19.0 (2025-07-09)
+
+### Features
+
+* appeal command ([#233](https://github.com/yeagerai/genlayer-cli/issues/233)) ([a33f882](https://github.com/yeagerai/genlayer-cli/commit/a33f882ec7f1e7758bbf6daef67b425be10e87f2))
+
 ## 0.18.5 (2025-07-09)
 
 ## 0.18.4 (2025-06-27)

package/dist/index.js

@@ -17723,7 +17723,7 @@ var require_semver2 = __commonJS({
 import { program } from "commander";
 
 // package.json
-var version = "0.18.5";
+var version = "0.20.0";
 var package_default = {
   name: "genlayer",
   version,
@@ -20660,39 +20660,6 @@ function ora(options) {
 import inquirer from "inquirer";
 import { inspect } from "util";
 
-// src/lib/accounts/KeypairManager.ts
-import { writeFileSync, existsSync, readFileSync } from "fs";
-import { ethers } from "ethers";
-var KeypairManager = class extends ConfigFileManager {
-  constructor() {
-    super();
-  }
-  getPrivateKey() {
-    const keypairPath = this.getConfigByKey("keyPairPath");
-    if (!keypairPath || !existsSync(keypairPath)) {
-      return "";
-    }
-    const keypairData = JSON.parse(readFileSync(keypairPath, "utf-8"));
-    if (!keypairData.privateKey) {
-      return "";
-    }
-    return keypairData.privateKey;
-  }
-  createKeypair(outputPath = "./keypair.json", overwrite = false) {
-    const finalOutputPath = this.getFilePath(outputPath);
-    if (existsSync(finalOutputPath) && !overwrite) {
-      throw new Error(`The file at ${finalOutputPath} already exists. Use the '--overwrite' option to replace it.`);
-    }
-    const wallet = ethers.Wallet.createRandom();
-    const keypairData = {
-      address: wallet.address,
-      privateKey: wallet.privateKey
-    };
-    writeFileSync(finalOutputPath, JSON.stringify(keypairData, null, 2));
-    this.writeConfig("keyPairPath", finalOutputPath);
-  }
-};
-
 // node_modules/genlayer-js/dist/chunk-MLKGABMK.js
 var __defProp2 = Object.defineProperty;
 var __export2 = (target, all) => {
@@ -40935,14 +40902,39 @@ var createAccount = (accountPrivateKey) => {
 };
 
 // src/lib/actions/BaseAction.ts
+import { ethers } from "ethers";
+import { writeFileSync, existsSync, readFileSync } from "fs";
 var BaseAction = class extends ConfigFileManager {
   constructor() {
     super();
-    __publicField(this, "keypairManager");
     __publicField(this, "spinner");
     __publicField(this, "_genlayerClient", null);
     this.spinner = ora({ text: "", spinner: "dots" });
-    this.keypairManager = new KeypairManager();
+  }
+  async decryptKeystore(keystoreData, attempt = 1) {
+    try {
+      const message = attempt === 1 ? "Enter password to decrypt keystore:" : `Invalid password. Attempt ${attempt}/3 - Enter password to decrypt keystore:`;
+      const password = await this.promptPassword(message);
+      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
+      return wallet.privateKey;
+    } catch (error) {
+      if (attempt >= 3) {
+        this.failSpinner("Maximum password attempts exceeded (3/3).");
+        process.exit(1);
+      }
+      return await this.decryptKeystore(keystoreData, attempt + 1);
+    }
+  }
+  isValidKeystoreFormat(data) {
+    return Boolean(
+      data && data.version === 1 && typeof data.encrypted === "string" && typeof data.address === "string"
+    );
+  }
+  formatOutput(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    return inspect(data, { depth: null, colors: false });
   }
   async getClient(rpcUrl) {
     if (!this._genlayerClient) {
@@ -40957,13 +40949,63 @@ var BaseAction = class extends ConfigFileManager {
     return this._genlayerClient;
   }
   async getPrivateKey() {
-    const privateKey = this.keypairManager.getPrivateKey();
-    if (privateKey) {
-      return privateKey;
+    const keypairPath = this.getConfigByKey("keyPairPath");
+    if (!keypairPath || !existsSync(keypairPath)) {
+      await this.confirmPrompt("Keypair file not found. Would you like to create a new keypair?");
+      return await this.createKeypair("./keypair.json", false);
+    }
+    const keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+    if (!this.isValidKeystoreFormat(keystoreData)) {
+      this.failSpinner("Invalid keystore format. Expected encrypted keystore file.");
+      await this.confirmPrompt("Would you like to create a new keypair?");
+      return await this.createKeypair("./keypair.json", true);
     }
-    await this.confirmPrompt("Keypair file not found. Would you like to create a new keypair?");
-    this.keypairManager.createKeypair();
-    return this.keypairManager.getPrivateKey();
+    return await this.decryptKeystore(keystoreData);
+  }
+  async createKeypair(outputPath, overwrite) {
+    const finalOutputPath = this.getFilePath(outputPath);
+    this.stopSpinner();
+    if (existsSync(finalOutputPath) && !overwrite) {
+      this.failSpinner(`The file at ${finalOutputPath} already exists. Use the '--overwrite' option to replace it.`);
+      process.exit(1);
+    }
+    const wallet = ethers.Wallet.createRandom();
+    const password = await this.promptPassword("Enter a password to encrypt your keystore (minimum 8 characters):");
+    const confirmPassword = await this.promptPassword("Confirm password:");
+    if (password !== confirmPassword) {
+      this.failSpinner("Passwords do not match");
+      process.exit(1);
+    }
+    if (password.length < 8) {
+      this.failSpinner("Password must be at least 8 characters long");
+      process.exit(1);
+    }
+    const encryptedJson = await wallet.encrypt(password);
+    const keystoreData = {
+      version: 1,
+      encrypted: encryptedJson,
+      address: wallet.address
+    };
+    writeFileSync(finalOutputPath, JSON.stringify(keystoreData, null, 2));
+    this.writeConfig("keyPairPath", finalOutputPath);
+    return wallet.privateKey;
+  }
+  async promptPassword(message) {
+    const answer = await inquirer.prompt([
+      {
+        type: "password",
+        name: "password",
+        message: source_default.yellow(message),
+        mask: "*",
+        validate: (input) => {
+          if (!input) {
+            return "Password cannot be empty";
+          }
+          return true;
+        }
+      }
+    ]);
+    return answer.password;
   }
   async confirmPrompt(message) {
     const answer = await inquirer.prompt([
@@ -40979,12 +41021,6 @@ var BaseAction = class extends ConfigFileManager {
       process.exit(0);
     }
   }
-  formatOutput(data) {
-    if (typeof data === "string") {
-      return data;
-    }
-    return inspect(data, { depth: null, colors: false });
-  }
   log(message, data) {
     console.log(source_default.white(`
 ${message}`));
@@ -42123,13 +42159,13 @@ var KeypairCreator = class extends BaseAction {
   constructor() {
     super();
   }
-  createKeypairAction(options) {
+  async createKeypairAction(options) {
     try {
-      this.startSpinner(`Creating keypair...`);
-      this.keypairManager.createKeypair(options.output, options.overwrite);
-      this.succeedSpinner(`Keypair successfully created and saved to: ${options.output}`);
+      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 keypair", error);
+      this.failSpinner("Failed to generate keystore", error);
     }
   }
 };
@@ -42137,9 +42173,9 @@ var KeypairCreator = class extends BaseAction {
 // src/commands/keygen/index.ts
 function initializeKeygenCommands(program2) {
   const keygenCommand = program2.command("keygen").description("Manage keypair generation");
-  keygenCommand.command("create").description("Generates a new keypair and saves it to a file").option("--output <path>", "Path to save the keypair", "./keypair.json").option("--overwrite", "Overwrite the existing file if it already exists", false).action((options) => {
+  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) => {
     const keypairCreator = new KeypairCreator();
-    keypairCreator.createKeypairAction(options);
+    await keypairCreator.createKeypairAction(options);
   });
   return program2;
 }
@@ -42779,6 +42815,43 @@ function initializeNetworkCommands(program2) {
   return program2;
 }
 
+// src/commands/transactions/appeal.ts
+var AppealAction = class extends BaseAction {
+  constructor() {
+    super();
+  }
+  async appeal({
+    txId,
+    rpc
+  }) {
+    const client = await this.getClient(rpc);
+    await client.initializeConsensusSmartContract();
+    this.startSpinner(`Appealing transaction ${txId}...`);
+    try {
+      const hash2 = await client.appealTransaction({
+        txId
+      });
+      const result = await client.waitForTransactionReceipt({
+        hash: hash2,
+        retries: 100,
+        interval: 5e3
+      });
+      this.succeedSpinner("Appeal operation successfully executed", result);
+    } catch (error) {
+      this.failSpinner("Error during appeal operation", error);
+    }
+  }
+};
+
+// src/commands/transactions/index.ts
+function initializeTransactionsCommands(program2) {
+  program2.command("appeal <txId>").description("Appeal a transaction by its hash").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (txId, options) => {
+    const appealAction = new AppealAction();
+    await appealAction.appeal({ txId, ...options });
+  });
+  return program2;
+}
+
 // src/index.ts
 function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
@@ -42790,6 +42863,7 @@ function initializeCLI() {
   initializeValidatorCommands(program);
   initializeScaffoldCommands(program);
   initializeNetworkCommands(program);
+  initializeTransactionsCommands(program);
   program.parse(process.argv);
 }
 initializeCLI();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.18.5",
+  "version": "0.20.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "type": "module",

package/src/commands/keygen/create.ts

@@ -10,13 +10,14 @@ export class KeypairCreator extends BaseAction {
     super();
   }
 
-  createKeypairAction(options: CreateKeypairOptions) {
+  async createKeypairAction(options: CreateKeypairOptions) {
     try {
-      this.startSpinner(`Creating keypair...`);
-      this.keypairManager.createKeypair(options.output, options.overwrite);
-      this.succeedSpinner(`Keypair successfully created and saved to: ${options.output}`);
+      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 keypair", error);
+      this.failSpinner("Failed to generate keystore", error);
     }
   }
 }

package/src/commands/keygen/index.ts

@@ -9,12 +9,12 @@ export function initializeKeygenCommands(program: Command) {
 
   keygenCommand
     .command("create")
-    .description("Generates a new keypair and saves it to a file")
-    .option("--output <path>", "Path to save the keypair", "./keypair.json")
+    .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((options: CreateKeypairOptions) => {
+    .action(async (options: CreateKeypairOptions) => {
       const keypairCreator = new KeypairCreator();
-      keypairCreator.createKeypairAction(options);
+      await keypairCreator.createKeypairAction(options);
     });
 
   return program;

package/src/commands/transactions/appeal.ts

@@ -0,0 +1,39 @@
+import {TransactionHash} from "genlayer-js/types";
+import {BaseAction} from "../../lib/actions/BaseAction";
+
+export interface AppealOptions {
+  rpc?: string;
+}
+
+export class AppealAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async appeal({
+    txId,
+    rpc,
+  }: {
+    txId: TransactionHash;
+    rpc?: string;
+  }): Promise<void> {
+    const client = await this.getClient(rpc);
+    await client.initializeConsensusSmartContract();
+    this.startSpinner(`Appealing transaction ${txId}...`);
+
+    try {
+      const hash = await client.appealTransaction({
+        txId,
+      });
+
+      const result = await client.waitForTransactionReceipt({
+        hash,
+        retries: 100,
+        interval: 5000,
+      });
+      this.succeedSpinner("Appeal operation successfully executed", result);
+    } catch (error) {
+      this.failSpinner("Error during appeal operation", error);
+    }
+  }
+} 

package/src/commands/transactions/index.ts

@@ -0,0 +1,16 @@
+import {Command} from "commander";
+import {TransactionHash} from "genlayer-js/types";
+import {AppealAction, AppealOptions} from "./appeal";
+
+export function initializeTransactionsCommands(program: Command) {
+  program
+    .command("appeal <txId>")
+    .description("Appeal a transaction by its hash")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (txId: TransactionHash, options: AppealOptions) => {
+      const appealAction = new AppealAction();
+      await appealAction.appeal({txId, ...options});
+    });
+
+  return program;
+} 

package/src/index.ts

@@ -10,6 +10,7 @@ import {initializeValidatorCommands} from "../src/commands/validators";
 import {initializeUpdateCommands} from "../src/commands/update";
 import {initializeScaffoldCommands} from "../src/commands/scaffold";
 import {initializeNetworkCommands} from "../src/commands/network";
+import {initializeTransactionsCommands} from "../src/commands/transactions";
 
 export function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
@@ -21,6 +22,7 @@ export function initializeCLI() {
   initializeValidatorCommands(program);
   initializeScaffoldCommands(program);
   initializeNetworkCommands(program);
+  initializeTransactionsCommands(program);
   program.parse(process.argv);
 }
 

package/src/lib/actions/BaseAction.ts

@@ -3,20 +3,53 @@ import ora, {Ora} from "ora";
 import chalk from "chalk";
 import inquirer from "inquirer";
 import { inspect } from "util";
-import {KeypairManager} from "../accounts/KeypairManager";
 import {createClient, createAccount} from "genlayer-js";
 import {localnet} from "genlayer-js/chains";
 import type {GenLayerClient, GenLayerChain} from "genlayer-js/types";
+import { ethers } from "ethers";
+import { writeFileSync, existsSync, readFileSync } from "fs";
+import { KeystoreData } from "../interfaces/KeystoreData";
 
 export class BaseAction extends ConfigFileManager {
-  protected keypairManager: KeypairManager;
   private spinner: Ora;
   private _genlayerClient: GenLayerClient<GenLayerChain> | null = null;
 
   constructor() {
     super();
     this.spinner = ora({text: "", spinner: "dots"});
-    this.keypairManager = new KeypairManager();
+  }
+
+  private async decryptKeystore(keystoreData: KeystoreData, attempt: number = 1): Promise<string> {
+    try {
+      const message = attempt === 1 
+        ? "Enter password to decrypt keystore:" 
+        : `Invalid password. Attempt ${attempt}/3 - Enter password to decrypt keystore:`;
+      const password = await this.promptPassword(message);
+      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
+      return wallet.privateKey;
+    } catch (error) {
+      if (attempt >= 3) {
+        this.failSpinner("Maximum password attempts exceeded (3/3).");
+        process.exit(1);
+      }
+      return await this.decryptKeystore(keystoreData, attempt + 1);
+    }
+  }
+
+  private isValidKeystoreFormat(data: any): data is KeystoreData {
+    return Boolean(
+      data && 
+      data.version === 1 && 
+      typeof data.encrypted === "string" && 
+      typeof data.address === "string"
+    );
+  }
+
+  private formatOutput(data: any): string {
+    if (typeof data === "string") {
+      return data;
+    }
+    return inspect(data, { depth: null, colors: false });
   }
 
   protected async getClient(rpcUrl?: string): Promise<GenLayerClient<GenLayerChain>> {
@@ -32,14 +65,79 @@ export class BaseAction extends ConfigFileManager {
     return this._genlayerClient;
   }
 
-  protected async getPrivateKey() {
-    const privateKey = this.keypairManager.getPrivateKey();
-    if (privateKey) {
-      return privateKey;
+  protected async getPrivateKey(): Promise<string> {
+    const keypairPath = this.getConfigByKey("keyPairPath");
+
+    if (!keypairPath || !existsSync(keypairPath)) {
+      await this.confirmPrompt("Keypair file not found. Would you like to create a new keypair?");
+      return await this.createKeypair("./keypair.json", false);
+    }
+
+    const keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+
+    if (!this.isValidKeystoreFormat(keystoreData)) {
+      this.failSpinner("Invalid keystore format. Expected encrypted keystore file.");
+      await this.confirmPrompt("Would you like to create a new keypair?");
+      return await this.createKeypair("./keypair.json", true);
     }
-    await this.confirmPrompt("Keypair file not found. Would you like to create a new keypair?");
-    this.keypairManager.createKeypair();
-    return this.keypairManager.getPrivateKey();
+
+    return await this.decryptKeystore(keystoreData);
+  }
+
+  protected async createKeypair(outputPath: string, overwrite: boolean): Promise<string> {
+    const finalOutputPath = this.getFilePath(outputPath);
+    this.stopSpinner();
+
+    if (existsSync(finalOutputPath) && !overwrite) {
+      this.failSpinner(`The file at ${finalOutputPath} already exists. Use the '--overwrite' option to replace it.`);
+      process.exit(1);
+    }
+
+    const wallet = ethers.Wallet.createRandom();
+    
+    const password = await this.promptPassword("Enter a password to encrypt your keystore (minimum 8 characters):");
+    const confirmPassword = await this.promptPassword("Confirm password:");
+
+    if (password !== confirmPassword) {
+      this.failSpinner("Passwords do not match");
+      process.exit(1);
+    }
+
+    if (password.length < 8) {
+      this.failSpinner("Password must be at least 8 characters long");
+      process.exit(1);
+    }
+
+    const encryptedJson = await wallet.encrypt(password);
+    
+    const keystoreData: KeystoreData = {
+      version: 1,
+      encrypted: encryptedJson,
+      address: wallet.address,
+    };
+
+    writeFileSync(finalOutputPath, JSON.stringify(keystoreData, null, 2));
+    this.writeConfig('keyPairPath', finalOutputPath);
+    
+    return wallet.privateKey;
+  }
+
+  protected async promptPassword(message: string): Promise<string> {
+    const answer = await inquirer.prompt([
+      {
+        type: "password",
+        name: "password",
+        message: chalk.yellow(message),
+        mask: "*",
+        validate: (input: string) => {
+          if (!input) {
+            return "Password cannot be empty";
+          }
+          return true;
+        },
+      },
+    ]);
+    return answer.password;
   }
 
   protected async confirmPrompt(message: string): Promise<void> {
@@ -58,13 +156,6 @@ export class BaseAction extends ConfigFileManager {
     }
   }
 
-  private formatOutput(data: any): string {
-    if (typeof data === "string") {
-      return data;
-    }
-    return inspect(data, { depth: null, colors: false });
-  }
-
   protected log(message: string, data?: any): void {
     console.log(chalk.white(`\n${message}`));
     if (data !== undefined) console.log(this.formatOutput(data));

package/src/lib/interfaces/KeystoreData.ts

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

package/tests/actions/appeal.test.ts

@@ -0,0 +1,99 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import type {TransactionHash} from "genlayer-js/types";
+import {AppealAction} from "../../src/commands/transactions/appeal";
+
+vi.mock("genlayer-js");
+
+describe("AppealAction", () => {
+  let appealAction: AppealAction;
+  const mockClient = {
+    appealTransaction: vi.fn(),
+    waitForTransactionReceipt: vi.fn(),
+    initializeConsensusSmartContract: vi.fn(),
+  };
+
+  const mockPrivateKey = "mocked_private_key";
+  const mockTxId = "0x1234567890123456789012345678901234567890123456789012345678901234" as TransactionHash;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(createClient).mockReturnValue(mockClient as any);
+    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
+    appealAction = new AppealAction();
+    vi.spyOn(appealAction as any, "getPrivateKey").mockResolvedValue(mockPrivateKey);
+
+    vi.spyOn(appealAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(appealAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(appealAction as any, "failSpinner").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("calls appealTransaction successfully", async () => {
+    const mockReceipt = {status: "success"};
+
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await appealAction.appeal({
+      txId: mockTxId,
+    });
+
+    expect(mockClient.appealTransaction).toHaveBeenCalledWith({
+      txId: mockTxId,
+    });
+    expect(appealAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Appeal operation successfully executed",
+      mockReceipt,
+    );
+  });
+
+  test("handles appealTransaction errors", async () => {
+    vi.mocked(mockClient.appealTransaction).mockRejectedValue(new Error("Mocked appeal error"));
+
+    await appealAction.appeal({txId: mockTxId});
+
+    expect(appealAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error during appeal operation",
+      expect.any(Error),
+    );
+  });
+
+  test("uses custom RPC URL for appeal operations", async () => {
+    const rpcUrl = "https://custom-rpc-url.com";
+    const mockReceipt = {status: "success"};
+
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await appealAction.appeal({
+      txId: mockTxId,
+      rpc: rpcUrl,
+    });
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: rpcUrl,
+      }),
+    );
+    expect(mockClient.appealTransaction).toHaveBeenCalledWith({
+      txId: mockTxId,
+    });
+    expect(appealAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Appeal operation successfully executed",
+      mockReceipt,
+    );
+  });
+
+  test("initializes consensus smart contract before appeal", async () => {
+    const mockReceipt = {status: "success"};
+
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await appealAction.appeal({txId: mockTxId});
+
+    expect(mockClient.initializeConsensusSmartContract).toHaveBeenCalledTimes(1);
+    expect(mockClient.appealTransaction).toHaveBeenCalled();
+  });
+}); 

package/tests/actions/create.test.ts

@@ -1,67 +1,45 @@
 import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
 import {KeypairCreator} from "../../src/commands/keygen/create";
-import {writeFileSync, existsSync} from "fs";
-import {ethers} from "ethers";
-
-vi.mock("fs");
-
-vi.mock("ethers", () => ({
-  ethers: {
-    Wallet: {
-      createRandom: vi.fn(),
-    },
-  },
-}));
 
 describe("KeypairCreator", () => {
   let keypairCreator: KeypairCreator;
 
-  const mockWallet: any = {
-    address: "0xMockedAddress",
-    privateKey: "0xMockedPrivateKey",
-  };
-
-  const mockKeypairManager = {
-    createKeypair: vi.fn(),
-  };
-
   beforeEach(() => {
     vi.clearAllMocks();
     keypairCreator = new KeypairCreator();
-    (keypairCreator as any).keypairManager = mockKeypairManager;
+    
+    // Mock the BaseAction methods
     vi.spyOn(keypairCreator as any, "startSpinner").mockImplementation(() => {});
     vi.spyOn(keypairCreator as any, "succeedSpinner").mockImplementation(() => {});
     vi.spyOn(keypairCreator as any, "failSpinner").mockImplementation(() => {});
-    vi.spyOn(keypairCreator as any, "writeConfig").mockImplementation(() => {});
-    vi.spyOn(keypairCreator as any, "getFilePath").mockImplementation(fileName => `/mocked/path/${fileName}`);
-    vi.mocked(ethers.Wallet.createRandom).mockReturnValue(mockWallet);
+    vi.spyOn(keypairCreator as any, "createKeypair").mockResolvedValue("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef");
   });
 
   afterEach(() => {
     vi.restoreAllMocks();
   });
 
-  test("successfully creates and saves a keypair", () => {
-    vi.mocked(existsSync).mockReturnValue(false);
+  test("successfully creates and saves an encrypted keystore", async () => {
     const options = {output: "keypair.json", overwrite: false};
 
-    keypairCreator.createKeypairAction(options);
+    await keypairCreator.createKeypairAction(options);
 
-    expect(keypairCreator["startSpinner"]).toHaveBeenCalledWith("Creating keypair...");
-    expect(mockKeypairManager.createKeypair).toHaveBeenCalledWith(options.output, options.overwrite);
+    expect(keypairCreator["startSpinner"]).toHaveBeenCalledWith("Creating encrypted keystore...");
+    expect(keypairCreator["createKeypair"]).toHaveBeenCalledWith(
+      options.output, 
+      options.overwrite
+    );
     expect(keypairCreator["succeedSpinner"]).toHaveBeenCalledWith(
-      "Keypair successfully created and saved to: keypair.json",
+      "Encrypted keystore successfully created and saved to: keypair.json",
     );
   });
 
-  test("handles errors during keypair creation", () => {
+  test("handles errors during keystore creation", async () => {
     const mockError = new Error("Mocked creation error");
-    mockKeypairManager.createKeypair.mockImplementation(() => {
-      throw mockError;
-    });
+    vi.spyOn(keypairCreator as any, "createKeypair").mockRejectedValue(mockError);
 
-    keypairCreator.createKeypairAction({output: "keypair.json", overwrite: true});
+    await keypairCreator.createKeypairAction({output: "keypair.json", overwrite: true});
 
-    expect(keypairCreator["failSpinner"]).toHaveBeenCalledWith("Failed to generate keypair", mockError);
+    expect(keypairCreator["failSpinner"]).toHaveBeenCalledWith("Failed to generate keystore", mockError);
   });
 });

package/tests/commands/appeal.test.ts

@@ -0,0 +1,58 @@
+import {Command} from "commander";
+import {AppealAction} from "../../src/commands/transactions/appeal";
+import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
+import {initializeTransactionsCommands} from "../../src/commands/transactions";
+
+vi.mock("../../src/commands/transactions/appeal");
+
+describe("appeal command", () => {
+  let program: Command;
+  const mockTxId = "0x1234567890123456789012345678901234567890123456789012345678901234";
+
+  beforeEach(() => {
+    program = new Command();
+    initializeTransactionsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("AppealAction.appeal is called with default options", async () => {
+    program.parse(["node", "test", "appeal", mockTxId]);
+    expect(AppealAction).toHaveBeenCalledTimes(1);
+    expect(AppealAction.prototype.appeal).toHaveBeenCalledWith({
+      txId: mockTxId,
+    });
+  });
+
+  test("AppealAction.appeal is called with custom RPC URL", async () => {
+    program.parse([
+      "node",
+      "test",
+      "appeal",
+      mockTxId,
+      "--rpc",
+      "https://custom-rpc-url-for-appeal.com",
+    ]);
+    expect(AppealAction).toHaveBeenCalledTimes(1);
+    expect(AppealAction.prototype.appeal).toHaveBeenCalledWith({
+      txId: mockTxId,
+      rpc: "https://custom-rpc-url-for-appeal.com",
+    });
+  });
+
+  test("AppealAction is instantiated when the appeal command is executed", async () => {
+    program.parse(["node", "test", "appeal", mockTxId]);
+    expect(AppealAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const appealCommand = program.commands.find(cmd => cmd.name() === "appeal");
+    appealCommand?.exitOverride();
+    expect(() =>
+      program.parse(["node", "test", "appeal", mockTxId, "--invalid-option"]),
+    ).toThrowError("error: unknown option '--invalid-option'");
+  });
+}); 

package/tests/index.test.ts

@@ -41,6 +41,10 @@ vi.mock("../src/commands/network", () => ({
   initializeNetworkCommands: vi.fn(),
 }));
 
+vi.mock("../src/commands/transactions", () => ({
+  initializeTransactionsCommands: vi.fn(),
+}));
+
 describe("CLI", () => {
   it("should initialize CLI", () => {
     expect(initializeCLI).not.toThrow();

package/tests/libs/baseAction.test.ts

@@ -4,20 +4,40 @@ import inquirer from "inquirer";
 import ora, {Ora} from "ora";
 import chalk from "chalk";
 import {inspect} from "util";
+import { ethers } from "ethers";
+import { writeFileSync, existsSync, readFileSync } from "fs";
 
 vi.mock("inquirer");
 vi.mock("ora");
+vi.mock("fs");
+vi.mock("ethers");
 
 describe("BaseAction", () => {
   let baseAction: BaseAction;
   let mockSpinner: Ora;
   let consoleSpy: any;
   let consoleErrorSpy: any;
+  let processExitSpy: any;
+
+  const mockKeystoreData = {
+    version: 1,
+    encrypted: '{"address":"test","crypto":{"cipher":"aes-128-ctr"}}',
+    address: "0x1234567890123456789012345678901234567890",
+  };
+
+  const mockWallet = {
+    privateKey: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+    address: "0x1234567890123456789012345678901234567890",
+    encrypt: vi.fn().mockResolvedValue('{"address":"test","crypto":{"cipher":"aes-128-ctr"}}'),
+  };
 
   beforeEach(() => {
     vi.clearAllMocks();
     consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
     consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process exited");
+    });
     mockSpinner = {
       start: vi.fn(),
       stop: vi.fn(),
@@ -27,8 +47,21 @@ describe("BaseAction", () => {
     } as unknown as Ora;
 
     (ora as unknown as Mock).mockReturnValue(mockSpinner);
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify(mockKeystoreData));
+    vi.mocked(writeFileSync).mockImplementation(() => {});
+
+    // Mock ethers
+    vi.mocked(ethers.Wallet.createRandom).mockReturnValue(mockWallet as any);
+    vi.mocked(ethers.Wallet.fromEncryptedJson).mockResolvedValue(mockWallet as any);
 
     baseAction = new BaseAction();
+
+    // Mock config methods
+    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({});
   });
 
   afterEach(() => {
@@ -162,44 +195,216 @@ describe("BaseAction", () => {
     expect((baseAction as any).formatOutput(true)).toBe("true");
   });
 
-  const mockPrivateKey = "mocked_private_key";
+  test("should prompt for password successfully", async () => {
+    const mockPassword = "test-password";
+    vi.mocked(inquirer.prompt).mockResolvedValue({password: mockPassword});
+
+    const result = await baseAction["promptPassword"]("Enter password:");
+    
+    expect(result).toBe(mockPassword);
+    expect(inquirer.prompt).toHaveBeenCalledWith([{
+      type: "password",
+      name: "password",
+      message: chalk.yellow("Enter password:"),
+      mask: "*",
+      validate: expect.any(Function),
+    }]);
+  });
+
+  test("should validate password input is not empty", async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValue({password: "valid-password"});
 
-  beforeEach(() => {
-    baseAction["keypairManager"] = {
-      getPrivateKey: vi.fn(),
-      createKeypair: vi.fn(),
-      getKeypairPath: vi.fn(),
-      setKeypairPath: vi.fn(),
-    } as any;
+    await baseAction["promptPassword"]("Enter password:");
+    
+    const mockCall = vi.mocked(inquirer.prompt).mock.calls[0];
+    const questions = mockCall[0] as any;
+    const validateFn = questions[0].validate;
+    expect(validateFn("")).toBe("Password cannot be empty");
+    expect(validateFn("valid")).toBe(true);
   });
 
-  test("should return private key when it exists", async () => {
-    vi.mocked(baseAction["keypairManager"].getPrivateKey).mockReturnValue(mockPrivateKey);
+  test("should return private key when keystore exists and is valid", async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValue({password: "correct-password"});
 
     const result = await baseAction["getPrivateKey"]();
 
-    expect(result).toBe(mockPrivateKey);
-    expect(baseAction["keypairManager"].createKeypair).not.toHaveBeenCalled();
+    expect(result).toBe(mockWallet.privateKey);
+    expect(existsSync).toHaveBeenCalledWith("./test-keypair.json");
+    expect(readFileSync).toHaveBeenCalledWith("./test-keypair.json", "utf-8");
   });
 
-  test("should create new keypair when private key doesn't exist and user confirms", async () => {
-    vi.mocked(baseAction["keypairManager"].getPrivateKey)
-      .mockReturnValueOnce(undefined)
-      .mockReturnValueOnce(mockPrivateKey);
-    vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: true});
-    await baseAction["getPrivateKey"]();
+  test("should create new keypair when keystore file does not exist", async () => {
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({confirmAction: true}) // confirm create new
+      .mockResolvedValueOnce({password: "new-password"}) // encrypt password
+      .mockResolvedValueOnce({password: "new-password"}); // confirm password
 
-    expect(baseAction["keypairManager"].createKeypair).toHaveBeenCalled();
+    const result = await baseAction["getPrivateKey"]();
+
+    expect(result).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?")})
+    ]));
   });
 
-  test("should exit when private key doesn't exist and user declines", async () => {
-    vi.mocked(baseAction["keypairManager"].getPrivateKey).mockReturnValueOnce(undefined);
+  test("should fail when keystore format is invalid and user declines", async () => {
+    vi.mocked(readFileSync).mockReturnValue('{"invalid": "format"}');
     vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: false});
-    vi.spyOn(process, "exit").mockImplementation(() => {
-      throw new Error("process exited");
-    });
 
     await expect(baseAction["getPrivateKey"]()).rejects.toThrow("process exited");
+    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Invalid keystore format. Expected encrypted keystore file."));
+  });
+
+  test("should create new keypair when keystore format is invalid and user confirms", async () => {
+    vi.mocked(readFileSync).mockReturnValue('{"invalid": "format"}');
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({confirmAction: true})
+      .mockResolvedValueOnce({password: "new-password"})
+      .mockResolvedValueOnce({password: "new-password"});
+
+    const result = await baseAction["getPrivateKey"]();
+
+    expect(result).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?")})
+    ]));
+  });
+
+  test("should decrypt keystore successfully on first attempt", async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValue({password: "correct-password"});
+
+    const result = await baseAction["decryptKeystore"](mockKeystoreData);
+
+    expect(result).toBe(mockWallet.privateKey);
+    expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
+      expect.objectContaining({message: chalk.yellow("Enter password to decrypt keystore:")})
+    ]));
+  });
+
+  test("should retry on wrong password and succeed on second attempt", async () => {
+    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);
+
+    expect(result).toBe(mockWallet.privateKey);
+    expect(inquirer.prompt).toHaveBeenCalledTimes(2);
+    expect(inquirer.prompt).toHaveBeenNthCalledWith(2, expect.arrayContaining([
+      expect.objectContaining({message: chalk.yellow("Invalid password. Attempt 2/3 - Enter password to decrypt keystore:")})
+    ]));
+  });
+
+  test("should exit after 3 failed password attempts", async () => {
+    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");
+    
+    expect(inquirer.prompt).toHaveBeenCalledTimes(3);
+    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Maximum password attempts exceeded (3/3)."));
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test("should create new keypair successfully", async () => {
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({password: "test-password"})
+      .mockResolvedValueOnce({password: "test-password"});
+
+    const result = await baseAction["createKeypair"]("./new-keypair.json", false);
+
+    expect(result).toBe(mockWallet.privateKey);
+    expect(ethers.Wallet.createRandom).toHaveBeenCalled();
+    expect(mockWallet.encrypt).toHaveBeenCalledWith("test-password");
+    expect(writeFileSync).toHaveBeenCalled();
+  });
+
+  test("should fail when file exists and overwrite is false", async () => {
+    vi.mocked(existsSync).mockReturnValue(true);
+
+    await expect(baseAction["createKeypair"]("./test-keypair.json", 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.")
+    );
+  });
+
+  test("should fail when passwords do not match", async () => {
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({password: "password1"})
+      .mockResolvedValueOnce({password: "password2"});
+
+    await expect(baseAction["createKeypair"]("./new-keypair.json", false)).rejects.toThrow("process exited");
+    
+    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Passwords do not match"));
+  });
+
+  test("should fail when password is too short", async () => {
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({password: "short"})
+      .mockResolvedValueOnce({password: "short"});
+
+    await expect(baseAction["createKeypair"]("./new-keypair.json", 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 () => {
+    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);
+
+    expect(result).toBe(mockWallet.privateKey);
+    expect(writeFileSync).toHaveBeenCalled();
+  });
+
+  test("should return true for valid keystore format", () => {
+    const validKeystore = {
+      version: 1,
+      encrypted: "encrypted-data",
+      address: "0x1234567890123456789012345678901234567890",
+    };
+
+    const result = baseAction["isValidKeystoreFormat"](validKeystore);
+    expect(result).toBe(true);
+  });
+
+  test("should return false for invalid keystore version", () => {
+    const invalidKeystore = {
+      version: 2,
+      encrypted: "encrypted-data",
+      address: "0x1234567890123456789012345678901234567890",
+    };
+
+    const result = baseAction["isValidKeystoreFormat"](invalidKeystore);
+    expect(result).toBe(false);
+  });
+
+  test("should return false for keystore missing fields", () => {
+    const invalidKeystore = {
+      version: 1,
+      encrypted: "encrypted-data",
+    };
+
+    const result = baseAction["isValidKeystoreFormat"](invalidKeystore);
+    expect(result).toBe(false);
+  });
+
+  test("should return false for null or undefined keystore", () => {
+    expect(baseAction["isValidKeystoreFormat"](null)).toBe(false);
+    expect(baseAction["isValidKeystoreFormat"](undefined)).toBe(false);
   });
 
   describe("formatOutput", () => {

package/src/lib/accounts/KeypairManager.ts

@@ -1,43 +0,0 @@
-import { writeFileSync, existsSync, readFileSync } from "fs";
-import { ethers } from "ethers";
-import path from "path";
-import { ConfigFileManager } from "../config/ConfigFileManager";
-
-export class KeypairManager extends ConfigFileManager {
-  constructor() {
-    super();
-  }
-
-  getPrivateKey(): string | undefined {
-    const keypairPath = this.getConfigByKey("keyPairPath");
-
-    if (!keypairPath || !existsSync(keypairPath)) {
-      return ""
-    }
-
-    const keypairData = JSON.parse(readFileSync(keypairPath, "utf-8"));
-
-    if (!keypairData.privateKey) {
-      return ""
-    }
-
-    return keypairData.privateKey;
-  }
-
-  createKeypair(outputPath = "./keypair.json", overwrite: boolean = false): void {
-    const finalOutputPath = this.getFilePath(outputPath);
-
-    if(existsSync(finalOutputPath) && !overwrite) {
-      throw new Error(`The file at ${finalOutputPath} already exists. Use the '--overwrite' option to replace it.`);
-    }
-
-    const wallet = ethers.Wallet.createRandom();
-    const keypairData = {
-      address: wallet.address,
-      privateKey: wallet.privateKey,
-    };
-
-    writeFileSync(finalOutputPath, JSON.stringify(keypairData, null, 2));
-    this.writeConfig('keyPairPath', finalOutputPath);
-  }
-} 

package/tests/libs/accounts/KeypairManager.test.ts

@@ -1,110 +0,0 @@
-import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
-import { writeFileSync, existsSync, readFileSync } from "fs";
-import { ethers } from "ethers";
-import { KeypairManager } from "../../../src/lib/accounts/KeypairManager";
-
-vi.mock("fs");
-vi.mock("ethers");
-
-describe("KeypairManager", () => {
-  let keypairManager: KeypairManager;
-  const mockPrivateKey = "0xMockedPrivateKey";
-  const mockAddress = "0xMockedAddress";
-  const mockKeypairPath = "/mocked/path/keypair.json";
-  const mockKeypairData = {
-    address: mockAddress,
-    privateKey: mockPrivateKey,
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    keypairManager = new KeypairManager();
-    vi.spyOn(keypairManager as any, "getConfigByKey").mockReturnValue(mockKeypairPath);
-    vi.spyOn(keypairManager as any, "writeConfig").mockImplementation(() => {});
-    vi.spyOn(keypairManager as any, "getFilePath").mockReturnValue(mockKeypairPath);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe("getPrivateKey", () => {
-    test("should return private key when keypair file exists and contains private key", () => {
-      vi.mocked(existsSync).mockReturnValue(true);
-      vi.mocked(readFileSync).mockReturnValue(JSON.stringify(mockKeypairData));
-
-      const result = keypairManager.getPrivateKey();
-
-      expect(result).toBe(mockPrivateKey);
-      expect(existsSync).toHaveBeenCalledWith(mockKeypairPath);
-      expect(readFileSync).toHaveBeenCalledWith(mockKeypairPath, "utf-8");
-    });
-
-    test("should return empty string when keypair file does not exist", () => {
-      vi.mocked(existsSync).mockReturnValue(false);
-
-      const result = keypairManager.getPrivateKey();
-
-      expect(result).toBe("");
-      expect(existsSync).toHaveBeenCalledWith(mockKeypairPath);
-      expect(readFileSync).not.toHaveBeenCalled();
-    });
-
-    test("should return empty string when keypair file exists but has no private key", () => {
-      vi.mocked(existsSync).mockReturnValue(true);
-      vi.mocked(readFileSync).mockReturnValue(JSON.stringify({ address: mockAddress }));
-
-      const result = keypairManager.getPrivateKey();
-
-      expect(result).toBe("");
-      expect(existsSync).toHaveBeenCalledWith(mockKeypairPath);
-      expect(readFileSync).toHaveBeenCalledWith(mockKeypairPath, "utf-8");
-    });
-  });
-
-  describe("createKeypair", () => {
-    test("should create new keypair and save it to file", () => {
-      const mockWallet = {
-        address: mockAddress,
-        privateKey: mockPrivateKey,
-      };
-      vi.mocked(ethers.Wallet.createRandom).mockReturnValue(mockWallet as any);
-      vi.mocked(existsSync).mockReturnValue(false);
-
-      keypairManager.createKeypair();
-
-      expect(ethers.Wallet.createRandom).toHaveBeenCalled();
-      expect(writeFileSync).toHaveBeenCalledWith(
-        mockKeypairPath,
-        JSON.stringify(mockKeypairData, null, 2)
-      );
-      expect(keypairManager["writeConfig"]).toHaveBeenCalledWith("keyPairPath", mockKeypairPath);
-    });
-
-    test("should throw error when file exists and overwrite is false", () => {
-      vi.mocked(existsSync).mockReturnValue(true);
-
-      expect(() => keypairManager.createKeypair()).toThrow(
-        `The file at ${mockKeypairPath} already exists. Use the '--overwrite' option to replace it.`
-      );
-    });
-
-    test("should overwrite existing file when overwrite is true", () => {
-      const mockWallet = {
-        address: mockAddress,
-        privateKey: mockPrivateKey,
-      };
-      vi.mocked(ethers.Wallet.createRandom).mockReturnValue(mockWallet as any);
-      vi.mocked(existsSync).mockReturnValue(true);
-
-      keypairManager.createKeypair("./keypair.json", true);
-
-      expect(ethers.Wallet.createRandom).toHaveBeenCalled();
-      expect(writeFileSync).toHaveBeenCalledWith(
-        mockKeypairPath,
-        JSON.stringify(mockKeypairData, null, 2)
-      );
-      expect(keypairManager["writeConfig"]).toHaveBeenCalledWith("keyPairPath", mockKeypairPath);
-    });
-  });
-});