genlayer 0.34.0 → 0.34.3

package/src/lib/clients/system.ts

@@ -1,73 +0,0 @@
-import util from "node:util";
-import {ChildProcess, exec} from "child_process";
-import open from "open";
-
-import {RunningPlatform, AVAILABLE_PLATFORMS} from "../config/simulator";
-import {MissingRequirementError} from "../errors/missingRequirement";
-
-export async function checkCommand(command: string, toolName: string): Promise<void> {
-  try {
-    await util.promisify(exec)(command);
-  }catch (error:any) {
-    if (error.stderr) {
-      throw new MissingRequirementError(toolName);
-    }
-  }
-}
-
-type ExecuteCommandResult = {
-  stdout: string;
-  stderr: string;
-};
-
-type ExecuteCommandByPlatformInput = {
-  [key in RunningPlatform]: string;
-};
-
-export async function executeCommand(
-  cmdsByPlatform: ExecuteCommandByPlatformInput,
-  toolName?: string,
-): Promise<ExecuteCommandResult> {
-  const runningPlatform = getPlatform();
-  const command = cmdsByPlatform[runningPlatform];
-  try {
-    return await util.promisify(exec)(command);
-  } catch (error: any) {
-    throw new Error(`Error executing ${toolName || command}: ${error.message}.`);
-  }
-}
-
-function getPlatform(): RunningPlatform {
-  const currentPlatform = process.platform as RunningPlatform;
-  if (!AVAILABLE_PLATFORMS.includes(currentPlatform)) {
-    throw new Error(`Unsupported platform: ${currentPlatform}.`);
-  }
-  return currentPlatform;
-}
-
-export function openUrl(url: string): Promise<ChildProcess> {
-  return open(url);
-}
-
-export async function getVersion(toolName: string): Promise<string> {
-  try {
-    const toolResponse = await util.promisify(exec)(`${toolName} --version`);
-
-    if (toolResponse.stderr) {
-      throw new Error(toolResponse.stderr);
-    }
-
-    try {
-      const versionMatch = toolResponse.stdout.match(/(\d+\.\d+\.\d+)/);
-      if (versionMatch) {
-        return versionMatch[1];
-      }
-    } catch (err) {
-      throw new Error(`Could not parse ${toolName} version.`);
-    }
-  } catch (error) {
-    throw new Error(`Error getting ${toolName} version.`);
-  }
-
-  return "";
-}

package/src/lib/config/ConfigFileManager.ts

@@ -1,194 +0,0 @@
-import path from "path";
-import os from "os";
-import fs from "fs";
-
-export interface AccountInfo {
-  name: string;
-  address: string;
-  path: string;
-}
-
-export class ConfigFileManager {
-  private folderPath: string;
-  private configFilePath: string;
-  private keystoresPath: string;
-
-  constructor(baseFolder: string = ".genlayer/", configFileName: string = "genlayer-config.json") {
-    this.folderPath = path.resolve(os.homedir(), baseFolder);
-    this.configFilePath = path.resolve(this.folderPath, configFileName);
-    this.keystoresPath = path.resolve(this.folderPath, "keystores");
-    this.ensureFolderExists();
-    this.ensureKeystoresDirExists();
-    this.ensureConfigFileExists();
-    this.migrateOldConfig();
-    this.migrateKeystoreFormats();
-  }
-
-  private ensureFolderExists(): void {
-    if (!fs.existsSync(this.folderPath)) {
-      fs.mkdirSync(this.folderPath, { recursive: true });
-    }
-  }
-
-  private ensureKeystoresDirExists(): void {
-    if (!fs.existsSync(this.keystoresPath)) {
-      fs.mkdirSync(this.keystoresPath, { recursive: true });
-    }
-  }
-
-  private ensureConfigFileExists(): void {
-    if (!fs.existsSync(this.configFilePath)) {
-      fs.writeFileSync(this.configFilePath, JSON.stringify({}, null, 2));
-    }
-  }
-
-  private migrateOldConfig(): void {
-    const config = this.getConfig();
-    if (config.keyPairPath && !config.activeAccount) {
-      const oldPath = config.keyPairPath;
-      if (fs.existsSync(oldPath)) {
-        const newPath = this.getKeystorePath("default");
-        // Read old keystore and convert format if needed
-        const content = fs.readFileSync(oldPath, "utf-8");
-        const web3Content = this.convertToWeb3Format(content);
-        fs.writeFileSync(newPath, web3Content);
-        delete config.keyPairPath;
-        config.activeAccount = "default";
-        fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
-      }
-    }
-  }
-
-  private migrateKeystoreFormats(): void {
-    if (!fs.existsSync(this.keystoresPath)) {
-      return;
-    }
-    const files = fs.readdirSync(this.keystoresPath);
-    if (!Array.isArray(files)) {
-      return;
-    }
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue;
-      const filePath = path.resolve(this.keystoresPath, file);
-      try {
-        const content = fs.readFileSync(filePath, "utf-8");
-        const parsed = JSON.parse(content);
-        // Check if it's old GenLayer format (has 'encrypted' string field)
-        if (parsed.encrypted && typeof parsed.encrypted === "string") {
-          const web3Content = this.convertToWeb3Format(content);
-          fs.writeFileSync(filePath, web3Content);
-        }
-        // If it has 'crypto' field, it's already web3 format - skip
-      } catch {
-        // Skip files that can't be parsed
-      }
-    }
-  }
-
-  private convertToWeb3Format(content: string): string {
-    try {
-      const parsed = JSON.parse(content);
-      // If it's GenLayer wrapper format (has 'encrypted' string field)
-      if (parsed.encrypted && typeof parsed.encrypted === "string") {
-        // The 'encrypted' field contains the actual web3 keystore JSON
-        return parsed.encrypted;
-      }
-      // Already web3 format or unknown - return as-is
-      return content;
-    } catch {
-      return content;
-    }
-  }
-
-  getFolderPath(): string {
-    return this.folderPath;
-  }
-
-  getFilePath(fileName: string): string {
-    return path.resolve(this.folderPath, fileName);
-  }
-
-  getConfig(): Record<string, any> {
-    const configContent = fs.readFileSync(this.configFilePath, "utf-8");
-    return JSON.parse(configContent);
-  }
-
-  getConfigByKey(key: string): any {
-    const config = this.getConfig();
-    return config[key] !== undefined ? config[key] : null;
-  }
-
-  writeConfig(key: string, value: any): void {
-    const config = this.getConfig();
-    config[key] = value;
-    fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
-  }
-
-  removeConfig(key: string): void {
-    const config = this.getConfig();
-    delete config[key];
-    fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
-  }
-
-  getKeystoresPath(): string {
-    return this.keystoresPath;
-  }
-
-  getKeystorePath(name: string): string {
-    return path.resolve(this.keystoresPath, `${name}.json`);
-  }
-
-  accountExists(name: string): boolean {
-    return fs.existsSync(this.getKeystorePath(name));
-  }
-
-  getActiveAccount(): string | null {
-    return this.getConfigByKey("activeAccount");
-  }
-
-  setActiveAccount(name: string): void {
-    if (!this.accountExists(name)) {
-      throw new Error(`Account '${name}' does not exist`);
-    }
-    this.writeConfig("activeAccount", name);
-  }
-
-  listAccounts(): AccountInfo[] {
-    if (!fs.existsSync(this.keystoresPath)) {
-      return [];
-    }
-    const files = fs.readdirSync(this.keystoresPath);
-    const accounts: AccountInfo[] = [];
-
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue;
-      const name = file.replace(".json", "");
-      const filePath = this.getKeystorePath(name);
-      try {
-        const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-        const addr = content.address || "unknown";
-        accounts.push({
-          name,
-          address: addr.startsWith("0x") ? addr : `0x${addr}`,
-          path: filePath,
-        });
-      } catch {
-        // Skip invalid files
-      }
-    }
-    return accounts;
-  }
-
-  removeAccount(name: string): void {
-    const keystorePath = this.getKeystorePath(name);
-    if (!fs.existsSync(keystorePath)) {
-      throw new Error(`Account '${name}' does not exist`);
-    }
-    fs.unlinkSync(keystorePath);
-
-    // If this was the active account, clear it
-    if (this.getActiveAccount() === name) {
-      this.removeConfig("activeAccount");
-    }
-  }
-}

package/src/lib/config/KeychainManager.ts

@@ -1,89 +0,0 @@
-type Keytar = typeof import('keytar').default;
-
-let keytarModule: Keytar | null = null;
-let keytarLoadAttempted = false;
-
-async function getKeytar(): Promise<Keytar | null> {
-  if (keytarLoadAttempted) return keytarModule;
-  keytarLoadAttempted = true;
-  try {
-    const mod = await import('keytar');
-    keytarModule = mod.default ?? mod;
-    return keytarModule;
-  } catch {
-    return null;
-  }
-}
-
-export class KeychainManager {
-  private static readonly SERVICE = 'genlayer-cli';
-
-  constructor() {}
-
-  private getKeychainAccount(accountName: string): string {
-    return `account:${accountName}`;
-  }
-
-  async isKeychainAvailable(): Promise<boolean> {
-    try {
-      const keytar = await getKeytar();
-      if (!keytar) return false;
-      await keytar.findCredentials('test-service');
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async storePrivateKey(accountName: string, privateKey: string): Promise<void> {
-    const keytar = await getKeytar();
-    if (!keytar) throw new Error('Keychain not available. Install libsecret-1-dev on Linux.');
-    try {
-      return await keytar.setPassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName), privateKey);
-    } catch (error: any) {
-      if (error?.message?.includes('org.freedesktop.secrets')) {
-        throw new Error('Keychain service not running. Install and start gnome-keyring or another secrets service.');
-      }
-      throw error;
-    }
-  }
-
-  async getPrivateKey(accountName: string): Promise<string | null> {
-    const keytar = await getKeytar();
-    if (!keytar) return null;
-    try {
-      return await keytar.getPassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName));
-    } catch {
-      return null;
-    }
-  }
-
-  async removePrivateKey(accountName: string): Promise<boolean> {
-    const keytar = await getKeytar();
-    if (!keytar) return false;
-    try {
-      return await keytar.deletePassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName));
-    } catch {
-      return false;
-    }
-  }
-
-  async listUnlockedAccounts(): Promise<string[]> {
-    const keytar = await getKeytar();
-    if (!keytar) return [];
-    try {
-      const credentials = await keytar.findCredentials(KeychainManager.SERVICE);
-      return credentials
-        .map(c => c.account)
-        .filter(a => a.startsWith('account:'))
-        .map(a => a.replace('account:', ''));
-    } catch {
-      return [];
-    }
-  }
-
-  async isAccountUnlocked(accountName: string): Promise<boolean> {
-    const key = await this.getPrivateKey(accountName);
-    return key !== null;
-  }
-} 

package/src/lib/config/simulator.ts

@@ -1,68 +0,0 @@
-export const localnetCompatibleVersion = "v0.65.0";
-export const DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
-export const CONTAINERS_NAME_PREFIX = "/genlayer-";
-export const IMAGES_NAME_PREFIX = "yeagerai";
-export const DEFAULT_RUN_SIMULATOR_COMMAND = (location: string, profiles: string) => ({
-  darwin: `osascript -e 'tell application "Terminal" to do script "cd ${location} && docker compose build && docker compose -p genlayer ${profiles} up"'`,
-  win32: `start cmd.exe /c "cd /d ${location} && docker compose build && docker compose -p genlayer ${profiles} up && pause"`,
-  linux: `nohup bash -c 'cd ${location} && docker compose build && docker compose -p genlayer ${profiles} up -d '`,
-});
-export const DEFAULT_RUN_DOCKER_COMMAND = {
-  darwin: "open -a Docker",
-  win32: 'start "" "C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe"',
-  linux: "sudo systemctl start docker",
-};
-
-export const VERSION_REQUIREMENTS = {
-  docker: "25.0.0",
-  node: "18.0.0",
-};
-
-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" | "heuristai" | "geminiai" | "xai";
-export type AiProvidersEnvVars = "ollama" | "OPENAIKEY" | "HEURISTAIAPIKEY" | "GEMINI_API_KEY" | "XAI_API_KEY";
-export type AiProvidersConfigType = {
-  [key in AiProviders]: {name: string; hint: string; envVar?: AiProvidersEnvVars; cliOptionValue: string};
-};
-
-export const AI_PROVIDERS_CONFIG: AiProvidersConfigType = {
-  ollama: {
-    name: "Ollama",
-    hint: "(By default, this will download and run a local instance of Llama 3)",
-    cliOptionValue: "ollama",
-  },
-  openai: {
-    name: "OpenAI",
-    hint: "(You will need to provide an OpenAI API key)",
-    envVar: "OPENAIKEY",
-    cliOptionValue: "openai",
-  },
-  heuristai: {
-    name: "Heurist",
-    hint: '(You will need to provide an API key. Get free API credits at https://dev-api-form.heurist.ai/ with referral code: "genlayer")',
-    envVar: "HEURISTAIAPIKEY",
-    cliOptionValue: "heuristai",
-  },
-  geminiai: {
-    name: "Gemini",
-    hint: '(You will need to provide an API key.)',
-    envVar: "GEMINI_API_KEY",
-    cliOptionValue: "geminiai",
-  },
-  xai: {
-    name: "XAI",
-    hint: '(You will need to provide an API key)',
-    envVar: "XAI_API_KEY",
-    cliOptionValue: "xai",
-  },
-};
-
-export const GENLAYER_REQUIRED_CONTAINERS = [
-  "genlayer-jsonrpc",
-  "genlayer-webrequest",
-  "genlayer-postgres"
-]

package/src/lib/config/text.ts

@@ -1,2 +0,0 @@
-export const 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.";

package/src/lib/errors/missingRequirement.ts

@@ -1,9 +0,0 @@
-export class MissingRequirementError extends Error {
-  requirement: string;
-
-  constructor(requirement: string) {
-    super(`${requirement} is not installed. Please install ${requirement}.`);
-    this.name = "MissingRequirement";
-    this.requirement = requirement;
-  }
-}

package/src/lib/errors/versionRequired.ts

@@ -1,9 +0,0 @@
-export class VersionRequiredError extends Error {
-  tool: string;
-
-  constructor(tool: string, requiredVersion: string) {
-    super(`${tool} version ${requiredVersion} or higher is required. Please update ${tool}.`);
-    this.name = "VersionRequired";
-    this.tool = tool;
-  }
-}

package/src/lib/interfaces/ISimulatorService.ts

@@ -1,37 +0,0 @@
-import {AiProviders} from "../config/simulator";
-
-export interface ISimulatorService {
-  setComposeOptions(headless: boolean, disableOllama?: boolean): void;
-  getComposeOptions(): string;
-  checkInstallRequirements(): Promise<Record<string, boolean>>;
-  checkVersionRequirements(): Promise<Record<string, string>>;
-  runSimulator(): Promise<{stdout: string; stderr: string}>;
-  waitForSimulatorToBeReady(retries?: number): Promise<WaitForSimulatorToBeReadyResultType>;
-  createRandomValidators(numValidators: number, llmProviders: AiProviders[]): Promise<any>;
-  deleteAllValidators(): Promise<any>;
-  getAiProvidersOptions(withHint: boolean, excludeProviders?: AiProviders[]): Array<{name: string; value: string}>;
-  getFrontendUrl(): string;
-  openFrontend(): Promise<boolean>;
-  stopDockerContainers(): Promise<void>;
-  resetDockerContainers(): Promise<void>;
-  resetDockerImages(): Promise<void>;
-  resetDockerVolumes(): Promise<void>;
-  checkCliVersion(): Promise<void>;
-  cleanDatabase(): Promise<boolean>;
-  addConfigToEnvFile(newConfig: Record<string, string>): void;
-  normalizeLocalnetVersion(version: string): string;
-  compareVersions(version1: string, version2: string): number;
-  isLocalnetRunning(): Promise<boolean>;
-}
-
-
-export type WaitForSimulatorToBeReadyResultType = {
-  initialized: boolean;
-  errorCode?: "TIMEOUT" | "ERROR";
-  errorMessage?: string;
-};
-
-export type InitializeDatabaseResultType = {
-  createResponse: any;
-  tablesResponse: any;
-};