genlayer 0.0.30 → 0.0.32-beta.0

package/src/lib/services/simulator.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import * as dotenv from "dotenv";
 import * as path from "path";
 
-import {rpcClient} from "@/lib/clients/jsonRpcClient";
+import {rpcClient} from "../clients/jsonRpcClient";
 import {
   DEFAULT_REPO_GH_URL,
   DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX,
@@ -13,7 +13,7 @@ import {
   STARTING_TIMEOUT_ATTEMPTS,
   AI_PROVIDERS_CONFIG,
   AiProviders,
-} from "@/lib/config/simulator";
+} from "../config/simulator";
 import {
   checkCommand,
   getHomeDirectory,
@@ -24,242 +24,253 @@ import {
   removeDockerContainer,
   listDockerImages,
   removeDockerImage,
-} from "@/lib/clients/system";
+} from "../clients/system";
 import {MissingRequirementError} from "../errors/missingRequirement";
 
-// Private helper functions
-export function getSimulatorLocation(): string {
-  return path.join(getHomeDirectory(), "genlayer-simulator");
-}
-
-export function readEnvConfigValue(key: string): string {
-  const simulatorLocation = getSimulatorLocation();
-  const envFilePath = path.join(simulatorLocation, ".env");
-  // Transform the config string to object
-  const envConfig = dotenv.parse(fs.readFileSync(envFilePath, "utf8"));
-  return envConfig[key];
-}
+import {
+  ISimulatorService,
+  DownloadSimulatorResultType,
+  WaitForSimulatorToBeReadyResultType,
+  InitializeDatabaseResultType,
+} from "../interfaces/ISimulatorService";
 
 function sleep(millliseconds: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, millliseconds));
 }
 
-function addConfigToEnvFile(newConfig: Record<string, string>): void {
-  const simulatorLocation = getSimulatorLocation();
-  const envFilePath = path.join(simulatorLocation, ".env");
+export class SimulatorService implements ISimulatorService {
+  public getSimulatorLocation(): string {
+    return path.join(getHomeDirectory(), "genlayer-simulator");
+  }
 
-  // Create a backup of the original .env file
-  fs.writeFileSync(`${envFilePath}.bak`, fs.readFileSync(envFilePath));
+  public readEnvConfigValue(key: string): string {
+    const simulatorLocation = this.getSimulatorLocation();
+    const envFilePath = path.join(simulatorLocation, ".env");
+    // Transform the config string to object
+    const envConfig = dotenv.parse(fs.readFileSync(envFilePath, "utf8"));
+    return envConfig[key];
+  }
 
-  // Transform the config string to object
-  const envConfig = dotenv.parse(fs.readFileSync(envFilePath, "utf8"));
-  Object.keys(newConfig).forEach(key => {
-    envConfig[key] = newConfig[key];
-  });
+  public addConfigToEnvFile(newConfig: Record<string, string>): void {
+    const simulatorLocation = this.getSimulatorLocation();
+    const envFilePath = path.join(simulatorLocation, ".env");
 
-  // Transform the updated config object back into a string
-  const updatedConfig = Object.keys(envConfig)
-    .map(key => {
-      return `${key}=${envConfig[key]}`;
-    })
-    .join("\n");
+    // Create a backup of the original .env file
+    fs.writeFileSync(`${envFilePath}.bak`, fs.readFileSync(envFilePath));
 
-  // Write the new .env file
-  fs.writeFileSync(envFilePath, updatedConfig);
-}
+    // Transform the config string to object
+    const envConfig = dotenv.parse(fs.readFileSync(envFilePath, "utf8"));
+    Object.keys(newConfig).forEach(key => {
+      envConfig[key] = newConfig[key];
+    });
 
-// Public functions
-export async function checkRequirements(): Promise<Record<string, boolean>> {
-  const requirementsInstalled = {
-    git: false,
-    docker: false,
-  };
-
-  try {
-    await checkCommand("git --version", "git");
-    requirementsInstalled.git = true;
-  } catch (error) {
-    if (!(error instanceof MissingRequirementError)) {
-      throw error;
-    }
-  }
-  try {
-    await checkCommand("docker --version", "docker");
-    requirementsInstalled.docker = true;
-  } catch (error: any) {
-    if (!(error instanceof MissingRequirementError)) {
-      throw error;
-    }
+    // Transform the updated config object back into a string
+    const updatedConfig = Object.keys(envConfig)
+      .map(key => {
+        return `${key}=${envConfig[key]}`;
+      })
+      .join("\n");
+
+    // Write the new .env file
+    fs.writeFileSync(envFilePath, updatedConfig);
   }
 
-  if (requirementsInstalled.docker) {
+  public async checkRequirements(): Promise<Record<string, boolean>> {
+    const requirementsInstalled = {
+      git: false,
+      docker: false,
+    };
+
     try {
-      await checkCommand("docker ps", "docker");
+      await checkCommand("git --version", "git");
+      requirementsInstalled.git = true;
+    } catch (error) {
+      if (!(error instanceof MissingRequirementError)) {
+        throw error;
+      }
+    }
+    try {
+      await checkCommand("docker --version", "docker");
+      requirementsInstalled.docker = true;
     } catch (error: any) {
-      await executeCommand(DEFAULT_RUN_DOCKER_COMMAND);
+      if (!(error instanceof MissingRequirementError)) {
+        throw error;
+      }
+    }
+
+    if (requirementsInstalled.docker) {
+      try {
+        await checkCommand("docker ps", "docker");
+      } catch (error: any) {
+        await executeCommand(DEFAULT_RUN_DOCKER_COMMAND);
+      }
     }
+
+    return requirementsInstalled;
   }
 
-  return requirementsInstalled;
-}
+  public async downloadSimulator(branch: string = "main"): Promise<DownloadSimulatorResultType> {
+    const simulatorLocation = this.getSimulatorLocation();
 
-type DownloadSimulatorResultType = {
-  wasInstalled: boolean;
-};
-
-export async function downloadSimulator(): Promise<DownloadSimulatorResultType> {
-  const simulatorLocation = getSimulatorLocation();
-
-  try {
-    const gitCommand = `git clone ${DEFAULT_REPO_GH_URL} ${simulatorLocation}`;
-    const cmdsByPlatform = {darwin: gitCommand, win32: gitCommand, linux: gitCommand};
-    await executeCommand(cmdsByPlatform, "git");
-  } catch (error: any) {
-    const simulatorLocationExists = fs.existsSync(simulatorLocation);
-    if (simulatorLocationExists) {
-      return {wasInstalled: true};
+    try {
+      const gitCommand = `git clone -b ${branch} ${DEFAULT_REPO_GH_URL} ${simulatorLocation}`;
+      const cmdsByPlatform = {darwin: gitCommand, win32: gitCommand, linux: gitCommand};
+      await executeCommand(cmdsByPlatform, "git");
+    } catch (error: any) {
+      const simulatorLocationExists = fs.existsSync(simulatorLocation);
+      if (simulatorLocationExists) {
+        return {wasInstalled: true};
+      }
+      throw error;
     }
-    throw error;
+    return {wasInstalled: false};
   }
-  return {wasInstalled: false};
-}
 
-export async function updateSimulator(): Promise<DownloadSimulatorResultType> {
-  const simulatorLocation = getSimulatorLocation();
-  const gitCommand = `git -C  "${simulatorLocation}" pull`;
-  const cmdsByPlatform = {darwin: gitCommand, win32: gitCommand, linux: gitCommand};
-  await executeCommand(cmdsByPlatform, "git");
-  return {wasInstalled: false};
-}
+  public async updateSimulator(branch: string = "main"): Promise<boolean> {
+    const simulatorLocation = this.getSimulatorLocation();
+    const gitCleanCommand = `git -C  "${simulatorLocation}" clean -f`;
+    const cleanCmdsByPlatform = {darwin: gitCleanCommand, win32: gitCleanCommand, linux: gitCleanCommand};
+    await executeCommand(cleanCmdsByPlatform, "git");
+
+    const gitFetchCommand = `git -C  "${simulatorLocation}" fetch`;
+    const fetchCmdsByPlatform = {darwin: gitFetchCommand, win32: gitFetchCommand, linux: gitFetchCommand};
+    await executeCommand(fetchCmdsByPlatform, "git");
+
+    const gitCheckoutCommand = `git -C  "${simulatorLocation}" checkout ${branch}`;
+    const checkoutCmdsByPlatform = {
+      darwin: gitCheckoutCommand,
+      win32: gitCheckoutCommand,
+      linux: gitCheckoutCommand,
+    };
+    await executeCommand(checkoutCmdsByPlatform, "git");
 
-export async function pullOllamaModel(): Promise<boolean> {
-  const simulatorLocation = getSimulatorLocation();
-  const cmdsByPlatform = DEFAULT_PULL_OLLAMA_COMMAND(simulatorLocation);
-  await executeCommand(cmdsByPlatform);
-  return true;
-}
+    const gitPullCommand = `git -C  "${simulatorLocation}" pull`;
+    const pullCmdsByPlatform = {darwin: gitPullCommand, win32: gitPullCommand, linux: gitPullCommand};
+    await executeCommand(pullCmdsByPlatform, "git");
+    return true;
+  }
 
-export async function configSimulator(newConfig: Record<string, string>): Promise<boolean> {
-  const simulatorLocation = getSimulatorLocation();
-  const envExample = path.join(simulatorLocation, ".env.example");
-  const envFilePath = path.join(simulatorLocation, ".env");
-  fs.copyFileSync(envExample, envFilePath);
-  addConfigToEnvFile(newConfig);
-  return true;
-}
+  public async pullOllamaModel(): Promise<boolean> {
+    const simulatorLocation = this.getSimulatorLocation();
+    const cmdsByPlatform = DEFAULT_PULL_OLLAMA_COMMAND(simulatorLocation);
+    await executeCommand(cmdsByPlatform);
+    return true;
+  }
 
-export function runSimulator(): Promise<{stdout: string; stderr: string}> {
-  const simulatorLocation = getSimulatorLocation();
-  const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(simulatorLocation);
-  return executeCommand(commandsByPlatform);
-}
+  public async configSimulator(newConfig: Record<string, string>): Promise<boolean> {
+    const simulatorLocation = this.getSimulatorLocation();
+    const envExample = path.join(simulatorLocation, ".env.example");
+    const envFilePath = path.join(simulatorLocation, ".env");
+    fs.copyFileSync(envExample, envFilePath);
+    this.addConfigToEnvFile(newConfig);
+    return true;
+  }
 
-type WaitForSimulatorToBeReadyResultType = {
-  initialized: boolean;
-  errorCode?: "TIMEOUT" | "ERROR";
-  errorMessage?: string;
-};
-
-export async function waitForSimulatorToBeReady(
-  retries: number = STARTING_TIMEOUT_ATTEMPTS,
-): Promise<WaitForSimulatorToBeReadyResultType> {
-  console.log("Waiting for the simulator to start up...");
-  try {
-    const response = await rpcClient.request({method: "ping", params: []});
-    if (response && response.result.status === "OK") {
-      return {initialized: true};
-    }
-    if (retries > 0) {
-      await sleep(STARTING_TIMEOUT_WAIT_CYLCE);
-      return waitForSimulatorToBeReady(retries - 1);
-    }
-  } catch (error: any) {
-    if (
-      (error.name === "FetchError" ||
-        error.message.includes("ECONNRESET") ||
-        error.message.includes("ECONNREFUSED") ||
-        error.message.includes("socket hang up")) &&
-      retries > 0
-    ) {
-      await sleep(STARTING_TIMEOUT_WAIT_CYLCE * 2);
-      return waitForSimulatorToBeReady(retries - 1);
-    }
-    return {initialized: false, errorCode: "ERROR", errorMessage: error.message};
+  public runSimulator(): Promise<{stdout: string; stderr: string}> {
+    const simulatorLocation = this.getSimulatorLocation();
+    const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(simulatorLocation);
+    return executeCommand(commandsByPlatform);
   }
 
-  return {initialized: false, errorCode: "TIMEOUT"};
-}
+  public async waitForSimulatorToBeReady(
+    retries: number = STARTING_TIMEOUT_ATTEMPTS,
+  ): Promise<WaitForSimulatorToBeReadyResultType> {
+    console.log("Waiting for the simulator to start up...");
+    try {
+      const response = await rpcClient.request({method: "ping", params: []});
+      if (response && response.result.status === "OK") {
+        return {initialized: true};
+      }
+      if (retries > 0) {
+        await sleep(STARTING_TIMEOUT_WAIT_CYLCE);
+        return this.waitForSimulatorToBeReady(retries - 1);
+      }
+    } catch (error: any) {
+      if (
+        (error.name === "FetchError" ||
+          error.message.includes("Fetch Error") ||
+          error.message.includes("ECONNRESET") ||
+          error.message.includes("ECONNREFUSED") ||
+          error.message.includes("socket hang up")) &&
+        retries > 0
+      ) {
+        await sleep(STARTING_TIMEOUT_WAIT_CYLCE * 2);
+        return this.waitForSimulatorToBeReady(retries - 1);
+      }
+      return {initialized: false, errorCode: "ERROR", errorMessage: error.message};
+    }
 
-export function clearAccountsAndTransactionsDatabase(): Promise<any> {
-  return rpcClient.request({method: "clear_account_and_transactions_tables", params: []});
-}
+    return {initialized: false, errorCode: "TIMEOUT"};
+  }
 
-type InitializeDatabaseResultType = {
-  createResponse: any;
-  tablesResponse: any;
-};
+  public clearAccountsAndTransactionsDatabase(): Promise<any> {
+    return rpcClient.request({method: "clear_account_and_transactions_tables", params: []});
+  }
 
-export async function initializeDatabase(): Promise<InitializeDatabaseResultType> {
-  const createResponse = await rpcClient.request({method: "create_db", params: []});
-  const tablesResponse = await rpcClient.request({method: "create_tables", params: []});
-  return {createResponse, tablesResponse};
-}
+  public async initializeDatabase(): Promise<InitializeDatabaseResultType> {
+    const createResponse = await rpcClient.request({method: "create_db", params: []});
+    const tablesResponse = await rpcClient.request({method: "create_tables", params: []});
+    return {createResponse, tablesResponse};
+  }
 
-export function createRandomValidators(numValidators: number, llmProviders: AiProviders[]): Promise<any> {
-  return rpcClient.request({
-    method: "create_random_validators",
-    params: [numValidators, 1, 10, llmProviders],
-  });
-}
+  public createRandomValidators(numValidators: number, llmProviders: AiProviders[]): Promise<any> {
+    return rpcClient.request({
+      method: "create_random_validators",
+      params: [numValidators, 1, 10, llmProviders],
+    });
+  }
 
-export function deleteAllValidators(): Promise<any> {
-  return rpcClient.request({method: "delete_all_validators", params: []});
-}
+  public deleteAllValidators(): Promise<any> {
+    return rpcClient.request({method: "delete_all_validators", params: []});
+  }
 
-export function getAiProvidersOptions(withHint: boolean = true): Array<{name: string; value: string}> {
-  return Object.values(AI_PROVIDERS_CONFIG).map(providerConfig => {
-    return {
-      name: `${providerConfig.name}${withHint ? ` ${providerConfig.hint}` : ""}`,
-      value: providerConfig.cliOptionValue,
-    };
-  });
-}
+  public getAiProvidersOptions(withHint: boolean = true): Array<{name: string; value: string}> {
+    return Object.values(AI_PROVIDERS_CONFIG).map(providerConfig => {
+      return {
+        name: `${providerConfig.name}${withHint ? ` ${providerConfig.hint}` : ""}`,
+        value: providerConfig.cliOptionValue,
+      };
+    });
+  }
 
-export function getFrontendUrl(): string {
-  const frontendPort = readEnvConfigValue("FRONTEND_PORT");
-  return `http://localhost:${frontendPort}`;
-}
+  public getFrontendUrl(): string {
+    const frontendPort = this.readEnvConfigValue("FRONTEND_PORT");
+    return `http://localhost:${frontendPort}`;
+  }
 
-export async function openFrontend(): Promise<boolean> {
-  await openUrl(getFrontendUrl());
-  return true;
-}
+  public async openFrontend(): Promise<boolean> {
+    await openUrl(this.getFrontendUrl());
+    return true;
+  }
 
-export async function resetDockerContainers(): Promise<boolean> {
-  const containers = await listDockerContainers();
-  const genlayerContainers = containers.filter((container: string) =>
-    container.startsWith(DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX),
-  );
-  const containersStopPromises = genlayerContainers.map((container: string) =>
-    stopDockerContainer(container),
-  );
-  await Promise.all(containersStopPromises);
-
-  const containersRemovePromises = genlayerContainers.map((container: string) =>
-    removeDockerContainer(container),
-  );
-  await Promise.all(containersRemovePromises);
-
-  return true;
-}
+  public async resetDockerContainers(): Promise<boolean> {
+    const containers = await listDockerContainers();
+    const genlayerContainers = containers.filter((container: string) =>
+      container.startsWith(DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX),
+    );
+    const containersStopPromises = genlayerContainers.map((container: string) =>
+      stopDockerContainer(container),
+    );
+    await Promise.all(containersStopPromises);
+
+    const containersRemovePromises = genlayerContainers.map((container: string) =>
+      removeDockerContainer(container),
+    );
+    await Promise.all(containersRemovePromises);
+
+    return true;
+  }
 
-export async function resetDockerImages(): Promise<boolean> {
-  const images = await listDockerImages();
-  const genlayerImages = images.filter((image: string) =>
-    image.startsWith(DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX),
-  );
-  const imagesRemovePromises = genlayerImages.map((image: string) => removeDockerImage(image));
-  await Promise.all(imagesRemovePromises);
+  public async resetDockerImages(): Promise<boolean> {
+    const images = await listDockerImages();
+    const genlayerImages = images.filter((image: string) =>
+      image.startsWith(DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX),
+    );
+    const imagesRemovePromises = genlayerImages.map((image: string) => removeDockerImage(image));
+    await Promise.all(imagesRemovePromises);
 
-  return true;
+    return true;
+  }
 }
+
+export default new SimulatorService();

package/src/types/node-fetch.d.ts

@@ -0,0 +1 @@
+declare module "node-fetch";