genlayer 0.10.1 → 0.10.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 
 
+## 0.10.2 (2025-01-30)
+
+
+### Bug Fixes
+
+* updated studio version ([#174](https://github.com/yeagerai/genlayer-cli/issues/174)) ([e70e7f2](https://github.com/yeagerai/genlayer-cli/commit/e70e7f2e549abc9c9633ae066820fb272c9334ee))
+
 ## 0.10.1 (2025-01-29)
 
 

package/dist/index.js

@@ -54537,7 +54537,7 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.10.1";
+var version = "0.10.2";
 var package_default = {
   name: "genlayer",
   version,
@@ -54678,7 +54678,7 @@ function v4(options, buf, offset) {
 var v4_default = v4;
 
 // src/lib/config/simulator.ts
-var localnetCompatibleVersion = "v0.34.3";
+var localnetCompatibleVersion = "v0.35.2";
 var DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
 var CONTAINERS_NAME_PREFIX = "/genlayer-";
 var IMAGES_NAME_PREFIX = "yeagerai";
@@ -54726,26 +54726,23 @@ var JsonRpcClient = class {
     this.serverUrl = serverUrl;
   }
   async request({ method, params }) {
-    try {
-      const response = await (0, import_node_fetch.default)(this.serverUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: v4_default(),
-          method,
-          params
-        })
-      });
-      if (response.ok) {
-        return response.json();
-      }
-    } catch (error) {
-      throw new Error(`Fetch Error: ${error.message}`);
+    const response = await (0, import_node_fetch.default)(this.serverUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: v4_default(),
+        method,
+        params
+      })
+    });
+    if (response.ok) {
+      return response.json();
     }
-    return null;
+    const result = await response.json();
+    throw new Error(result?.error?.message || response.statusText);
   }
 };
 var rpcClient = new JsonRpcClient(DEFAULT_JSON_RPC_URL);
@@ -55382,12 +55379,12 @@ Run npm install -g genlayer to update
   }
   createRandomValidators(numValidators, llmProviders) {
     return rpcClient.request({
-      method: "create_random_validators",
+      method: "sim_createRandomValidators",
       params: [numValidators, 1, 10, llmProviders]
     });
   }
   deleteAllValidators() {
-    return rpcClient.request({ method: "delete_all_validators", params: [] });
+    return rpcClient.request({ method: "sim_deleteAllValidators", params: [] });
   }
   getAiProvidersOptions(withHint = true) {
     return Object.values(AI_PROVIDERS_CONFIG).map((providerConfig) => {
@@ -86776,6 +86773,273 @@ function initializeConfigCommands(program2) {
   return program2;
 }
 
+// src/lib/actions/BaseAction.ts
+var BaseAction = class {
+  async confirmPrompt(message) {
+    const answer = await lib_default.prompt([
+      {
+        type: "confirm",
+        name: "confirmAction",
+        message,
+        default: true
+      }
+    ]);
+    if (!answer.confirmAction) {
+      console.log("Operation aborted!");
+      process.exit(0);
+    }
+  }
+};
+
+// src/commands/validators/validators.ts
+var ValidatorsAction = class extends BaseAction {
+  async getValidator(options) {
+    try {
+      if (options.address) {
+        console.log(`Fetching validator with address: ${options.address}`);
+        const result = await rpcClient.request({
+          method: "sim_getValidator",
+          params: [options.address]
+        });
+        console.log("Validator Details:", result.result);
+      } else {
+        console.log("Fetching all validators...");
+        const result = await rpcClient.request({
+          method: "sim_getAllValidators",
+          params: []
+        });
+        console.log("All Validators:", result.result);
+      }
+    } catch (error) {
+      console.error("Error fetching validators:", error);
+    }
+  }
+  async deleteValidator(options) {
+    try {
+      if (options.address) {
+        await this.confirmPrompt(`This command will delete the validator with the address: ${options.address}. Do you want to continue?`);
+        console.log(`Deleting validator with address: ${options.address}`);
+        const result = await rpcClient.request({
+          method: "sim_deleteValidator",
+          params: [options.address]
+        });
+        console.log("Deleted Address:", result.result);
+      } else {
+        await this.confirmPrompt(`This command will delete all validators. Do you want to continue?`);
+        console.log("Deleting all validators...");
+        await rpcClient.request({
+          method: "sim_deleteAllValidators",
+          params: []
+        });
+        console.log("Successfully deleted all validators");
+      }
+    } catch (error) {
+      console.error("Error deleting validators:", error);
+    }
+  }
+  async countValidators() {
+    try {
+      console.log("Counting all validators...");
+      const result = await rpcClient.request({
+        method: "sim_countValidators",
+        params: []
+      });
+      console.log("Total Validators:", result.result);
+    } catch (error) {
+      console.error("Error counting validators:", error);
+    }
+  }
+  async updateValidator(options) {
+    try {
+      console.log(`Fetching validator with address: ${options.address}...`);
+      const currentValidator = await rpcClient.request({
+        method: "sim_getValidator",
+        params: [options.address]
+      });
+      if (!currentValidator.result) {
+        throw new Error(`Validator with address ${options.address} not found.`);
+      }
+      console.log("Current Validator Details:", currentValidator.result);
+      const parsedStake = options.stake ? parseInt(options.stake, 10) : currentValidator.result.stake;
+      if (isNaN(parsedStake) || parsedStake < 0) {
+        return console.error("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
+      };
+      console.log("Updated Validator Details:", updatedValidator);
+      const result = await rpcClient.request({
+        method: "sim_updateValidator",
+        params: [
+          updatedValidator.address,
+          updatedValidator.stake,
+          updatedValidator.provider,
+          updatedValidator.model,
+          updatedValidator.config
+        ]
+      });
+      console.log("Validator successfully updated:", result.result);
+    } catch (error) {
+      console.error("Error updating validator:", error);
+    }
+  }
+  async createRandomValidators(options) {
+    try {
+      const count = parseInt(options.count, 10);
+      if (isNaN(count) || count < 1) {
+        return console.error("Invalid count. Please provide a positive integer.");
+      }
+      console.log(`Creating ${count} random validator(s)...`);
+      console.log(`Providers: ${options.providers.length > 0 ? options.providers.join(", ") : "None"}`);
+      console.log(`Models: ${options.models.length > 0 ? options.models.join(", ") : "None"}`);
+      const result = await rpcClient.request({
+        method: "sim_createRandomValidators",
+        params: [count, 1, 10, options.providers, options.models]
+      });
+      console.log("Random validators successfully created:", result.result);
+    } catch (error) {
+      console.error("Error creating random validators:", error);
+    }
+  }
+  async createValidator(options) {
+    try {
+      const stake = parseInt(options.stake, 10);
+      if (isNaN(stake) || stake < 1) {
+        return console.error("Invalid stake. Please provide a positive integer.");
+      }
+      if (options.model && !options.provider) {
+        return console.error("You must specify a provider if using a model.");
+      }
+      console.log("Fetching available providers and models...");
+      const providersAndModels = await rpcClient.request({
+        method: "sim_getProvidersAndModels",
+        params: []
+      });
+      if (!providersAndModels.result || providersAndModels.result.length === 0) {
+        return console.error("No providers or models available.");
+      }
+      const availableProviders = [
+        ...new Map(
+          providersAndModels.result.filter((entry) => entry.is_available).map((entry) => [entry.provider, entry])
+        ).values()
+      ];
+      let provider = options.provider;
+      if (!provider) {
+        const { selectedProvider } = await lib_default.prompt([
+          {
+            type: "list",
+            name: "selectedProvider",
+            message: "Select a provider:",
+            choices: availableProviders.map((entry) => entry.provider)
+          }
+        ]);
+        provider = selectedProvider;
+      }
+      const availableModels = providersAndModels.result.filter(
+        (entry) => entry.provider === provider && entry.is_model_available
+      );
+      if (availableModels.length === 0) {
+        return console.error("No models available for the selected provider.");
+      }
+      let model = options.model;
+      if (!model) {
+        const { selectedModel } = await lib_default.prompt([
+          {
+            type: "list",
+            name: "selectedModel",
+            message: "Select a model:",
+            choices: availableModels.map((entry) => entry.model)
+          }
+        ]);
+        model = selectedModel;
+      }
+      const modelDetails = availableModels.find(
+        (entry) => entry.model === model
+      );
+      if (!modelDetails) {
+        return console.error("Selected model details not found.");
+      }
+      const config = options.config ? JSON.parse(options.config) : modelDetails.config;
+      console.log("Creating validator with the following details:");
+      console.log(`Stake: ${stake}`);
+      console.log(`Provider: ${modelDetails.provider}`);
+      console.log(`Model: ${modelDetails.model}`);
+      console.log(`Config:`, config);
+      console.log(`Plugin:`, modelDetails.plugin);
+      console.log(`Plugin Config:`, modelDetails.plugin_config);
+      const result = await rpcClient.request({
+        method: "sim_createValidator",
+        params: [
+          stake,
+          modelDetails.provider,
+          modelDetails.model,
+          config,
+          modelDetails.plugin,
+          modelDetails.plugin_config
+        ]
+      });
+      console.log("Validator successfully created:", result.result);
+    } catch (error) {
+      console.error("Error creating validator:", error);
+    }
+  }
+};
+
+// src/commands/validators/index.ts
+function initializeValidatorCommands(program2) {
+  const validatorsAction = new ValidatorsAction();
+  const validatorsCommand = program2.command("validators").description("Manage validator 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").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 program2;
+}
+
 // src/commands/update/index.ts
 function initializeUpdateCommands(program2) {
   const updateCommand = program2.command("update").description("Update resources like models or configurations");
@@ -86799,6 +87063,7 @@ function initializeCLI() {
   initializeContractsCommands(program);
   initializeConfigCommands(program);
   initializeUpdateCommands(program);
+  initializeValidatorCommands(program);
   program.parse(process.argv);
 }
 initializeCLI();

package/docker-compose.yml

@@ -61,6 +61,9 @@ services:
         max-file: "3"
     deploy:
       replicas: ${JSONRPC_REPLICAS:-1}
+    volumes:
+      - hardhat_artifacts:/app/hardhat/artifacts
+      - hardhat_deployments:/app/hardhat/deployments
 
   webrequest:
     image: yeagerai/simulator-webrequest:${LOCALNETVERSION:-latest}
@@ -144,8 +147,15 @@ services:
         condition: service_healthy
 
   hardhat:
-    image: yeagerai/simulator-hardhat
+    image: yeagerai/simulator-hardhat:${LOCALNETVERSION:-latest}
     ports:
       - "${HARDHAT_PORT:-8545}:8545"
     environment:
-      - HARDHAT_NETWORK=hardhat
+      - HARDHAT_NETWORK=hardhat
+    volumes:
+      - hardhat_artifacts:/app/artifacts
+      - hardhat_deployments:/app/deployments
+
+volumes:
+  hardhat_artifacts:
+  hardhat_deployments:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {

package/src/commands/validators/index.ts

@@ -0,0 +1,94 @@
+import { Command } from "commander";
+import { ValidatorsAction } from "./validators";
+
+export function initializeValidatorCommands(program: Command) {
+  const validatorsAction = new ValidatorsAction();
+
+  const validatorsCommand = program
+    .command("validators")
+    .description("Manage validator 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;
+}