genlayer 0.0.19 → 0.0.21

package/CHANGELOG.md

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

package/dist/index.js

@@ -1052,7 +1052,7 @@ var require_command = __commonJS({
     var EventEmitter = require("events").EventEmitter;
     var childProcess = require("child_process");
     var path = require("path");
-    var fs2 = require("fs");
+    var fs3 = require("fs");
     var process4 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1951,11 +1951,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path.resolve(baseDir, baseName);
-          if (fs2.existsSync(localBin))
+          if (fs3.existsSync(localBin))
             return localBin;
           if (sourceExt.includes(path.extname(baseName)))
             return void 0;
-          const foundExt = sourceExt.find((ext) => fs2.existsSync(`${localBin}${ext}`));
+          const foundExt = sourceExt.find((ext) => fs3.existsSync(`${localBin}${ext}`));
           if (foundExt)
             return `${localBin}${foundExt}`;
           return void 0;
@@ -1967,7 +1967,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs2.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs3.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -17601,10 +17601,10 @@ var require_supports_color = __commonJS({
         return 3;
       }
       if ("TERM_PROGRAM" in env2) {
-        const version = parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        const version2 = parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
         switch (env2.TERM_PROGRAM) {
           case "iTerm.app":
-            return version >= 3 ? 3 : 2;
+            return version2 >= 3 ? 3 : 2;
           case "Apple_Terminal":
             return 2;
         }
@@ -29099,7 +29099,7 @@ var require_iso2022 = __commonJS({
 var require_chardet = __commonJS({
   "node_modules/chardet/index.js"(exports2, module2) {
     "use strict";
-    var fs2 = require("fs");
+    var fs3 = require("fs");
     var utf8 = require_utf8();
     var unicode = require_unicode();
     var mbcs = require_mbcs();
@@ -29173,29 +29173,29 @@ var require_chardet = __commonJS({
       var fd;
       var handler = function(err, buffer) {
         if (fd) {
-          fs2.closeSync(fd);
+          fs3.closeSync(fd);
         }
         if (err)
           return cb(err, null);
         cb(null, self2.detect(buffer, opts));
       };
       if (opts && opts.sampleSize) {
-        fd = fs2.openSync(filepath, "r"), sample = Buffer.allocUnsafe(opts.sampleSize);
-        fs2.read(fd, sample, 0, opts.sampleSize, null, function(err) {
+        fd = fs3.openSync(filepath, "r"), sample = Buffer.allocUnsafe(opts.sampleSize);
+        fs3.read(fd, sample, 0, opts.sampleSize, null, function(err) {
           handler(err, sample);
         });
         return;
       }
-      fs2.readFile(filepath, handler);
+      fs3.readFile(filepath, handler);
     };
     module2.exports.detectFileSync = function(filepath, opts) {
       if (opts && opts.sampleSize) {
-        var fd = fs2.openSync(filepath, "r"), sample2 = Buffer.allocUnsafe(opts.sampleSize);
-        fs2.readSync(fd, sample2, 0, opts.sampleSize);
-        fs2.closeSync(fd);
+        var fd = fs3.openSync(filepath, "r"), sample2 = Buffer.allocUnsafe(opts.sampleSize);
+        fs3.readSync(fd, sample2, 0, opts.sampleSize);
+        fs3.closeSync(fd);
         return self2.detect(sample2, opts);
       }
-      return self2.detect(fs2.readFileSync(filepath), opts);
+      return self2.detect(fs3.readFileSync(filepath), opts);
     };
     module2.exports.detectAll = function(buffer, opts) {
       if (typeof opts !== "object") {
@@ -32699,7 +32699,7 @@ var require_os_tmpdir = __commonJS({
 var require_tmp = __commonJS({
   "node_modules/tmp/lib/tmp.js"(exports2, module2) {
     "use strict";
-    var fs2 = require("fs");
+    var fs3 = require("fs");
     var path = require("path");
     var crypto3 = require("crypto");
     var osTmpDir = require_os_tmpdir();
@@ -32763,7 +32763,7 @@ var require_tmp = __commonJS({
         return cb(new Error("Invalid template provided"));
       (function _getUniqueName() {
         const name = _generateTmpName(opts);
-        fs2.stat(name, function(err) {
+        fs3.stat(name, function(err) {
           if (!err) {
             if (tries-- > 0)
               return _getUniqueName();
@@ -32782,7 +32782,7 @@ var require_tmp = __commonJS({
       do {
         const name = _generateTmpName(opts);
         try {
-          fs2.statSync(name);
+          fs3.statSync(name);
         } catch (e2) {
           return name;
         }
@@ -32795,14 +32795,14 @@ var require_tmp = __commonJS({
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err)
           return cb(err);
-        fs2.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
+        fs3.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
           if (err2)
             return cb(err2);
           if (opts.discardDescriptor) {
-            return fs2.close(fd, function _discardCallback(err3) {
+            return fs3.close(fd, function _discardCallback(err3) {
               if (err3) {
                 try {
-                  fs2.unlinkSync(name);
+                  fs3.unlinkSync(name);
                 } catch (e2) {
                   if (!isENOENT(e2)) {
                     err3 = e2;
@@ -32825,9 +32825,9 @@ var require_tmp = __commonJS({
       opts.postfix = opts.postfix || ".tmp";
       const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
       const name = tmpNameSync(opts);
-      var fd = fs2.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+      var fd = fs3.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
       if (opts.discardDescriptor) {
-        fs2.closeSync(fd);
+        fs3.closeSync(fd);
         fd = void 0;
       }
       return {
@@ -32839,9 +32839,9 @@ var require_tmp = __commonJS({
     function _rmdirRecursiveSync(root) {
       const dirs = [root];
       do {
-        var dir2 = dirs.pop(), deferred = false, files = fs2.readdirSync(dir2);
+        var dir2 = dirs.pop(), deferred = false, files = fs3.readdirSync(dir2);
         for (var i2 = 0, length = files.length; i2 < length; i2++) {
-          var file2 = path.join(dir2, files[i2]), stat2 = fs2.lstatSync(file2);
+          var file2 = path.join(dir2, files[i2]), stat2 = fs3.lstatSync(file2);
           if (stat2.isDirectory()) {
             if (!deferred) {
               deferred = true;
@@ -32849,11 +32849,11 @@ var require_tmp = __commonJS({
             }
             dirs.push(file2);
           } else {
-            fs2.unlinkSync(file2);
+            fs3.unlinkSync(file2);
           }
         }
         if (!deferred) {
-          fs2.rmdirSync(dir2);
+          fs3.rmdirSync(dir2);
         }
       } while (dirs.length !== 0);
     }
@@ -32862,7 +32862,7 @@ var require_tmp = __commonJS({
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err)
           return cb(err);
-        fs2.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
+        fs3.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
           if (err2)
             return cb(err2);
           cb(null, name, _prepareTmpDirRemoveCallback(name, opts));
@@ -32872,7 +32872,7 @@ var require_tmp = __commonJS({
     function dirSync(options) {
       var args = _parseArguments(options), opts = args[0];
       const name = tmpNameSync(opts);
-      fs2.mkdirSync(name, opts.mode || DIR_MODE);
+      fs3.mkdirSync(name, opts.mode || DIR_MODE);
       return {
         name,
         removeCallback: _prepareTmpDirRemoveCallback(name, opts)
@@ -32882,7 +32882,7 @@ var require_tmp = __commonJS({
       const removeCallback = _prepareRemoveCallback(function _removeCallback(fdPath) {
         try {
           if (0 <= fdPath[0]) {
-            fs2.closeSync(fdPath[0]);
+            fs3.closeSync(fdPath[0]);
           }
         } catch (e2) {
           if (!isEBADF(e2) && !isENOENT(e2)) {
@@ -32890,7 +32890,7 @@ var require_tmp = __commonJS({
           }
         }
         try {
-          fs2.unlinkSync(fdPath[1]);
+          fs3.unlinkSync(fdPath[1]);
         } catch (e2) {
           if (!isENOENT(e2)) {
             throw e2;
@@ -32903,7 +32903,7 @@ var require_tmp = __commonJS({
       return removeCallback;
     }
     function _prepareTmpDirRemoveCallback(name, opts) {
-      const removeFunction = opts.unsafeCleanup ? _rmdirRecursiveSync : fs2.rmdirSync.bind(fs2);
+      const removeFunction = opts.unsafeCleanup ? _rmdirRecursiveSync : fs3.rmdirSync.bind(fs3);
       const removeCallback = _prepareRemoveCallback(removeFunction, name);
       if (!opts.keep) {
         _removeObjects.unshift(removeCallback);
@@ -32948,10 +32948,10 @@ var require_tmp = __commonJS({
     function setGracefulCleanup() {
       _gracefulCleanup = true;
     }
-    var version = process.versions.node.split(".").map(function(value) {
+    var version2 = process.versions.node.split(".").map(function(value) {
       return parseInt(value, 10);
     });
-    if (version[0] === 0 && (version[1] < 9 || version[1] === 9 && version[2] < 5)) {
+    if (version2[0] === 0 && (version2[1] < 9 || version2[1] === 9 && version2[2] < 5)) {
       process.addListener("uncaughtException", function _uncaughtExceptionThrown(err) {
         _uncaughtException = true;
         _garbageCollector();
@@ -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) {
@@ -39555,6 +39894,9 @@ var {
   Help
 } = import_index.default;
 
+// package.json
+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.";
 
@@ -39836,10 +40178,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 3;
   }
   if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env.TERM_PROGRAM) {
       case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
+        return version2 >= 3 ? 3 : 2;
       }
       case "Apple_Terminal": {
         return 2;
@@ -42145,6 +42487,36 @@ 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);
 var import_node_https = __toESM(require("https"), 1);
@@ -43498,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"'`
-});
-var AVAILABLE_PLATFORMS = ["darwin", "win32", "linux"];
-var STARTING_TIMEOUT_WAIT_CYLCE = 2e3;
-var STARTING_TIMEOUT_ATTEMPTS = 60;
-
 // src/lib/clients/jsonRpcClient.ts
 var JsonRpcClient = class {
   constructor(serverUrl) {
@@ -43567,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}`);
@@ -43601,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 = {
@@ -43630,9 +44005,12 @@ 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) {
-      if (error.toString().includes("already exists and is not an empty directory")) {
+      const simulatorLocationExists = fs2.existsSync(simulatorLocation);
+      if (simulatorLocationExists) {
         return { wasInstalled: true };
       }
       throw error;
@@ -43643,17 +44021,29 @@ function downloadSimulator() {
 function updateSimulator() {
   return __async(this, null, function* () {
     const simulatorLocation = getSimulatorLocation();
-    try {
-      yield executeCommand(`cd ${simulatorLocation} && git pull`, "git");
-    } catch (error) {
-      if (error.toString().includes("already exists and is not an empty directory")) {
-        return { wasInstalled: true };
-      }
-      throw error;
-    }
+    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!");
   });
 }
@@ -43776,7 +44245,7 @@ function initializeGeneralCommands(program2) {
 }
 
 // src/index.ts
-program.version("0.0.1").description(CLI_DESCRIPTION);
+program.version(version).description(CLI_DESCRIPTION);
 initializeGeneralCommands(program);
 program.parse(process.argv);
 /*! Bundled license information:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.0.19",
+  "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/index.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {program} from "commander";
-
+import {version} from "../package.json";
 import {CLI_DESCRIPTION} from "@/lib/config/text";
 import {initializeGeneralCommands} from "@/commands/general";
 
-program.version("0.0.1").description(CLI_DESCRIPTION);
+program.version(version).description(CLI_DESCRIPTION);
 
 initializeGeneralCommands(program);
 

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"'`,
+  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 = 60;
+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,9 +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,
@@ -22,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 = {
@@ -57,9 +87,12 @@ 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) {
-    if (error.toString().includes("already exists and is not an empty directory")) {
+    const simulatorLocationExists = fs.existsSync(simulatorLocation);
+    if (simulatorLocationExists) {
       return {wasInstalled: true};
     }
     throw error;
@@ -69,44 +102,64 @@ export async function downloadSimulator(): Promise<DownloadSimulatorResultType>
 
 export async function updateSimulator(): Promise<DownloadSimulatorResultType> {
   const simulatorLocation = getSimulatorLocation();
-
-  try {
-    await executeCommand(`cd ${simulatorLocation} && git pull`, "git");
-  } catch (error: any) {
-    if (error.toString().includes("already exists and is not an empty directory")) {
-      return {wasInstalled: true};
-    }
-    throw error;
-  }
+  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 = {
@@ -119,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};
+  });
+}

package/tsconfig.json

@@ -45,7 +45,7 @@
     // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
     // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
     // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    "resolveJsonModule": true /* Enable importing .json files. */,
     // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
     // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */