genlayer 0.5.1-beta.0 → 0.7.0

package/docker-compose.yml

@@ -2,7 +2,7 @@ version: "3.8"
 
 services:
   frontend:
-    image: yeagerai/simulator-frontend:latest
+    image: yeagerai/simulator-frontend:${LOCALNETVERSION:-latest}
     ports:
       - "${FRONTEND_PORT:-8080}:8080"
     environment:
@@ -25,7 +25,7 @@ services:
 
 
   jsonrpc:
-    image: yeagerai/simulator-jsonrpc:latest
+    image: yeagerai/simulator-jsonrpc:${LOCALNETVERSION:-latest}
     environment:
       - FLASK_SERVER_PORT=${RPCPORT:-5000}
       - PYTHONUNBUFFERED=1
@@ -63,7 +63,7 @@ services:
       replicas: ${JSONRPC_REPLICAS:-1}
 
   webrequest:
-    image: yeagerai/simulator-webrequest:latest
+    image: yeagerai/simulator-webrequest:${LOCALNETVERSION:-latest}
     shm_size: 2gb
     environment:
       - FLASK_SERVER_PORT=${WEBREQUESTPORT:-5002}
@@ -131,7 +131,7 @@ services:
     #   - "./data/postgres:/var/lib/postgresql/data"
 
   database-migration:
-    image: yeagerai/simulator-database-migration:latest
+    image: yeagerai/simulator-database-migration:${LOCALNETVERSION:-latest}
     environment:
       - DB_URL=postgresql://${DBUSER:-postgres}:${DBPASSWORD:-postgres}@postgres/${DBNAME:-simulator_db}
       - WEBREQUESTPORT=${WEBREQUESTPORT:-5002}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.5.1-beta.0",
+  "version": "0.7.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
@@ -12,6 +11,7 @@ export function initializeGeneralCommands(program: Command) {
     .option("--numValidators <numValidators>", "Number of validators", "5")
     .option("--headless", "Headless mode", false)
     .option("--reset-db", "Reset Database", false)
+    .option("--localnet-version <localnetVersion>", "Select a specific localnet version", 'latest')
     .action((options: InitActionOptions) => initAction(options, simulatorService));
 
   program

package/src/commands/general/init.ts

@@ -6,6 +6,7 @@ export interface InitActionOptions {
   numValidators: number;
   headless: boolean;
   resetDb: boolean;
+  localnetVersion: string;
 }
 
 function getRequirementsErrorMessage({docker}: Record<string, boolean>): string {
@@ -34,6 +35,11 @@ function getVersionErrorMessage({docker, node}: Record<string, string>): string
 export async function initAction(options: InitActionOptions, simulatorService: ISimulatorService) {
   simulatorService.setComposeOptions(options.headless);
 
+  let localnetVersion = options.localnetVersion;
+
+  if(localnetVersion !== 'latest'){
+    localnetVersion = simulatorService.normalizeLocalnetVersion(localnetVersion);
+  }
   await simulatorService.checkCliVersion();
 
   // Check if requirements are installed
@@ -139,6 +145,7 @@ export async function initAction(options: InitActionOptions, simulatorService: I
 
   console.log("Configuring GenLayer Simulator environment...");
   simulatorService.addConfigToEnvFile(aiProvidersEnvVars);
+  simulatorService.addConfigToEnvFile({LOCALNETVERSION: localnetVersion});
 
 
   // Run the GenLayer Simulator

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/src/lib/interfaces/ISimulatorService.ts

@@ -18,6 +18,7 @@ export interface ISimulatorService {
   checkCliVersion(): Promise<void>;
   cleanDatabase(): Promise<boolean>;
   addConfigToEnvFile(newConfig: Record<string, string>): void;
+  normalizeLocalnetVersion(version: string): string;
 }
 
 

package/src/lib/services/simulator.ts

@@ -295,6 +295,23 @@ export class SimulatorService implements ISimulatorService {
     return true;
   }
 
+  public normalizeLocalnetVersion(version: string) {
+
+    if (!version.startsWith('v')) {
+      version = 'v' + version;
+    }
+
+    const versionRegex = /^v(\d+)\.(\d+)\.(\d+)(-.+)?$/;
+    const match = version.match(versionRegex);
+
+    if (!match) {
+      console.error('Invalid version format. Expected format: v0.0.0 or v0.0.0-suffix');
+      process.exit(1);
+    }
+
+    return version
+  }
+
 }
 
 export default new SimulatorService();

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/actions/init.test.ts

@@ -14,7 +14,7 @@ vi.mock("dotenv");
 
 
 const tempDir = mkdtempSync(join(tmpdir(), "test-initAction-"));
-const defaultActionOptions = { numValidators: 5, branch: "main", location: tempDir, headless: false, resetDb: false };
+const defaultActionOptions = { numValidators: 5, branch: "main", location: tempDir, headless: false, resetDb: false, localnetVersion: 'latest' };
 
 describe("init action", () => {
   let error: ReturnType<any>;
@@ -201,7 +201,7 @@ describe("init action", () => {
     simServResetDockerContainers.mockResolvedValue(true);
     simServResetDockerImages.mockResolvedValue(true);
 
-    await initAction({...defaultActionOptions, headless: true, resetDb: true}, simulatorService);
+    await initAction({...defaultActionOptions, headless: true, resetDb: true, localnetVersion: "v1.0.0"}, simulatorService);
 
     expect(log).toHaveBeenCalledWith(
       `GenLayer simulator initialized successfully! `
@@ -441,4 +441,5 @@ describe("init action", () => {
 
     expect(error).toHaveBeenCalledWith(errorMsg);
   });
+
 });

package/tests/commands/init.test.ts

@@ -8,7 +8,8 @@ const openFrontendSpy = vi.spyOn(simulatorService, "openFrontend");
 const defaultOptions = {
   numValidators: "5",
   headless: false,
-  resetDb: false
+  resetDb: false,
+  localnetVersion: 'latest'
 }
 
 vi.mock("inquirer", () => ({
@@ -73,4 +74,11 @@ describe("init command", () => {
     expect(action).toHaveBeenCalledWith({...defaultOptions, headless: true});
     expect(openFrontendSpy).not.toHaveBeenCalled();
   });
+
+  test("option --localnet-version is accepted", async () => {
+    program.parse(["node", "test", "init", "--localnet-version", "v1.0.0"]);
+    expect(action).toHaveBeenCalledTimes(1);
+    expect(action).toHaveBeenCalledWith({...defaultOptions, localnetVersion: "v1.0.0"});
+    expect(openFrontendSpy).not.toHaveBeenCalled();
+  });
 });

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