genlayer 0.38.8 → 0.38.10

package/src/commands/contracts/deploy.ts

@@ -0,0 +1,161 @@
+import fs from "fs";
+import path from "path";
+import {BaseAction} from "../../lib/actions/BaseAction";
+import {pathToFileURL} from "url";
+import {TransactionStatus} from "genlayer-js/types";
+import {buildSync} from "esbuild";
+
+export interface DeployOptions {
+  contract?: string;
+  args?: any[];
+  rpc?: string;
+}
+
+export interface DeployScriptsOptions {
+  rpc?: string;
+}
+
+export class DeployAction extends BaseAction {
+  private readonly deployDir = path.resolve(process.cwd(), "deploy");
+
+  constructor() {
+    super();
+  }
+
+  private readContractCode(contractPath: string): string {
+    if (!fs.existsSync(contractPath)) {
+      throw new Error(`Contract file not found: ${contractPath}`);
+    }
+    return fs.readFileSync(contractPath, "utf-8");
+  }
+
+  private async executeTsScript(filePath: string, rpcUrl?: string): Promise<void> {
+    const outFile = filePath.replace(/\.ts$/, ".compiled.js");
+    this.startSpinner(`Transpiling TypeScript file: ${filePath}`);
+    try {
+      buildSync({
+        entryPoints: [filePath],
+        outfile: outFile,
+        bundle: false,
+        platform: "node",
+        format: "esm",
+        target: "es2020",
+        sourcemap: false,
+      });
+      await this.executeJsScript(filePath, outFile, rpcUrl);
+    } catch (error) {
+      this.failSpinner(`Error executing: ${filePath}`, error);
+    } finally {
+      fs.unlinkSync(outFile);
+    }
+  }
+
+  private async executeJsScript(
+    filePath: string,
+    transpiledFilePath?: string,
+    rpcUrl?: string,
+  ): Promise<void> {
+    this.startSpinner(`Executing file: ${filePath}`);
+    try {
+      const module = await import(pathToFileURL(transpiledFilePath || filePath).href);
+      if (!module.default || typeof module.default !== "function") {
+        this.failSpinner(`No "default" function found in: ${filePath}`);
+        return;
+      }
+      const client = await this.getClient(rpcUrl);
+      await module.default(client);
+      this.succeedSpinner(`Successfully executed: ${filePath}`);
+    } catch (error) {
+      this.failSpinner(`Error executing: ${filePath}`, error);
+    }
+  }
+
+  async deployScripts(options?: DeployScriptsOptions) {
+    this.startSpinner("Searching for deploy scripts...");
+    if (!fs.existsSync(this.deployDir)) {
+      this.failSpinner("No deploy folder found.");
+      return;
+    }
+    const files = fs
+      .readdirSync(this.deployDir)
+      .filter(file => file.endsWith(".ts") || file.endsWith(".js"))
+      .sort((a, b) => {
+        const numA = parseInt(a.split("_")[0]);
+        const numB = parseInt(b.split("_")[0]);
+
+        if (!isNaN(numA) && !isNaN(numB)) return numA - numB;
+        if (!isNaN(numA)) return -1;
+        if (!isNaN(numB)) return 1;
+        return a.localeCompare(b);
+      });
+
+    if (files.length === 0) {
+      this.failSpinner("No deploy scripts found.");
+      return;
+    }
+
+    this.setSpinnerText(`Found ${files.length} deploy scripts. Executing...`);
+
+    for (const file of files) {
+      const filePath = path.resolve(this.deployDir, file);
+      this.setSpinnerText(`Executing script: ${filePath}`);
+      try {
+        if (file.endsWith(".ts")) {
+          await this.executeTsScript(filePath, options?.rpc);
+        } else {
+          await this.executeJsScript(filePath, undefined, options?.rpc);
+        }
+      } catch (error) {
+        this.failSpinner(`Error executing script: ${filePath}`, error);
+      }
+    }
+  }
+
+  async deploy(options: DeployOptions): Promise<void> {
+    try {
+      const client = await this.getClient(options.rpc);
+      this.startSpinner("Setting up the deployment environment...");
+      await client.initializeConsensusSmartContract();
+
+      if (!options.contract) {
+        this.failSpinner("No contract specified for deployment.");
+        return;
+      }
+      this.setSpinnerText("Reading contract code...");
+      const contractCode = this.readContractCode(options.contract);
+
+      if (!contractCode) {
+        this.failSpinner("Contract code is empty.");
+        return;
+      }
+
+      const leaderOnly = false;
+      const deployParams: any = {code: contractCode, args: options.args, leaderOnly};
+
+      this.setSpinnerText("Starting contract deployment...");
+      this.log("Deployment Parameters:", deployParams);
+
+      const hash = (await client.deployContract(deployParams)) as any;
+      this.log("Deployment Transaction Hash:", hash);
+      const result = await client.waitForTransactionReceipt({
+        hash,
+        retries: 50,
+        interval: 5000,
+        status: TransactionStatus.ACCEPTED,
+      });
+
+      this.log("Deployment Receipt:", result);
+
+      const contractAddress =
+        result.data?.contract_address ?? // localnet/studio
+        (result.txDataDecoded as any)?.contractAddress; // testnet
+
+      this.succeedSpinner("Contract deployed successfully.", {
+        "Transaction Hash": hash,
+        "Contract Address": contractAddress,
+      });
+    } catch (error) {
+      this.failSpinner("Error deploying contract", error);
+    }
+  }
+}

package/src/commands/contracts/index.ts

@@ -0,0 +1,150 @@
+import {Command} from "commander";
+import {CalldataAddress} from "genlayer-js/types";
+import {DeployAction, DeployOptions, DeployScriptsOptions} from "./deploy";
+import {CallAction, CallOptions} from "./call";
+import {WriteAction, WriteOptions} from "./write";
+import {SchemaAction, SchemaOptions} from "./schema";
+import {CodeAction, CodeOptions} from "./code";
+
+const ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+const ADDR_PREFIX_RE = /^addr#([0-9a-fA-F]{40})$/;
+const BYTES_PREFIX_RE = /^b#([0-9a-fA-F]*)$/;
+const HEX_RE = /^0x[0-9a-fA-F]+$/;
+
+function hexToBytes(hex: string): Uint8Array {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+
+export function coerceValue(value: unknown): unknown {
+  if (value === null) return null;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (Number.isSafeInteger(value)) return value;
+    return BigInt(value);
+  }
+  if (Array.isArray(value)) return value.map(coerceValue);
+  if (typeof value === "object" && value !== null) {
+    const result: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = coerceValue(v);
+    }
+    return result;
+  }
+  if (typeof value === "string") return parseScalar(value);
+  return value;
+}
+
+export function parseScalar(value: string): unknown {
+  if (value === "null") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+
+  const addrMatch = value.match(ADDR_PREFIX_RE);
+  if (addrMatch) return new CalldataAddress(hexToBytes(addrMatch[1]));
+  if (ADDRESS_RE.test(value)) return new CalldataAddress(hexToBytes(value.slice(2)));
+
+  const bytesMatch = value.match(BYTES_PREFIX_RE);
+  if (bytesMatch) return hexToBytes(bytesMatch[1]);
+
+  if (HEX_RE.test(value)) return BigInt(value);
+  if (!isNaN(Number(value)) && Number.isSafeInteger(Number(value))) return Number(value);
+  if (!isNaN(Number(value))) return BigInt(value);
+
+  return value;
+}
+
+export function parseArg(value: string, previous: any[] = []): any[] {
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "object" || Array.isArray(parsed)) {
+      return [...previous, coerceValue(parsed)];
+    }
+  } catch {
+    // not JSON, fall through to scalar parsing
+  }
+  return [...previous, parseScalar(value)];
+}
+
+const ARGS_HELP = [
+  "Contract arguments. Supported types:",
+  "  bool: true, false",
+  "  null: null",
+  "  int: 42, -1, 0x1a (large values auto-use BigInt)",
+  '  str: hello, "multi word"',
+  "  address: 0x6857...a0 (40 hex chars) or addr#6857...a0",
+  "  bytes: b#deadbeef",
+  '  array: \'[1, 2, "three"]\'',
+  '  dict: \'{"key": "value"}\'',
+].join("\n");
+
+export function initializeContractsCommands(program: Command) {
+  program
+    .command("deploy")
+    .description("Deploy intelligent contracts")
+    .option("--contract <contractPath>", "Path to the smart contract to deploy")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .option("--args <args...>", ARGS_HELP, parseArg, [])
+    .action(async (options: DeployOptions) => {
+      const deployer = new DeployAction();
+      if (options.contract) {
+        await deployer.deploy(options);
+      } else {
+        const deployScriptsOptions: DeployScriptsOptions = {rpc: options.rpc};
+        await deployer.deployScripts(deployScriptsOptions);
+      }
+    });
+
+  program
+    .command("call <contractAddress> <method>")
+    .description("Call a contract method without sending a transaction or changing the state")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .option(
+      "--args <args...>",
+      ARGS_HELP,
+      parseArg,
+      [],
+    )
+    .action(async (contractAddress: string, method: string, options: CallOptions) => {
+      const callAction = new CallAction();
+      await callAction.call({contractAddress, method, ...options});
+    });
+
+  program
+    .command("write <contractAddress> <method>")
+    .description("Sends a transaction to a contract method that modifies the state")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .option(
+      "--args <args...>",
+      ARGS_HELP,
+      parseArg,
+      [],
+    )
+    .action(async (contractAddress: string, method: string, options: WriteOptions) => {
+      const writeAction = new WriteAction();
+      await writeAction.write({contractAddress, method, ...options});
+    });
+
+  program
+    .command("schema <contractAddress>")
+    .description("Get the schema for a deployed contract")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (contractAddress: string, options: SchemaOptions) => {
+      const schemaAction = new SchemaAction();
+      await schemaAction.schema({contractAddress, ...options});
+    });
+
+  program
+    .command("code <contractAddress>")
+    .description("Get the source for a deployed contract")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (contractAddress: string, options: CodeOptions) => {
+      const codeAction = new CodeAction();
+      await codeAction.code({contractAddress, ...options});
+    });
+
+  return program;
+}

package/src/commands/contracts/schema.ts

@@ -0,0 +1,31 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+import type {Address} from "genlayer-js/types";
+
+export interface SchemaOptions {
+  rpc?: string;
+}
+
+export class SchemaAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async schema({
+    contractAddress,
+    rpc,
+  }: {
+    contractAddress: string;
+    rpc?: string;
+  }): Promise<void> {
+    const client = await this.getClient(rpc, true);
+    await client.initializeConsensusSmartContract();
+    this.startSpinner(`Getting schema for contract at ${contractAddress}...`);
+
+    try {
+      const result = await client.getContractSchema(contractAddress as Address);
+      this.succeedSpinner("Contract schema retrieved successfully", result);
+    } catch (error) {
+      this.failSpinner("Error retrieving contract schema", error);
+    }
+  }
+} 

package/src/commands/contracts/write.ts

@@ -0,0 +1,49 @@
+// import {simulator} from "genlayer-js/chains";
+// import type {GenLayerClient} from "genlayer-js/types";
+import {BaseAction} from "../../lib/actions/BaseAction";
+
+export interface WriteOptions {
+  args: any[];
+  rpc?: string;
+}
+
+export class WriteAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async write({
+    contractAddress,
+    method,
+    args,
+    rpc,
+  }: {
+    contractAddress: string;
+    method: string;
+    args: any[];
+    rpc?: string;
+  }): Promise<void> {
+    const client = await this.getClient(rpc);
+    await client.initializeConsensusSmartContract();
+    this.startSpinner(`Calling write method ${method} on contract at ${contractAddress}...`);
+
+    try {
+      const hash = await client.writeContract({
+        address: contractAddress as any,
+        functionName: method,
+        args,
+        value: 0n,
+      });
+      this.log("Write Transaction Hash:", hash);
+
+      const result = await client.waitForTransactionReceipt({
+        hash,
+        retries: 100,
+        interval: 5000,
+      });
+      this.succeedSpinner("Write operation successfully executed", result);
+    } catch (error) {
+      this.failSpinner("Error during write operation", error);
+    }
+  }
+}

package/src/commands/general/index.ts

@@ -0,0 +1,45 @@
+import { Command } from "commander";
+
+import simulatorService from "../../lib/services/simulator";
+import { InitAction, InitActionOptions } from "./init";
+import { StartAction, StartActionOptions } from "./start";
+import {localnetCompatibleVersion} from "../../lib/config/simulator";
+import {StopAction} from "./stop";
+
+export function initializeGeneralCommands(program: Command) {
+  program
+    .command("init")
+    .description("Initialize the GenLayer Environment")
+    .option("--numValidators <numValidators>", "Number of validators", "5")
+    .option("--headless", "Headless mode", false)
+    .option("--reset-db", "Reset Database", false)
+    .option("--localnet-version <localnetVersion>", `Select a specific localnet version (minimum: ${localnetCompatibleVersion})`, localnetCompatibleVersion)
+    .option("--ollama", "Enable Ollama container", false)
+    .action(async (options: InitActionOptions) => {
+      const initAction = new InitAction();
+      await initAction.execute(options)
+    });
+
+  program
+    .command("up")
+    .description("Starts GenLayer's simulator")
+    .option("--reset-validators", "Remove all current validators and create new random ones", false)
+    .option("--numValidators <numValidators>", "Number of validators", "5")
+    .option("--headless", "Headless mode", false)
+    .option("--reset-db", "Reset Database", false)
+    .option("--ollama", "Enable Ollama container", false)
+    .action(async (options: StartActionOptions) => {
+      const startAction = new StartAction();
+      await startAction.execute(options);
+    });
+
+  program
+    .command("stop")
+    .description("Stop all running localnet services.")
+    .action(async () => {
+      const stopAction = new StopAction();
+      await stopAction.stop();
+    });
+
+  return program;
+}

package/src/commands/general/init.ts

@@ -0,0 +1,180 @@
+import inquirer from "inquirer";
+import {DistinctQuestion} from "inquirer";
+import {ISimulatorService} from "../../lib/interfaces/ISimulatorService";
+import {AI_PROVIDERS_CONFIG, AiProviders, localnetCompatibleVersion} from "../../lib/config/simulator";
+import {OllamaAction} from "../update/ollama";
+import {BaseAction} from "../../lib/actions/BaseAction";
+import {SimulatorService} from "../../lib/services/simulator";
+
+export interface InitActionOptions {
+  numValidators: number;
+  headless: boolean;
+  resetDb: boolean;
+  localnetVersion: string;
+  ollama: boolean;
+}
+
+function getRequirementsErrorMessage({docker}: Record<string, boolean>): string {
+  if (!docker) {
+    return "Docker is not installed. Please install Docker and try again.\n";
+  }
+  return "";
+}
+
+function getVersionErrorMessage({docker, node}: Record<string, string>): string {
+  let message = "";
+
+  if (docker) {
+    message += `Docker version ${docker} or higher is required. Please update Docker and try again.\n`;
+  }
+  if (node) {
+    message += `Node version ${node} or higher is required. Please update Node and try again.\n`;
+  }
+  return message;
+}
+
+export class InitAction extends BaseAction {
+  private simulatorService: ISimulatorService;
+  constructor() {
+    super();
+    this.simulatorService = new SimulatorService();
+  }
+
+  public async execute(options: InitActionOptions): Promise<void> {
+    try {
+      this.simulatorService.setComposeOptions(options.headless, options.ollama);
+      let localnetVersion = options.localnetVersion;
+      if (localnetVersion !== "latest") {
+        localnetVersion = this.simulatorService.normalizeLocalnetVersion(localnetVersion);
+        
+        if (this.simulatorService.compareVersions(localnetVersion, localnetCompatibleVersion) < 0) {
+          this.failSpinner(`Localnet version ${localnetVersion} is not supported. Minimum required version is ${localnetCompatibleVersion}. Please use a newer version.`);
+          return;
+        }
+      }
+
+      this.startSpinner("Checking CLI version...");
+      await this.simulatorService.checkCliVersion();
+
+      const isRunning = await this.simulatorService.isLocalnetRunning();
+
+      this.setSpinnerText("Checking installation requirements...");
+      const requirementsInstalled = await this.simulatorService.checkInstallRequirements();
+      const requirementErrorMessage = getRequirementsErrorMessage(requirementsInstalled);
+      if (requirementErrorMessage) {
+        this.failSpinner(requirementErrorMessage);
+        return;
+      }
+
+      this.setSpinnerText("Checking version requirements...");
+      const missingVersions = await this.simulatorService.checkVersionRequirements();
+      const versionErrorMessage = getVersionErrorMessage(missingVersions);
+      if (versionErrorMessage) {
+        this.failSpinner(versionErrorMessage);
+        return;
+      }
+      this.stopSpinner();
+
+      const confirmMessage = isRunning
+        ? `GenLayer Localnet is already running and this command is going to reset GenLayer docker images, containers and volumes, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?`
+        : `This command is going to reset GenLayer docker images, containers and volumes, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?`;
+
+      await this.confirmPrompt(confirmMessage);
+
+      this.logInfo(`Initializing GenLayer CLI with ${options.numValidators} validators`);
+
+      // Reset Docker containers, images, and volumes
+      this.startSpinner("Resetting Docker containers, images, and volumes...");
+      await this.simulatorService.resetDockerContainers();
+      await this.simulatorService.resetDockerImages();
+      await this.simulatorService.resetDockerVolumes();
+      this.stopSpinner();
+
+      const llmQuestions: DistinctQuestion[] = [
+        {
+          type: "checkbox",
+          name: "selectedLlmProviders",
+          message: "Select which LLM providers do you want to use:",
+          choices: this.simulatorService.getAiProvidersOptions(true, options.ollama ? [] : ["ollama"]),
+          validate: answer => (answer.length < 1 ? "You must choose at least one option." : true),
+        },
+      ];
+      const llmProvidersAnswer = await inquirer.prompt(llmQuestions);
+      const selectedLlmProviders = llmProvidersAnswer.selectedLlmProviders as AiProviders[];
+
+      let defaultOllamaModel = this.getConfig().defaultOllamaModel;
+      const aiProvidersEnvVars: Record<string, string> = {};
+      const configurableAiProviders = selectedLlmProviders.filter(
+        (provider: AiProviders) => AI_PROVIDERS_CONFIG[provider].envVar,
+      );
+      for (const provider of configurableAiProviders) {
+        const providerConfig = AI_PROVIDERS_CONFIG[provider];
+        const keyQuestion: DistinctQuestion[] = [
+          {
+            type: "input",
+            name: providerConfig.cliOptionValue,
+            message: `Please enter your ${providerConfig.name} API Key:`,
+            validate: (value: string) =>
+              value.length ? true : `Please enter a valid API Key for ${providerConfig.name}.`,
+          },
+        ];
+        const apiKeyAnswer = await inquirer.prompt(keyQuestion);
+        aiProvidersEnvVars[providerConfig.envVar!] = apiKeyAnswer[providerConfig.cliOptionValue];
+      }
+
+      this.startSpinner("Configuring GenLayer Localnet environment...");
+      this.simulatorService.addConfigToEnvFile(aiProvidersEnvVars);
+      this.simulatorService.addConfigToEnvFile({LOCALNETVERSION: localnetVersion});
+
+      this.setSpinnerText("Running GenLayer Localnet...");
+      this.simulatorService.setupLocalhostAccess();
+      await this.simulatorService.runSimulator();
+
+      this.setSpinnerText("Waiting for localnet to be ready...");
+      const {initialized, errorCode, errorMessage} = await this.simulatorService.waitForSimulatorToBeReady();
+      if (!initialized) {
+        if (errorCode === "ERROR") {
+          this.failSpinner(`Unable to initialize the GenLayer Localnet: ${errorMessage}`);
+          return;
+        }
+        if (errorCode === "TIMEOUT") {
+          this.failSpinner(
+            "The localnet is taking too long to initialize. Please try again after the localnet is ready.",
+          );
+          return;
+        }
+      }
+
+      this.stopSpinner();
+
+      if (selectedLlmProviders.includes("ollama")) {
+        const ollamaAction = new OllamaAction();
+        if (!defaultOllamaModel) {
+          this.writeConfig("defaultOllamaModel", "llama3");
+          defaultOllamaModel = "llama3";
+        }
+        await ollamaAction.updateModel(defaultOllamaModel);
+      }
+
+      this.startSpinner("Initializing validators...");
+      await this.simulatorService.deleteAllValidators();
+      await this.simulatorService.createRandomValidators(Number(options.numValidators), selectedLlmProviders);
+
+      if (options.resetDb) {
+        this.setSpinnerText("Cleaning database...");
+        await this.simulatorService.cleanDatabase();
+      }
+
+      let successMessage = "GenLayer Localnet initialized successfully! ";
+      if (!options.headless) {
+        successMessage += `Go to ${this.simulatorService.getFrontendUrl()} in your browser to access it.`;
+      }
+      if (!options.headless) {
+        await this.simulatorService.openFrontend();
+      }
+      this.succeedSpinner(successMessage);
+    } catch (error) {
+      this.failSpinner("An error occurred during initialization.", error);
+    }
+  }
+}