genlayer 0.38.8 → 0.38.10

package/src/commands/general/start.ts

@@ -0,0 +1,128 @@
+import inquirer from "inquirer";
+import {ISimulatorService} from "../../lib/interfaces/ISimulatorService";
+import {DistinctQuestion} from "inquirer";
+import {BaseAction} from "../../lib/actions/BaseAction";
+import {SimulatorService} from "../../lib/services/simulator";
+
+export interface StartActionOptions {
+  resetValidators: boolean;
+  numValidators: number;
+  headless: boolean;
+  resetDb: boolean;
+  ollama: boolean;
+}
+
+export class StartAction extends BaseAction {
+  private simulatorService: ISimulatorService;
+
+  constructor() {
+    super();
+    this.simulatorService = new SimulatorService();
+  }
+
+  async execute(options: StartActionOptions) {
+    const {resetValidators, numValidators, headless, resetDb, ollama} = options;
+
+    this.simulatorService.setComposeOptions(headless, ollama);
+    this.startSpinner("Checking CLI version...");
+    await this.simulatorService.checkCliVersion();
+
+    this.setSpinnerText("Checking Docker...");
+    try {
+      await this.simulatorService.ensureDockerRunning();
+    } catch (error) {
+      this.failSpinner(
+        "Docker is not running. Please start Docker Desktop and try again.",
+        error,
+      );
+      return;
+    }
+
+    const isRunning = await this.simulatorService.isLocalnetRunning();
+    if (isRunning) {
+      this.stopSpinner();
+      await this.confirmPrompt("GenLayer Localnet is already running. Do you want to proceed?");
+      this.startSpinner("Stopping Docker containers...");
+      await this.simulatorService.stopDockerContainers();
+    }
+
+    const restartValidatorsHintText = resetValidators
+      ? `creating new ${numValidators} random validators`
+      : "keeping the existing validators";
+    this.setSpinnerText(`Starting GenLayer Localnet (${restartValidatorsHintText})...`);
+
+    try {
+      this.simulatorService.setupLocalhostAccess();
+      await this.simulatorService.runSimulator();
+    } catch (error) {
+      this.failSpinner("Error starting the simulator", error);
+      return;
+    }
+
+    try {
+      this.setSpinnerText("Waiting for the simulator to be ready...");
+      const {initialized, errorCode, errorMessage} = await this.simulatorService.waitForSimulatorToBeReady();
+
+      if (!initialized) {
+        if (errorCode === "ERROR") {
+          this.failSpinner("Unable to initialize the GenLayer simulator.", errorMessage);
+          return;
+        }
+        if (errorCode === "TIMEOUT") {
+          this.failSpinner("The simulator is taking too long to initialize. Please try again later.");
+          return;
+        }
+      }
+    } catch (error) {
+      this.failSpinner("Error waiting for the simulator to be ready", error);
+      return;
+    }
+
+    if (resetDb) {
+      this.setSpinnerText("Resetting database...");
+      await this.simulatorService.cleanDatabase();
+    }
+
+    if (resetValidators) {
+      this.setSpinnerText("Initializing validators...");
+      try {
+        await this.simulatorService.deleteAllValidators();
+
+        const questions: DistinctQuestion[] = [
+          {
+            type: "checkbox",
+            name: "selectedLlmProviders",
+            message: "Select which LLM providers do you want to use:",
+            choices: this.simulatorService.getAiProvidersOptions(false, ollama ? [] : ["ollama"]),
+            validate: answer => (answer.length < 1 ? "You must choose at least one option." : true),
+          },
+        ];
+
+        const llmProvidersAnswer = await inquirer.prompt(questions);
+        await this.simulatorService.createRandomValidators(
+          numValidators,
+          llmProvidersAnswer.selectedLlmProviders,
+        );
+      } catch (error) {
+        this.failSpinner("Unable to initialize the validators", error);
+        return;
+      }
+    }
+
+    let successMessage = "GenLayer simulator initialized successfully! ";
+    successMessage += headless
+      ? ""
+      : `Go to ${this.simulatorService.getFrontendUrl()} in your browser to access it.`;
+    this.succeedSpinner(successMessage);
+
+    if (!headless) {
+      try {
+        this.startSpinner("Opening frontend...");
+        await this.simulatorService.openFrontend();
+        this.succeedSpinner("Frontend opened successfully");
+      } catch (error) {
+        this.failSpinner("Error opening the frontend", error);
+      }
+    }
+  }
+}

package/src/commands/general/stop.ts

@@ -0,0 +1,26 @@
+import { BaseAction } from "../../lib/actions/BaseAction";
+import { SimulatorService } from "../../lib/services/simulator";
+import { ISimulatorService } from "../../lib/interfaces/ISimulatorService";
+
+export class StopAction extends BaseAction {
+  private simulatorService: ISimulatorService;
+
+  constructor() {
+    super();
+    this.simulatorService = new SimulatorService();
+  }
+
+  public async stop(): Promise<void> {
+    try {
+      await this.confirmPrompt(
+        "Are you sure you want to stop all running GenLayer containers? This will halt all active processes."
+      );
+
+      this.startSpinner("Stopping Docker containers...");
+      await this.simulatorService.stopDockerContainers();
+      this.succeedSpinner("All running GenLayer containers have been successfully stopped.");
+    } catch (error) {
+      this.failSpinner("An error occurred while stopping the containers.", error);
+    }
+  }
+}

package/src/commands/localnet/index.ts

@@ -0,0 +1,100 @@
+import { Command } from "commander";
+import { ValidatorsAction } from "./validators";
+
+export function initializeValidatorCommands(program: Command) {
+  const validatorsAction = new ValidatorsAction();
+
+  const localnetCommand = program
+    .command("localnet")
+    .description("Manage localnet operations");
+
+  const validatorsCommand = localnetCommand
+    .command("validators")
+    .description("Manage localnet validators operations");
+
+  validatorsCommand
+    .command("get")
+
+    .description("Retrieve details of a specific validator or all validators")
+    .option("--address <validatorAddress>", "The address of the validator to retrieve (omit to retrieve all validators)")
+    .action(async (options) => {
+      await validatorsAction.getValidator({ address: options.address });
+    });
+
+  validatorsCommand
+    .command("delete")
+    .description("Delete a specific validator or all validators")
+    .option("--address <validatorAddress>", "The address of the validator to delete (omit to delete all validators)")
+    .action(async (options) => {
+      await validatorsAction.deleteValidator({ address: options.address });
+    });
+
+  validatorsCommand
+    .command("count")
+    .description("Count all validators")
+    .action(async () => {
+      await validatorsAction.countValidators();
+    });
+
+  validatorsCommand
+    .command("update <validatorAddress>")
+    .description("Update a validator's details")
+    .option("--stake <stake>", "New stake for the validator")
+    .option("--provider <provider>", "New provider for the validator")
+    .option("--model <model>", "New model for the validator")
+    .option("--config <config>", "New JSON config for the validator")
+    .action(async (validatorAddress, options) => {
+      await validatorsAction.updateValidator({
+        address: validatorAddress,
+        stake: options.stake,
+        provider: options.provider,
+        model: options.model,
+        config: options.config,
+      });
+    });
+
+  validatorsCommand
+    .command("create-random")
+    .description("Create random validators")
+    .option("--count <count>", "Number of validators to create", "1") // Default to "1"
+    .option(
+      "--providers <providers...>",
+      "Space-separated list of provider names (e.g., openai ollama)",
+      []
+    )
+    .option(
+      "--models <models...>",
+      "Space-separated list of model names (e.g., gpt-4 gpt-4o)",
+      []
+    )
+    .action(async (options) => {
+      await validatorsAction.createRandomValidators({
+        count: options.count,
+        providers: options.providers,
+        models: options.models,
+      });
+    });
+
+  validatorsCommand
+    .command("create")
+    .description("Create a new validator")
+    .option("--stake <stake>", "Stake amount for the validator (default: 1)", "1")
+    .option(
+      "--config <config>",
+      `Optional JSON configuration for the validator (e.g., '{"max_tokens": 500, "temperature": 0.75}')`
+    )
+    .option("--provider <provider>", "Specify the provider for the validator")
+    .option("--model <model>", "Specify the model for the validator")
+    .action(async (options) => {
+      await validatorsAction.createValidator({
+        stake: options.stake,
+        config: options.config,
+        provider: options.provider,
+        model: options.model,
+      });
+    });
+
+  return program;
+}
+
+

package/src/commands/localnet/validators.ts

@@ -0,0 +1,269 @@
+import inquirer from "inquirer";
+import { rpcClient } from "../../lib/clients/jsonRpcClient";
+import { BaseAction } from "../../lib/actions/BaseAction";
+
+export interface ValidatorOptions {
+  address?: string;
+}
+
+export interface UpdateValidatorOptions {
+  address: string;
+  stake?: string;
+  provider?: string;
+  model?: string;
+  config?: string;
+}
+
+export interface CreateRandomValidatorsOptions {
+  count: string;
+  providers: string[];
+  models: string[];
+}
+
+export interface CreateValidatorOptions {
+  stake: string;
+  config?: string;
+  model?: string;
+  provider?: string;
+}
+
+export class ValidatorsAction extends BaseAction {
+  public async getValidator(options: ValidatorOptions): Promise<void> {
+    try {
+      if (options.address) {
+        this.startSpinner(`Fetching validator with address: ${options.address}`);
+
+        const result = await rpcClient.request({
+          method: "sim_getValidator",
+          params: [options.address],
+        });
+
+        this.succeedSpinner(`Successfully fetched validator with address: ${options.address}`, result.result);
+      } else {
+        this.startSpinner(`Fetching all validators...`);
+
+        const result = await rpcClient.request({
+          method: "sim_getAllValidators",
+          params: [],
+        });
+        this.succeedSpinner('Successfully fetched all validators.', result.result)
+      }
+    } catch (error) {
+      this.failSpinner("Error fetching validators", error);
+    }
+  }
+
+  public async deleteValidator(options: ValidatorOptions): Promise<void> {
+    try {
+      if (options.address) {
+        await this.confirmPrompt(`This command will delete the validator with the address: ${options.address}. Do you want to continue?`);
+        this.startSpinner(`Deleting validator with address: ${options.address}`);
+
+        const result = await rpcClient.request({
+          method: "sim_deleteValidator",
+          params: [options.address],
+        });
+
+        this.succeedSpinner(`Deleted Address: ${result.result}`);
+      } else {
+        await this.confirmPrompt(`This command will delete all validators. Do you want to continue?`);
+        this.startSpinner("Deleting all validators...");
+
+        await rpcClient.request({
+          method: "sim_deleteAllValidators",
+          params: [],
+        });
+
+        this.succeedSpinner("Successfully deleted all validators");
+      }
+    } catch (error) {
+      this.failSpinner("Error deleting validators", error);
+    }
+  }
+
+  public async countValidators(): Promise<void> {
+    try {
+      this.startSpinner("Counting all validators...");
+
+      const result = await rpcClient.request({
+        method: "sim_countValidators",
+        params: [],
+      });
+      this.succeedSpinner(`Total Validators: ${result.result}`);
+    } catch (error) {
+      this.failSpinner("Error counting validators", error);
+    }
+  }
+
+  public async updateValidator(options: UpdateValidatorOptions): Promise<void> {
+    try {
+      this.startSpinner(`Fetching validator with address: ${options.address}...`);
+      const currentValidator = await rpcClient.request({
+        method: "sim_getValidator",
+        params: [options.address],
+      });
+
+      this.log("Current Validator Details:", currentValidator.result);
+
+      const parsedStake = options.stake
+        ? parseInt(options.stake, 10)
+        : currentValidator.result.stake;
+
+      if (isNaN(parsedStake) || parsedStake < 0) {
+        return this.failSpinner("Invalid stake value. Stake must be a positive integer.");
+      }
+
+      const updatedValidator = {
+        address: options.address,
+        stake: options.stake || currentValidator.result.stake,
+        provider: options.provider || currentValidator.result.provider,
+        model: options.model || currentValidator.result.model,
+        config: options.config ? JSON.parse(options.config) : currentValidator.result.config,
+      };
+
+      this.log("Updated Validator Details:", updatedValidator);
+
+      this.setSpinnerText('Updating Validator...');
+
+      const result = await rpcClient.request({
+        method: "sim_updateValidator",
+        params: [
+          updatedValidator.address,
+          updatedValidator.stake,
+          updatedValidator.provider,
+          updatedValidator.model,
+          updatedValidator.config,
+        ],
+      });
+
+      this.succeedSpinner("Validator successfully updated", result.result);
+    } catch (error) {
+      this.failSpinner("Error updating validator", error);
+    }
+  }
+
+  public async createRandomValidators(options: CreateRandomValidatorsOptions): Promise<void> {
+    try {
+      const count = parseInt(options.count, 10);
+      if (isNaN(count) || count < 1) {
+        return this.logError("Invalid count. Please provide a positive integer.");
+      }
+
+      this.startSpinner(`Creating ${count} random validator(s)...`);
+      this.log(`Providers: ${options.providers.length > 0 ? options.providers.join(", ") : "All"}`);
+      this.log(`Models: ${options.models.length > 0 ? options.models.join(", ") : "All"}`);
+
+      const result = await rpcClient.request({
+        method: "sim_createRandomValidators",
+        params: [count, 1, 10, options.providers, options.models],
+      });
+
+      this.succeedSpinner("Random validators successfully created", result.result);
+    } catch (error) {
+      this.failSpinner("Error creating random validators", error);
+    }
+  }
+
+  public async createValidator(options: CreateValidatorOptions): Promise<void> {
+    try {
+      const stake = parseInt(options.stake, 10);
+      if (isNaN(stake) || stake < 1) {
+        return this.logError("Invalid stake. Please provide a positive integer.");
+      }
+
+      if (options.model && !options.provider) {
+        return this.logError("You must specify a provider if using a model.");
+      }
+
+      this.startSpinner("Fetching available providers and models...");
+
+      const providersAndModels = await rpcClient.request({
+        method: "sim_getProvidersAndModels",
+        params: [],
+      });
+      this.stopSpinner();
+
+      if (!providersAndModels.result || providersAndModels.result.length === 0) {
+        return this.logError("No providers or models available.");
+      }
+
+      const availableProviders = [
+        ...new Map(
+          providersAndModels.result
+            .filter((entry: any) => entry.is_available)
+            .map((entry: any) => [entry.provider, entry])
+        ).values(),
+      ];
+
+      let provider =  options.provider
+
+      if(!provider){
+        const { selectedProvider } = await inquirer.prompt([
+          {
+            type: "list",
+            name: "selectedProvider",
+            message: "Select a provider:",
+            choices: availableProviders.map((entry: any) => entry.provider),
+          },
+        ]);
+
+        provider = selectedProvider;
+      }
+
+      const availableModels = providersAndModels.result.filter(
+        (entry: any) => entry.provider === provider && entry.is_model_available
+      );
+
+      if (availableModels.length === 0) {
+        return this.logError("No models available for the selected provider.");
+      }
+
+      let model = options.model;
+
+      if(!model){
+        const { selectedModel } = await inquirer.prompt([
+          {
+            type: "list",
+            name: "selectedModel",
+            message: "Select a model:",
+            choices: availableModels.map((entry: any) => entry.model),
+          },
+        ]);
+
+        model = selectedModel;
+      }
+
+      const modelDetails = availableModels.find(
+        (entry: any) => entry.model === model
+      );
+
+      if (!modelDetails) {
+        return this.logError("Selected model details not found.");
+      }
+
+      const config = options.config ? JSON.parse(options.config) : modelDetails.config;
+      const params = [
+        stake,
+        modelDetails.provider,
+        modelDetails.model,
+        config,
+        modelDetails.plugin,
+        modelDetails.plugin_config,
+      ]
+
+      this.log("Validator details:", params);
+      this.startSpinner('Creating validator...');
+
+      const result = await rpcClient.request({
+        method: "sim_createValidator",
+        params,
+      });
+
+      this.succeedSpinner("Validator successfully created:", result.result);
+    } catch (error) {
+      this.failSpinner("Error creating validator", error);
+    }
+  }
+}
+
+

package/src/commands/network/index.ts

@@ -0,0 +1,29 @@
+import {Command} from "commander";
+import {NetworkActions} from "./setNetwork";
+
+export function initializeNetworkCommands(program: Command) {
+  const networkActions = new NetworkActions();
+
+  const network = program.command("network").description("Network configuration");
+
+  // genlayer network set [name]
+  network
+    .command("set")
+    .description("Set the network to use")
+    .argument("[network]", "The network to set")
+    .action((networkName?: string) => networkActions.setNetwork(networkName));
+
+  // genlayer network info
+  network
+    .command("info")
+    .description("Show current network configuration and contract addresses")
+    .action(() => networkActions.showInfo());
+
+  // genlayer network list
+  network
+    .command("list")
+    .description("List available networks")
+    .action(() => networkActions.listNetworks());
+
+  return program;
+}

package/src/commands/network/setNetwork.ts

@@ -0,0 +1,77 @@
+import {BaseAction, BUILT_IN_NETWORKS, resolveNetwork} from "../../lib/actions/BaseAction";
+import inquirer, {DistinctQuestion} from "inquirer";
+
+const networks = Object.entries(BUILT_IN_NETWORKS).map(([alias, network]) => ({
+  name: network.name,
+  alias,
+  value: network,
+}));
+
+export class NetworkActions extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async showInfo(): Promise<void> {
+    const storedNetwork = this.getConfigByKey("network") || "localnet";
+    const network = resolveNetwork(storedNetwork);
+
+    const info: Record<string, string> = {
+      alias: storedNetwork,
+      name: network.name,
+      chainId: network.id?.toString() || "unknown",
+      rpc: network.rpcUrls?.default?.http?.[0] || "unknown",
+      mainContract: network.consensusMainContract?.address || "not set",
+      stakingContract: network.stakingContract?.address || "not set",
+    };
+
+    if (network.blockExplorers?.default?.url) {
+      info.explorer = network.blockExplorers.default.url;
+    }
+
+    this.succeedSpinner("Current network", info);
+  }
+
+  async listNetworks(): Promise<void> {
+    const currentNetwork = this.getConfigByKey("network") || "localnet";
+
+    console.log("");
+    for (const net of networks) {
+      const marker = net.alias === currentNetwork ? "*" : " ";
+      console.log(`${marker} ${net.alias.padEnd(16)} ${net.name}`);
+    }
+    console.log("");
+  }
+
+  async setNetwork(networkName?: string): Promise<void> {
+    if (networkName || networkName === "") {
+      if (!networks.some(n => n.name === networkName || n.alias === networkName)) {
+        this.failSpinner(`Network ${networkName} not found`);
+        return;
+      }
+      const selectedNetwork = networks.find(n => n.name === networkName || n.alias === networkName);
+      if (!selectedNetwork) {
+        this.failSpinner(`Network ${networkName} not found`);
+        return;
+      }
+      this.writeConfig("network", selectedNetwork.alias);
+      this.succeedSpinner(`Network successfully set to ${selectedNetwork.name}`);
+      return;
+    }
+
+    const networkQuestions: DistinctQuestion[] = [
+      {
+        type: "list",
+        name: "selectedNetwork",
+        message: "Select which network do you want to use:",
+        choices: networks.map(n => ({name: n.name, value: n.alias})),
+      },
+    ];
+    const networkAnswer = await inquirer.prompt(networkQuestions);
+    const selectedAlias = networkAnswer.selectedNetwork;
+    const selectedNetwork = networks.find(n => n.alias === selectedAlias)!;
+
+    this.writeConfig("network", selectedAlias);
+    this.succeedSpinner(`Network successfully set to ${selectedNetwork.name}`);
+  }
+}

package/src/commands/scaffold/index.ts

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { NewAction } from "./new";
+
+export function initializeScaffoldCommands(program: Command) {
+  program
+    .command("new <projectName>")
+    .description("Create a new GenLayer project using the default template")
+    .option("--path <directory>", "Specify the directory for the new project", ".")
+    .option("--overwrite", "Overwrite existing directory if it exists", false)
+    .action(async (projectName, options) => {
+      const newProjectAction = new NewAction();
+      await newProjectAction.createProject(projectName, options);
+    });
+
+  return program;
+}

package/src/commands/scaffold/new.ts

@@ -0,0 +1,34 @@
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import { BaseAction } from "../../lib/actions/BaseAction";
+
+export class NewAction extends BaseAction {
+  private templatePath: string;
+
+  constructor() {
+    super();
+    const __filename = fileURLToPath(import.meta.url);
+    const basePath = path.resolve(path.dirname(__filename), "..");
+    this.templatePath = path.join(basePath, "templates", "default");
+  }
+
+  async createProject(projectName: string, options: { path: string; overwrite: boolean }) {
+    const targetPath = path.resolve(options.path, projectName);
+
+    if (fs.existsSync(targetPath) && !options.overwrite) {
+      return this.failSpinner(
+        `Project directory "${targetPath}" already exists. Use --overwrite to replace it.`
+      );
+    }
+
+    this.startSpinner(`Creating new GenLayer project: ${projectName}`);
+
+    try {
+      fs.copySync(this.templatePath, targetPath);
+      this.succeedSpinner(`Project "${projectName}" created successfully at ${targetPath}`);
+    } catch (error) {
+      this.failSpinner(`Error creating project "${projectName}"`, error);
+    }
+  }
+}