genlayer 0.0.20 → 0.0.21

package/CHANGELOG.md

@@ -1,5 +1,7 @@
 
 
+## 0.0.21 (2024-04-30)
+
 ## 0.0.20 (2024-04-26)
 
 ## 0.0.19 (2024-04-26)

package/dist/index.js

@@ -34416,6 +34416,345 @@ var require_set = __commonJS({
   }
 });
 
+// node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "node_modules/dotenv/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "dotenv",
+      version: "16.4.5",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        "lint-readme": "standard-markdown",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap tests/*.js --100 -Rspec",
+        "test:coverage": "tap --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@definitelytyped/dtslint": "^0.0.133",
+        "@types/node": "^18.11.3",
+        decache: "^4.6.1",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-markdown": "^7.1.0",
+        "standard-version": "^9.5.0",
+        tap: "^16.3.0",
+        tar: "^6.1.11",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// node_modules/dotenv/lib/main.js
+var require_main2 = __commonJS({
+  "node_modules/dotenv/lib/main.js"(exports2, module2) {
+    "use strict";
+    var fs3 = require("fs");
+    var path = require("path");
+    var os3 = require("os");
+    var crypto3 = require("crypto");
+    var packageJson = require_package();
+    var version2 = packageJson.version;
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse2(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      const vaultPath = _vaultPath(options);
+      const result = DotenvModule.configDotenv({ path: vaultPath });
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i2 = 0; i2 < length; i2++) {
+        try {
+          const key = keys[i2].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i2 + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _log(message) {
+      console.log(`[dotenv@${version2}][INFO] ${message}`);
+    }
+    function _warn(message) {
+      console.log(`[dotenv@${version2}][WARN] ${message}`);
+    }
+    function _debug(message) {
+      console.log(`[dotenv@${version2}][DEBUG] ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs3.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs3.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path.join(os3.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      _log("Loading env from encrypted .env.vault");
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      const debug = Boolean(options && options.debug);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path2 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs3.readFileSync(path2, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e2) {
+          if (debug) {
+            _debug(`Failed to load ${path2} ${e2.message}`);
+          }
+          lastError = e2;
+        }
+      }
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsedAll, options);
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto3.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+        }
+      }
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse: parse2,
+      populate
+    };
+    module2.exports.configDotenv = DotenvModule.configDotenv;
+    module2.exports._configVault = DotenvModule._configVault;
+    module2.exports._parseVault = DotenvModule._parseVault;
+    module2.exports.config = DotenvModule.config;
+    module2.exports.decrypt = DotenvModule.decrypt;
+    module2.exports.parse = DotenvModule.parse;
+    module2.exports.populate = DotenvModule.populate;
+    module2.exports = DotenvModule;
+  }
+});
+
 // node_modules/web-streams-polyfill/dist/ponyfill.es2018.js
 var require_ponyfill_es2018 = __commonJS({
   "node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports2, module2) {
@@ -39556,7 +39895,7 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.0.20";
+var version = "0.0.21";
 
 // src/lib/config/text.ts
 var CLI_DESCRIPTION = "GenLayer CLI is a development environment for the GenLayer ecosystem. It allows developers to interact with the protocol by creating accounts, sending transactions, and working with Intelligent Contracts by testing, debugging, and deploying them.";
@@ -42148,8 +42487,35 @@ var inquirer = {
 };
 var inquirer_default = inquirer;
 
+// src/lib/config/simulator.ts
+var DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
+var DEFAULT_REPO_GH_URL = "git@github.com:yeagerai/genlayer-simulator.git";
+var DEFAULT_CONFIG_SIMULATOR_COMMAND = (simulatorLocation) => ({
+  darwin: `cd ${simulatorLocation} && cp .env.example .env`,
+  win32: `cd ${simulatorLocation} && xcopy .env.example .env`,
+  linux: `cd ${simulatorLocation} && cp .env.example .env`
+});
+var DEFAULT_RUN_SIMULATOR_COMMAND = (simulatorLocation) => ({
+  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${simulatorLocation} && docker compose build && docker compose up"'`,
+  win32: `start cmd.exe /k "cd ${simulatorLocation} && docker compose build && docker compose up"`,
+  linux: `x-terminal-emulator -e bash -c 'cd ${simulatorLocation} && docker compose build && docker compose up; echo "Press enter to exit"; read'`
+});
+var DEFAULT_RUN_OLLAMA_COMMAND = (simulatorLocation) => ({
+  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${simulatorLocation} && docker exec -it ollama ollama run llama2"'`,
+  win32: `start cmd.exe /k "cd ${simulatorLocation} && docker exec -it ollama ollama run llama2"`,
+  linux: `x-terminal-emulator -e bash -c 'cd ${simulatorLocation} && docker exec -it ollama ollama run llama2; echo "Press enter to exit"; read'`
+});
+var AVAILABLE_PLATFORMS = ["darwin", "win32", "linux"];
+var STARTING_TIMEOUT_WAIT_CYLCE = 2e3;
+var STARTING_TIMEOUT_ATTEMPTS = 120;
+var AI_PROVIDERS_CONFIG = {
+  ollama: { name: "Ollama", envVar: "ollama", cliOptionValue: "ollama" },
+  openai: { name: "OpenAI", envVar: "GENVMOPENAIKEY", cliOptionValue: "openai" }
+};
+
 // src/lib/services/simulator.ts
 var fs2 = __toESM(require("fs"));
+var dotenv = __toESM(require_main2());
 
 // node_modules/node-fetch/src/index.js
 var import_node_http2 = __toESM(require("http"), 1);
@@ -43504,18 +43870,6 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 
-// src/lib/config/simulator.ts
-var DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
-var DEFAULT_REPO_GH_URL = "git@github.com:yeagerai/genlayer-simulator.git";
-var DEFAULT_RUN_SIMULATOR_COMMAND = (simulatorLocation) => ({
-  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${simulatorLocation} && cp .env.example .env && docker compose build && docker compose up"'`,
-  win32: `start cmd.exe /k "cd ${simulatorLocation} && xcopy .env.example .env && docker compose build && docker compose up"`,
-  linux: `x-terminal-emulator -e bash -c 'cd ${simulatorLocation} && cp .env.example .env && docker compose build && docker compose up; echo "Press enter to exit"; read'`
-});
-var AVAILABLE_PLATFORMS = ["darwin", "win32", "linux"];
-var STARTING_TIMEOUT_WAIT_CYLCE = 2e3;
-var STARTING_TIMEOUT_ATTEMPTS = 120;
-
 // src/lib/clients/jsonRpcClient.ts
 var JsonRpcClient = class {
   constructor(serverUrl) {
@@ -43573,8 +43927,10 @@ function checkCommand(command, toolName) {
     console.log(`${toolName} is installed.`);
   });
 }
-function executeCommand(command, toolName) {
+function executeCommand(cmdsByPlatform, toolName) {
   try {
+    const runningPlatform = getPlatform();
+    const command = cmdsByPlatform[runningPlatform];
     return asyncExec(command);
   } catch (error) {
     throw new Error(`Error executing ${toolName}: ${error.message}`);
@@ -43607,6 +43963,19 @@ function getSimulatorLocation() {
 function sleep(millliseconds) {
   return new Promise((resolve) => setTimeout(resolve, millliseconds));
 }
+function addConfigToEnvFile(newConfig) {
+  const simulatorLocation = getSimulatorLocation();
+  const envFilePath = `${simulatorLocation}/.env`;
+  fs2.writeFileSync(`${envFilePath}.bak`, fs2.readFileSync(envFilePath));
+  const envConfig = dotenv.parse(fs2.readFileSync(envFilePath, "utf8"));
+  Object.keys(newConfig).forEach((key) => {
+    envConfig[key] = newConfig[key];
+  });
+  const updatedConfig = Object.keys(envConfig).map((key) => {
+    return `${key}=${envConfig[key]}`;
+  }).join("\n");
+  fs2.writeFileSync(envFilePath, updatedConfig);
+}
 function checkRequirements() {
   return __async(this, null, function* () {
     const requirementsInstalled = {
@@ -43636,7 +44005,9 @@ function downloadSimulator() {
   return __async(this, null, function* () {
     const simulatorLocation = getSimulatorLocation();
     try {
-      yield executeCommand(`git clone ${DEFAULT_REPO_GH_URL} ${simulatorLocation}`, "git");
+      const gitCommand = `git clone ${DEFAULT_REPO_GH_URL} ${simulatorLocation}`;
+      const cmdsByPlatform = { darwin: gitCommand, win32: gitCommand, linux: gitCommand };
+      yield executeCommand(cmdsByPlatform, "git");
     } catch (error) {
       const simulatorLocationExists = fs2.existsSync(simulatorLocation);
       if (simulatorLocationExists) {
@@ -43650,10 +44021,29 @@ function downloadSimulator() {
 function updateSimulator() {
   return __async(this, null, function* () {
     const simulatorLocation = getSimulatorLocation();
-    yield executeCommand(`cd ${simulatorLocation} && git pull`, "git");
+    const gitCommand = `cd ${simulatorLocation} && git pull`;
+    const cmdsByPlatform = { darwin: gitCommand, win32: gitCommand, linux: gitCommand };
+    yield executeCommand(cmdsByPlatform, "git");
     return { wasInstalled: false };
   });
 }
+function runOllamaModel() {
+  return __async(this, null, function* () {
+    const simulatorLocation = getSimulatorLocation();
+    const cmdsByPlatform = DEFAULT_RUN_OLLAMA_COMMAND(simulatorLocation);
+    yield executeCommandInNewTerminal(cmdsByPlatform);
+    return true;
+  });
+}
+function configSimulator(newConfig) {
+  return __async(this, null, function* () {
+    const simulatorLocation = getSimulatorLocation();
+    const commandsByPlatform = DEFAULT_CONFIG_SIMULATOR_COMMAND(simulatorLocation);
+    yield executeCommand(commandsByPlatform, "copy (cp)");
+    addConfigToEnvFile(newConfig);
+    return true;
+  });
+}
 function runSimulator() {
   const simulatorLocation = getSimulatorLocation();
   const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(simulatorLocation);
@@ -43661,24 +44051,29 @@ function runSimulator() {
 }
 function waitForSimulatorToBeReady() {
   return __async(this, arguments, function* (retries = STARTING_TIMEOUT_ATTEMPTS) {
+    console.log("Waiting for Simulator to be ready...:");
     try {
       const response = yield rpcClient.request({ method: "ping", params: [] });
       if (response && response.result.status === "OK") {
-        return true;
+        return { initialized: true };
       }
       if (retries > 0) {
         yield sleep(STARTING_TIMEOUT_WAIT_CYLCE);
         return waitForSimulatorToBeReady(retries - 1);
       }
     } catch (error) {
-      if (error.message.includes("ECONNREFUSED") && retries > 0) {
+      if ((error.message.includes("ECONNREFUSED") || error.message.includes("socket hang up")) && retries > 0) {
         yield sleep(STARTING_TIMEOUT_WAIT_CYLCE * 2);
         return waitForSimulatorToBeReady(retries - 1);
       }
+      return { initialized: false, error: "ERROR" };
     }
-    return false;
+    return { initialized: false, error: "TIMEOUT" };
   });
 }
+function clearDatabaseTables() {
+  return rpcClient.request({ method: "clear_tables", params: [] });
+}
 function initializeDatabase() {
   return __async(this, null, function* () {
     const createResponse = yield rpcClient.request({ method: "create_db", params: [] });
@@ -43686,6 +44081,17 @@ function initializeDatabase() {
     return { createResponse, tablesResponse };
   });
 }
+function createRandomValidators() {
+  return rpcClient.request({ method: "create_random_validators", params: [10, 1, 10] });
+}
+function deleteAllValidators() {
+  return rpcClient.request({ method: "delete_all_validators", params: [] });
+}
+function getAiProvidersOptions() {
+  return Object.values(AI_PROVIDERS_CONFIG).map((providerConfig) => {
+    return { name: providerConfig.name, value: providerConfig.cliOptionValue };
+  });
+}
 
 // src/commands/general/init.ts
 function getRequirementsErrorMessage({ git, docker }) {
@@ -43736,6 +44142,50 @@ function initAction(options) {
       console.error(error);
       return;
     }
+    const questions = [
+      {
+        type: "checkbox",
+        name: "selectedLlmProviders",
+        message: "Select which LLM providers do you want to use:",
+        choices: getAiProvidersOptions(),
+        validate: function(answer) {
+          if (answer.length < 1) {
+            return "You must choose at least one option.";
+          }
+          return true;
+        }
+      }
+    ];
+    const llmProvidersAnswer = yield inquirer_default.prompt(questions);
+    const selectedLlmProviders = llmProvidersAnswer.selectedLlmProviders;
+    const aiProvidersEnvVars = {};
+    const configurableAiProviders = selectedLlmProviders.filter((provider) => provider !== "ollama");
+    for (let i2 = 0; i2 < configurableAiProviders.length; i2++) {
+      const provider = configurableAiProviders[i2];
+      const providerConfig = AI_PROVIDERS_CONFIG[provider];
+      const questions2 = [
+        {
+          type: "password",
+          name: providerConfig.cliOptionValue,
+          message: `Please enter your ${providerConfig.name} API Key:`,
+          validate: function(value) {
+            if (value.length) {
+              return true;
+            }
+            return `Please enter a valid API Key for ${providerConfig.name}.`;
+          }
+        }
+      ];
+      const apiKeyAnswer = yield inquirer_default.prompt(questions2);
+      aiProvidersEnvVars[providerConfig.envVar] = apiKeyAnswer[providerConfig.cliOptionValue];
+    }
+    console.log("Configuring GenLayer Simulator environment...");
+    try {
+      yield configSimulator(aiProvidersEnvVars);
+    } catch (error) {
+      console.error(error);
+      return;
+    }
     console.log("Running the GenLayer Simulator...");
     try {
       yield runSimulator();
@@ -43744,18 +44194,28 @@ function initAction(options) {
       return;
     }
     try {
-      const initialized = yield waitForSimulatorToBeReady();
-      if (!initialized) {
+      const { initialized, error } = yield waitForSimulatorToBeReady();
+      if (!initialized && error === "ERROR") {
         console.error("Unable to initialize the GenLayer simulator. Please try again.");
         return;
       }
+      if (!initialized && error === "TIMEOUT") {
+        console.error(
+          "The simulator is taking too lonk to initialize. Please try again after the simulator is ready."
+        );
+        return;
+      }
       console.log("Simulator is running!");
     } catch (error) {
       console.error(error);
       return;
     }
+    if (selectedLlmProviders.includes("ollama")) {
+      yield runOllamaModel();
+    }
     console.log("Initializing the database...");
     try {
+      yield clearDatabaseTables();
       const { createResponse, tablesResponse } = yield initializeDatabase();
       if (!createResponse || !tablesResponse) {
         console.error("Unable to initialize the database. Please try again.");
@@ -43765,6 +44225,15 @@ function initAction(options) {
       console.error(error);
       return;
     }
+    console.log("Initializing validators...");
+    try {
+      yield deleteAllValidators();
+      yield createRandomValidators();
+    } catch (error) {
+      console.error("Unable to initialize the validators.");
+      console.error(error);
+      return;
+    }
     console.log("GenLayer simulator initialized successfully!");
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {
@@ -53,6 +53,7 @@
   },
   "dependencies": {
     "commander": "^12.0.0",
+    "dotenv": "^16.4.5",
     "inquirer": "^9.2.19",
     "node-fetch": "^3.3.2",
     "uuid": "^9.0.1"

package/src/commands/general/init.ts

@@ -1,12 +1,19 @@
 import inquirer from "inquirer";
 
+import {AI_PROVIDERS_CONFIG, AiProviders} from "@/lib/config/simulator";
 import {
   initializeDatabase,
   checkRequirements,
   downloadSimulator,
+  configSimulator,
   runSimulator,
   waitForSimulatorToBeReady,
   updateSimulator,
+  clearDatabaseTables,
+  createRandomValidators,
+  deleteAllValidators,
+  runOllamaModel,
+  getAiProvidersOptions,
 } from "@/lib/services/simulator";
 export interface InitActionOptions {
   numValidators: number;
@@ -68,6 +75,58 @@ export async function initAction(options: InitActionOptions) {
     return;
   }
 
+  // Check LLM configuration
+  const questions = [
+    {
+      type: "checkbox",
+      name: "selectedLlmProviders",
+      message: "Select which LLM providers do you want to use:",
+      choices: getAiProvidersOptions(),
+      validate: function (answer: string[]) {
+        if (answer.length < 1) {
+          return "You must choose at least one option.";
+        }
+        return true;
+      },
+    },
+  ];
+
+  // Since ollama runs locally we can run it here and then look for the other providers
+  const llmProvidersAnswer = await inquirer.prompt(questions);
+  const selectedLlmProviders = llmProvidersAnswer.selectedLlmProviders as AiProviders[];
+
+  // Gather the API Keys
+  const aiProvidersEnvVars: Record<string, string> = {};
+  const configurableAiProviders = selectedLlmProviders.filter((provider: string) => provider !== "ollama");
+  for (let i = 0; i < configurableAiProviders.length; i++) {
+    const provider = configurableAiProviders[i];
+    const providerConfig = AI_PROVIDERS_CONFIG[provider];
+    const questions = [
+      {
+        type: "password",
+        name: providerConfig.cliOptionValue,
+        message: `Please enter your ${providerConfig.name} API Key:`,
+        validate: function (value: string) {
+          if (value.length) {
+            return true;
+          }
+          return `Please enter a valid API Key for ${providerConfig.name}.`;
+        },
+      },
+    ];
+
+    const apiKeyAnswer = await inquirer.prompt(questions);
+    aiProvidersEnvVars[providerConfig.envVar] = apiKeyAnswer[providerConfig.cliOptionValue];
+  }
+
+  console.log("Configuring GenLayer Simulator environment...");
+  try {
+    await configSimulator(aiProvidersEnvVars);
+  } catch (error) {
+    console.error(error);
+    return;
+  }
+
   // Run the GenLayer Simulator
   console.log("Running the GenLayer Simulator...");
   try {
@@ -78,20 +137,34 @@ export async function initAction(options: InitActionOptions) {
   }
 
   try {
-    const initialized = await waitForSimulatorToBeReady();
-    if (!initialized) {
+    const {initialized, error} = await waitForSimulatorToBeReady();
+    if (!initialized && error === "ERROR") {
       console.error("Unable to initialize the GenLayer simulator. Please try again.");
       return;
     }
+    if (!initialized && error === "TIMEOUT") {
+      console.error(
+        "The simulator is taking too lonk to initialize. Please try again after the simulator is ready.",
+      );
+      return;
+    }
     console.log("Simulator is running!");
   } catch (error) {
     console.error(error);
     return;
   }
 
+  // Ollama doesn't need changes in configuration, we just run it
+  if (selectedLlmProviders.includes("ollama")) {
+    await runOllamaModel();
+  }
+
   // Initialize the database
   console.log("Initializing the database...");
   try {
+    //remove everything from the database
+    await clearDatabaseTables();
+
     const {createResponse, tablesResponse} = await initializeDatabase();
     if (!createResponse || !tablesResponse) {
       console.error("Unable to initialize the database. Please try again.");
@@ -101,5 +174,19 @@ export async function initAction(options: InitActionOptions) {
     console.error(error);
     return;
   }
+
+  // Initializing validators
+  console.log("Initializing validators...");
+  try {
+    //remove all validators
+    await deleteAllValidators();
+    // create random validators
+    await createRandomValidators();
+  } catch (error) {
+    console.error("Unable to initialize the validators.");
+    console.error(error);
+    return;
+  }
+
   console.log("GenLayer simulator initialized successfully!");
 }

package/src/lib/clients/system.ts

@@ -20,18 +20,23 @@ type ExecuteCommandResult = {
   stderr: string;
 };
 
-export function executeCommand(command: string, toolName: string): Promise<ExecuteCommandResult> {
+type ExecuteCommandInNewTerminalInput = {
+  [key in RunningPlatform]: string;
+};
+
+export function executeCommand(
+  cmdsByPlatform: ExecuteCommandInNewTerminalInput,
+  toolName: string,
+): Promise<ExecuteCommandResult> {
   try {
+    const runningPlatform = getPlatform();
+    const command = cmdsByPlatform[runningPlatform];
     return asyncExec(command);
   } catch (error: any) {
     throw new Error(`Error executing ${toolName}: ${error.message}`);
   }
 }
 
-type ExecuteCommandInNewTerminalInput = {
-  [key in RunningPlatform]: string;
-};
-
 export function executeCommandInNewTerminal(
   cmdsByPlatform: ExecuteCommandInNewTerminalInput,
 ): PromiseWithChild<{stdout: string; stderr: string}> {

package/src/lib/config/simulator.ts

@@ -1,11 +1,32 @@
 export const DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
 export const DEFAULT_REPO_GH_URL = "git@github.com:yeagerai/genlayer-simulator.git";
+export const DEFAULT_CONFIG_SIMULATOR_COMMAND = (simulatorLocation: string) => ({
+  darwin: `cd ${simulatorLocation} && cp .env.example .env`,
+  win32: `cd ${simulatorLocation} && xcopy .env.example .env`,
+  linux: `cd ${simulatorLocation} && cp .env.example .env`,
+});
 export const DEFAULT_RUN_SIMULATOR_COMMAND = (simulatorLocation: string) => ({
-  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${simulatorLocation} && cp .env.example .env && docker compose build && docker compose up"'`,
-  win32: `start cmd.exe /k "cd ${simulatorLocation} && xcopy .env.example .env && docker compose build && docker compose up"`,
-  linux: `x-terminal-emulator -e bash -c 'cd ${simulatorLocation} && cp .env.example .env && docker compose build && docker compose up; echo "Press enter to exit"; read'`,
+  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${simulatorLocation} && docker compose build && docker compose up"'`,
+  win32: `start cmd.exe /k "cd ${simulatorLocation} && docker compose build && docker compose up"`,
+  linux: `x-terminal-emulator -e bash -c 'cd ${simulatorLocation} && docker compose build && docker compose up; echo "Press enter to exit"; read'`,
+});
+export const DEFAULT_RUN_OLLAMA_COMMAND = (simulatorLocation: string) => ({
+  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${simulatorLocation} && docker exec -it ollama ollama run llama2"'`,
+  win32: `start cmd.exe /k "cd ${simulatorLocation} && docker exec -it ollama ollama run llama2"`,
+  linux: `x-terminal-emulator -e bash -c 'cd ${simulatorLocation} && docker exec -it ollama ollama run llama2; echo "Press enter to exit"; read'`,
 });
 export const AVAILABLE_PLATFORMS = ["darwin", "win32", "linux"] as const;
 export type RunningPlatform = (typeof AVAILABLE_PLATFORMS)[number];
 export const STARTING_TIMEOUT_WAIT_CYLCE = 2000;
 export const STARTING_TIMEOUT_ATTEMPTS = 120;
+
+export type AiProviders = "ollama" | "openai";
+export type AiProvidersEnvVars = "ollama" | "GENVMOPENAIKEY";
+export type AiProvidersConfigType = {
+  [key in AiProviders]: {name: string; envVar: AiProvidersEnvVars; cliOptionValue: string};
+};
+
+export const AI_PROVIDERS_CONFIG: AiProvidersConfigType = {
+  ollama: {name: "Ollama", envVar: "ollama", cliOptionValue: "ollama"},
+  openai: {name: "OpenAI", envVar: "GENVMOPENAIKEY", cliOptionValue: "openai"},
+};

package/src/lib/services/simulator.ts

@@ -1,11 +1,15 @@
 import * as fs from "fs";
+import * as dotenv from "dotenv";
 
 import {rpcClient} from "@/lib/clients/jsonRpcClient";
 import {
   DEFAULT_REPO_GH_URL,
   DEFAULT_RUN_SIMULATOR_COMMAND,
+  DEFAULT_CONFIG_SIMULATOR_COMMAND,
+  DEFAULT_RUN_OLLAMA_COMMAND,
   STARTING_TIMEOUT_WAIT_CYLCE,
   STARTING_TIMEOUT_ATTEMPTS,
+  AI_PROVIDERS_CONFIG,
 } from "@/lib/config/simulator";
 import {
   checkCommand,
@@ -24,6 +28,30 @@ 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 = `${simulatorLocation}/.env`;
+
+  // Create a backup of the original .env file
+  fs.writeFileSync(`${envFilePath}.bak`, fs.readFileSync(envFilePath));
+
+  // Transform the config string to object
+  const envConfig = dotenv.parse(fs.readFileSync(envFilePath, "utf8"));
+  Object.keys(newConfig).forEach(key => {
+    envConfig[key] = newConfig[key];
+  });
+
+  // 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);
+}
+
 // Public functions
 export async function checkRequirements(): Promise<Record<string, boolean>> {
   const requirementsInstalled = {
@@ -59,7 +87,9 @@ export async function downloadSimulator(): Promise<DownloadSimulatorResultType>
   const simulatorLocation = getSimulatorLocation();
 
   try {
-    await executeCommand(`git clone ${DEFAULT_REPO_GH_URL} ${simulatorLocation}`, "git");
+    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) {
@@ -72,36 +102,64 @@ export async function downloadSimulator(): Promise<DownloadSimulatorResultType>
 
 export async function updateSimulator(): Promise<DownloadSimulatorResultType> {
   const simulatorLocation = getSimulatorLocation();
-  await executeCommand(`cd ${simulatorLocation} && git pull`, "git");
+  const gitCommand = `cd ${simulatorLocation} && git pull`;
+  const cmdsByPlatform = {darwin: gitCommand, win32: gitCommand, linux: gitCommand};
+  await executeCommand(cmdsByPlatform, "git");
   return {wasInstalled: false};
 }
 
+export async function runOllamaModel(): Promise<boolean> {
+  const simulatorLocation = getSimulatorLocation();
+  const cmdsByPlatform = DEFAULT_RUN_OLLAMA_COMMAND(simulatorLocation);
+  await executeCommandInNewTerminal(cmdsByPlatform);
+  return true;
+}
+
+export async function configSimulator(newConfig: Record<string, string>): Promise<boolean> {
+  const simulatorLocation = getSimulatorLocation();
+  const commandsByPlatform = DEFAULT_CONFIG_SIMULATOR_COMMAND(simulatorLocation);
+  await executeCommand(commandsByPlatform, "copy (cp)");
+  addConfigToEnvFile(newConfig);
+  return true;
+}
+
 export function runSimulator(): Promise<{stdout: string; stderr: string}> {
   const simulatorLocation = getSimulatorLocation();
   const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(simulatorLocation);
   return executeCommandInNewTerminal(commandsByPlatform);
 }
 
+type WaitForSimulatorToBeReadyResultType = {
+  initialized: boolean;
+  error?: "TIMEOUT" | "ERROR";
+};
+
 export async function waitForSimulatorToBeReady(
   retries: number = STARTING_TIMEOUT_ATTEMPTS,
-): Promise<boolean> {
+): Promise<WaitForSimulatorToBeReadyResultType> {
+  console.log("Waiting for Simulator to be ready...:");
   try {
     const response = await rpcClient.request({method: "ping", params: []});
     if (response && response.result.status === "OK") {
-      return true;
+      return {initialized: true};
     }
     if (retries > 0) {
       await sleep(STARTING_TIMEOUT_WAIT_CYLCE);
       return waitForSimulatorToBeReady(retries - 1);
     }
   } catch (error: any) {
-    if (error.message.includes("ECONNREFUSED") && retries > 0) {
+    if ((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, error: "ERROR"};
   }
 
-  return false;
+  return {initialized: false, error: "TIMEOUT"};
+}
+
+export function clearDatabaseTables(): Promise<any> {
+  return rpcClient.request({method: "clear_tables", params: []});
 }
 
 type InitializeDatabaseResultType = {
@@ -114,3 +172,17 @@ export async function initializeDatabase(): Promise<InitializeDatabaseResultType
   const tablesResponse = await rpcClient.request({method: "create_tables", params: []});
   return {createResponse, tablesResponse};
 }
+
+export function createRandomValidators(): Promise<any> {
+  return rpcClient.request({method: "create_random_validators", params: [10, 1, 10]});
+}
+
+export function deleteAllValidators(): Promise<any> {
+  return rpcClient.request({method: "delete_all_validators", params: []});
+}
+
+export function getAiProvidersOptions(): Array<{name: string; value: string}> {
+  return Object.values(AI_PROVIDERS_CONFIG).map(providerConfig => {
+    return {name: providerConfig.name, value: providerConfig.cliOptionValue};
+  });
+}