genlayer 0.5.1-beta.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.5.1-beta.0",
+  "version": "0.6.0",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {
@@ -59,6 +59,7 @@
     "commander": "^12.0.0",
     "dockerode": "^4.0.2",
     "dotenv": "^16.4.5",
+    "ethers": "^6.13.4",
     "inquirer": "^9.2.19",
     "node-fetch": "^2.7.0",
     "open": "^10.1.0",

package/src/commands/general/index.ts

@@ -1,9 +1,8 @@
-import {Command} from "commander";
+import { Command } from "commander";
 
 import simulatorService from "../../lib/services/simulator";
-
-import {initAction, InitActionOptions} from "./init";
-import {startAction, StartActionOptions} from "./start";
+import { initAction, InitActionOptions } from "./init";
+import { startAction, StartActionOptions } from "./start";
 
 export function initializeGeneralCommands(program: Command) {
   program

package/src/commands/keygen/create.ts

@@ -0,0 +1,44 @@
+import { writeFileSync, existsSync } from "fs";
+import { ethers } from "ethers";
+import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
+
+export interface CreateKeypairOptions {
+  output: string;
+  overwrite: boolean;
+}
+
+export class KeypairCreator {
+  private filePathManager: ConfigFileManager;
+
+  constructor() {
+    this.filePathManager = new ConfigFileManager();
+  }
+
+  createKeypairAction(options: CreateKeypairOptions) {
+    try {
+
+      const outputPath = this.filePathManager.getFilePath(options.output);
+
+      if(existsSync(outputPath) && !options.overwrite) {
+        console.warn(
+          `The file at ${outputPath} already exists. Use the '--overwrite' option to replace it.`
+        );
+        return;
+      }
+
+      const wallet = ethers.Wallet.createRandom();
+      const keypairData = {
+        address: wallet.address,
+        privateKey: wallet.privateKey,
+      };
+
+      writeFileSync(outputPath, JSON.stringify(keypairData, null, 2));
+
+      this.filePathManager.writeConfig('keyPairPath', outputPath);
+      console.log(`Keypair successfully created and saved to: ${outputPath}`);
+    } catch (error) {
+      console.error("Failed to generate keypair:", error);
+      process.exit(1);
+    }
+  }
+}

package/src/commands/keygen/index.ts

@@ -0,0 +1,21 @@
+import { Command } from "commander";
+import { CreateKeypairOptions, KeypairCreator } from "./create";
+
+export function initializeKeygenCommands(program: Command) {
+
+  const keygenCommand = program
+    .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: CreateKeypairOptions) => {
+      const keypairCreator = new KeypairCreator();
+      keypairCreator.createKeypairAction(options);
+    });
+
+  return program;
+}

package/src/index.ts

@@ -2,11 +2,13 @@
 import {program} from "commander";
 import {version} from "../package.json";
 import {CLI_DESCRIPTION} from "../src/lib/config/text";
-import {initializeGeneralCommands} from "../src/commands/general";
+import { initializeGeneralCommands } from "../src/commands/general";
+import { initializeKeygenCommands } from "../src/commands/keygen";
 
 export function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
   initializeGeneralCommands(program);
+  initializeKeygenCommands(program);
   program.parse(process.argv);
 }
 

package/src/lib/config/ConfigFileManager.ts

@@ -0,0 +1,51 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+export class ConfigFileManager {
+  private folderPath: string;
+  private configFilePath: string;
+
+  constructor(baseFolder: string = ".genlayer/", configFileName: string = "genlayer-config.json") {
+    this.folderPath = path.resolve(os.homedir(), baseFolder);
+    this.configFilePath = path.resolve(this.folderPath, configFileName);
+    this.ensureFolderExists();
+    this.ensureConfigFileExists();
+  }
+
+  private ensureFolderExists(): void {
+    if (!fs.existsSync(this.folderPath)) {
+      fs.mkdirSync(this.folderPath, { recursive: true });
+    }
+  }
+
+  private ensureConfigFileExists(): void {
+    if (!fs.existsSync(this.configFilePath)) {
+      fs.writeFileSync(this.configFilePath, JSON.stringify({}, null, 2));
+    }
+  }
+
+  getFolderPath(): string {
+    return this.folderPath;
+  }
+
+  getFilePath(fileName: string): string {
+    return path.resolve(this.folderPath, fileName);
+  }
+
+  getConfig(): Record<string, any> {
+    const configContent = fs.readFileSync(this.configFilePath, "utf-8");
+    return JSON.parse(configContent);
+  }
+
+  getConfigByKey(key: string): any {
+    const config = this.getConfig();
+    return config[key] !== undefined ? config[key] : null;
+  }
+
+  writeConfig(key: string, value: any): void {
+    const config = this.getConfig();
+    config[key] = value;
+    fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
+  }
+}

package/tests/actions/create.test.ts

@@ -0,0 +1,140 @@
+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(),
+    },
+  },
+}));
+
+vi.mock("../../src/lib/config/ConfigFileManager", () => ({
+  ConfigFileManager: vi.fn().mockImplementation(() => ({
+    getFilePath: vi.fn((fileName) => `/mocked/path/${fileName}`),
+    writeConfig: vi.fn(),
+  })),
+}));
+
+describe("KeypairCreator", () => {
+  let keypairCreator: KeypairCreator;
+
+  const mockWallet: any = {
+    address: "0xMockedAddress",
+    privateKey: "0xMockedPrivateKey",
+  };
+  keypairCreator = new KeypairCreator();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(ethers.Wallet.createRandom).mockReturnValue(mockWallet);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("successfully creates and saves a keypair", () => {
+    const consoleLogSpy = vi.spyOn(console, "log");
+    vi.mocked(existsSync).mockReturnValue(false);
+    const options = { output: "keypair.json", overwrite: false };
+
+    keypairCreator.createKeypairAction(options);
+
+    expect(ethers.Wallet.createRandom).toHaveBeenCalledTimes(1);
+
+    expect(keypairCreator["filePathManager"].getFilePath).toHaveBeenCalledWith("keypair.json");
+
+    expect(writeFileSync).toHaveBeenCalledWith(
+      "/mocked/path/keypair.json",
+      JSON.stringify(
+        {
+          address: mockWallet.address,
+          privateKey: mockWallet.privateKey,
+        },
+        null,
+        2
+      )
+    );
+
+    expect(keypairCreator["filePathManager"].writeConfig).toHaveBeenCalledWith(
+      "keyPairPath",
+      "/mocked/path/keypair.json"
+    );
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      "Keypair successfully created and saved to: /mocked/path/keypair.json"
+    );
+  });
+
+  test("skips creation if file exists and overwrite is false", () => {
+
+
+    const consoleWarnSpy = vi.spyOn(console, "warn");
+    vi.mocked(existsSync).mockReturnValue(true);
+    const options = { output: "keypair.json", overwrite: false };
+
+    keypairCreator.createKeypairAction(options);
+
+    expect(ethers.Wallet.createRandom).not.toHaveBeenCalled();
+    expect(writeFileSync).not.toHaveBeenCalled();
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      "The file at /mocked/path/keypair.json already exists. Use the '--overwrite' option to replace it."
+    );
+  });
+
+  test("overwrites the file if overwrite is true", () => {
+    const consoleLogSpy = vi.spyOn(console, "log");
+    vi.mocked(existsSync).mockReturnValue(true); // Simulate file exists
+    const options = { output: "keypair.json", overwrite: true };
+
+    keypairCreator.createKeypairAction(options);
+
+    expect(ethers.Wallet.createRandom).toHaveBeenCalledTimes(1);
+
+    expect(keypairCreator["filePathManager"].getFilePath).toHaveBeenCalledWith("keypair.json");
+
+    expect(writeFileSync).toHaveBeenCalledWith(
+      "/mocked/path/keypair.json",
+      JSON.stringify(
+        {
+          address: mockWallet.address,
+          privateKey: mockWallet.privateKey,
+        },
+        null,
+        2
+      )
+    );
+
+    expect(keypairCreator["filePathManager"].writeConfig).toHaveBeenCalledWith(
+      "keyPairPath",
+      "/mocked/path/keypair.json"
+    );
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      "Keypair successfully created and saved to: /mocked/path/keypair.json"
+    );
+  });
+
+  test("handles errors during keypair creation", () => {
+    const consoleErrorSpy = vi.spyOn(console, "error");
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+
+    vi.mocked(writeFileSync).mockImplementation(() => {
+      throw new Error("Mocked write error");
+    });
+
+    expect(() => {
+      keypairCreator.createKeypairAction({ output: "keypair.json", overwrite: true });
+    }).toThrowError("process.exit");
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to generate keypair:", expect.any(Error));
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+});

package/tests/commands/keygen.test.ts

@@ -0,0 +1,77 @@
+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";
+
+vi.mock("../../src/commands/keygen/create");
+
+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("throws error for unrecognized options", async () => {
+    const keygenCommand = program.commands.find((cmd) => cmd.name() === "keygen");
+    const createCommand = keygenCommand?.commands.find((cmd) => cmd.name() === "create");
+
+    createCommand?.exitOverride();
+    expect(() => program.parse(["node", "test", "keygen", "create", "--unknown"])).toThrowError(
+      "error: unknown option '--unknown'"
+    );
+  });
+
+  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();
+  });
+});

package/tests/index.test.ts

@@ -13,6 +13,10 @@ vi.mock("../src/commands/general", () => ({
   initializeGeneralCommands: vi.fn(),
 }));
 
+vi.mock("../src/commands/keygen", () => ({
+  initializeKeygenCommands: vi.fn(),
+}));
+
 
 describe("CLI", () => {
   it("should initialize CLI", () => {

package/tests/libs/configFileManager.test.ts

@@ -0,0 +1,113 @@
+import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import { ConfigFileManager } from "../../src/lib/config/ConfigFileManager";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+vi.mock("fs");
+
+vi.mock("os")
+
+describe("ConfigFileManager", () => {
+  const mockFolderPath = "/mocked/home/.genlayer";
+  const mockConfigFilePath = `${mockFolderPath}/genlayer-config.json`;
+
+  let configFileManager: ConfigFileManager;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    configFileManager = new ConfigFileManager();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("ensures folder and config file are created if they don't exist", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    new ConfigFileManager();
+
+    expect(fs.existsSync).toHaveBeenCalledWith(mockFolderPath);
+    expect(fs.mkdirSync).toHaveBeenCalledWith(mockFolderPath, { recursive: true });
+
+    expect(fs.existsSync).toHaveBeenCalledWith(mockConfigFilePath);
+    expect(fs.writeFileSync).toHaveBeenCalledWith(mockConfigFilePath, JSON.stringify({}, null, 2));
+  });
+
+  test("does not recreate folder or config file if they exist", () => {
+    vi.clearAllMocks();
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    new ConfigFileManager();
+
+    expect(fs.mkdirSync).not.toHaveBeenCalled();
+    expect(fs.writeFileSync).not.toHaveBeenCalled();
+  });
+
+  test("getFolderPath returns the correct folder path", () => {
+    expect(configFileManager.getFolderPath()).toBe(mockFolderPath);
+  });
+
+  test("getFilePath returns the correct file path for a given file name", () => {
+    const fileName = "example.json";
+    const expectedFilePath = path.resolve(mockFolderPath, fileName);
+
+    expect(configFileManager.getFilePath(fileName)).toBe(expectedFilePath);
+  });
+
+  test("getConfig returns the parsed content of the config file", () => {
+    const mockConfig = { key: "value" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+    const config = configFileManager.getConfig();
+
+    expect(fs.readFileSync).toHaveBeenCalledWith(mockConfigFilePath, "utf-8");
+    expect(config).toEqual(mockConfig);
+  });
+
+  test("getConfigByKey returns the value for a given key", () => {
+    const mockConfig = { key: "value" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+    const value = configFileManager.getConfigByKey("key");
+
+    expect(value).toBe("value");
+  });
+
+  test("getConfigByKey returns null for a non-existing key", () => {
+    const mockConfig = { key: "value" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+    const value = configFileManager.getConfigByKey("nonExistingKey");
+
+    expect(value).toBeNull();
+  });
+
+  test("writeConfig updates the config file with a new key-value pair", () => {
+    const mockConfig = { existingKey: "existingValue" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+    configFileManager.writeConfig("newKey", "newValue");
+
+    const expectedConfig = { existingKey: "existingValue", newKey: "newValue" };
+    expect(fs.writeFileSync).toHaveBeenCalledWith(
+      mockConfigFilePath,
+      JSON.stringify(expectedConfig, null, 2)
+    );
+  });
+
+  test("writeConfig overwrites an existing key in the config file", () => {
+    const mockConfig = { existingKey: "existingValue" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+    configFileManager.writeConfig("existingKey", "updatedValue");
+
+    const expectedConfig = { existingKey: "updatedValue" };
+    expect(fs.writeFileSync).toHaveBeenCalledWith(
+      mockConfigFilePath,
+      JSON.stringify(expectedConfig, null, 2)
+    );
+  });
+});