genlayer 0.33.1 → 0.34.1

package/src/commands/transactions/appeal.ts

@@ -1,39 +0,0 @@
-import {TransactionHash} from "genlayer-js/types";
-import {BaseAction} from "../../lib/actions/BaseAction";
-
-export interface AppealOptions {
-  rpc?: string;
-}
-
-export class AppealAction extends BaseAction {
-  constructor() {
-    super();
-  }
-
-  async appeal({
-    txId,
-    rpc,
-  }: {
-    txId: TransactionHash;
-    rpc?: string;
-  }): Promise<void> {
-    const client = await this.getClient(rpc);
-    await client.initializeConsensusSmartContract();
-    this.startSpinner(`Appealing transaction ${txId}...`);
-
-    try {
-      const hash = await client.appealTransaction({
-        txId,
-      });
-
-      const result = await client.waitForTransactionReceipt({
-        hash,
-        retries: 100,
-        interval: 5000,
-      });
-      this.succeedSpinner("Appeal operation successfully executed", result);
-    } catch (error) {
-      this.failSpinner("Error during appeal operation", error);
-    }
-  }
-} 

package/src/commands/transactions/index.ts

@@ -1,39 +0,0 @@
-import {Command} from "commander";
-import {TransactionStatus, TransactionHash} from "genlayer-js/types";
-import {ReceiptAction, ReceiptOptions} from "./receipt";
-import {AppealAction, AppealOptions} from "./appeal";
-
-function parseIntOption(value: string, fallback: number): number {
-  const parsed = parseInt(value, 10);
-  return isNaN(parsed) ? fallback : parsed;
-}
-
-export function initializeTransactionsCommands(program: Command) {
-  const validStatuses = Object.values(TransactionStatus).join(", ");
-  
-  program
-    .command("receipt <txId>")
-    .description("Get transaction receipt by hash")
-    .option("--status <status>", `Transaction status to wait for (${validStatuses})`, TransactionStatus.FINALIZED)
-    .option("--retries <retries>", "Number of retries", (value) => parseIntOption(value, 100), 100)
-    .option("--interval <interval>", "Interval between retries in milliseconds", (value) => parseIntOption(value, 5000), 5000)
-    .option("--rpc <rpcUrl>", "RPC URL for the network")
-    .option("--stdout", "Print only stdout from the receipt")
-    .option("--stderr", "Print only stderr from the receipt")
-    .action(async (txId: TransactionHash, options: ReceiptOptions) => {
-      const receiptAction = new ReceiptAction();
-      
-      await receiptAction.receipt({txId, ...options});
-    })      
-
-  program
-    .command("appeal <txId>")
-    .description("Appeal a transaction by its hash")
-    .option("--rpc <rpcUrl>", "RPC URL for the network")
-    .action(async (txId: TransactionHash, options: AppealOptions) => {
-      const appealAction = new AppealAction();
-      await appealAction.appeal({txId, ...options});
-    });
-
-  return program;
-} 

package/src/commands/transactions/receipt.ts

@@ -1,90 +0,0 @@
-import {BaseAction} from "../../lib/actions/BaseAction";
-import {TransactionHash, TransactionStatus} from "genlayer-js/types";
-
-export interface ReceiptParams {
-  txId: TransactionHash;
-  status?: string | TransactionStatus;
-  retries?: number;
-  interval?: number;
-  rpc?: string;
-  stdout?: boolean;
-  stderr?: boolean;
-}
-
-export interface ReceiptOptions extends Omit<ReceiptParams, 'txId'> {}
-
-export class ReceiptAction extends BaseAction {
-  constructor() {
-    super();
-  }
-
-  private validateTransactionStatus(status: string): TransactionStatus | undefined {
-    const upperStatus = status.toUpperCase() as keyof typeof TransactionStatus;
-    
-    if (!(upperStatus in TransactionStatus)) {
-      const validStatuses = Object.values(TransactionStatus);
-      this.failSpinner(
-        "Invalid transaction status", 
-        `Invalid status: ${status}. Valid values are: ${validStatuses.join(", ")}`
-      );
-      return
-    }
-    
-    return TransactionStatus[upperStatus];
-  }
-
-  async receipt({
-    txId,
-    status = TransactionStatus.FINALIZED,
-    retries,
-    interval,
-    rpc,
-    stdout,
-    stderr,
-  }: ReceiptParams): Promise<void> {
-    const client = await this.getClient(rpc);
-    await client.initializeConsensusSmartContract();
-    this.startSpinner(`Waiting for transaction receipt ${txId} (status: ${status})...`);
-
-    try {
-      let validatedStatus = this.validateTransactionStatus(status);
-
-      if (!validatedStatus) {
-        return;
-      }
-        
-      const result = await client.waitForTransactionReceipt({
-        hash: txId,
-        status: validatedStatus,
-        retries,
-        interval,
-      });
-
-      // If specific output flags are provided, print only those fields
-      if (stdout || stderr) {
-        const stdoutValue = (result as any)?.consensus_data?.leader_receipt[0]?.genvm_result?.stdout;
-        const stderrValue = (result as any)?.consensus_data?.leader_receipt[0]?.genvm_result?.stderr;
-
-        if (stdout && stderr) {
-          this.succeedSpinner("Transaction stdout and stderr", { stdout: stdoutValue, stderr: stderrValue });
-          return;
-        }
-
-        if (stdout) {
-          this.succeedSpinner("Transaction stdout retrieved successfully", stdoutValue);
-          return;
-        }
-
-        if (stderr) {
-          this.succeedSpinner("Transaction stderr retrieved successfully", stderrValue);
-          return;
-        }
-      }
-
-      // Default behavior (no flags): show full receipt result
-      this.succeedSpinner("Transaction receipt retrieved successfully", result);
-    } catch (error) {
-      this.failSpinner("Error retrieving transaction receipt", error);
-    }
-  }
-} 

package/src/commands/update/index.ts

@@ -1,25 +0,0 @@
-import { Command } from "commander";
-import { OllamaAction } from "./ollama";
-
-export function initializeUpdateCommands(program: Command) {
-  const updateCommand = program
-    .command("update")
-    .description("Update resources like models or configurations");
-
-  updateCommand
-    .command("ollama")
-    .description("Manage Ollama models (update or remove)")
-    .option("--model [model-name]", "Specify the model to update or remove", '')
-    .option("--remove", "Remove the specified model instead of updating")
-    .action(async (options) => {
-      const ollamaAction = new OllamaAction();
-
-      if (options.remove) {
-        await ollamaAction.removeModel(options.model);
-      } else {
-        await ollamaAction.updateModel(options.model);
-      }
-    });
-
-  return program;
-}

package/src/commands/update/ollama.ts

@@ -1,103 +0,0 @@
-import Docker from "dockerode";
-import { rpcClient } from "../../lib/clients/jsonRpcClient";
-import { BaseAction } from "../../lib/actions/BaseAction";
-
-export class OllamaAction extends BaseAction {
-  private docker: Docker;
-
-  constructor() {
-    super();
-    this.docker = new Docker();
-  }
-
-  async updateModel(modelName: string) {
-    try {
-      this.startSpinner(`Updating model "${modelName}"...`);
-
-      if(!modelName){
-        modelName = this.getConfig().defaultOllamaModel;
-      }
-
-      const providersAndModels = await rpcClient.request({
-        method: "sim_getProvidersAndModels",
-        params: [],
-      });
-
-      const existingOllamaProvider = providersAndModels.result.find(
-        (entry: any) => entry.plugin === "ollama"
-      );
-
-      if (!existingOllamaProvider) {
-        return this.failSpinner("No existing 'ollama' provider found. Unable to add/update a model.");
-      }
-
-      await this.executeModelCommand("pull", modelName, `Model "${modelName}" updated successfully`);
-
-      const existingModel = providersAndModels.result.some(
-        (entry: any) => entry.plugin === "ollama" && entry.model === modelName
-      );
-      if (!existingModel) {
-        this.startSpinner(`Adding model "${modelName}" to Provider Presets...`);
-
-        const newModelConfig = {
-          config: existingOllamaProvider.config,
-          model: modelName,
-          plugin: "ollama",
-          plugin_config: existingOllamaProvider.plugin_config,
-          provider: "ollama",
-        };
-
-        await rpcClient.request({
-          method: "sim_addProvider",
-          params: [newModelConfig],
-        });
-        this.succeedSpinner(`Model "${modelName}" added to Provider Presets successfully.`);
-      }
-    } catch (error) {
-      this.failSpinner(`Error updating model "${modelName}"`, error);
-    }
-  }
-
-  async removeModel(modelName: string) {
-    await this.executeModelCommand("rm", modelName, `Model "${modelName}" removed successfully`);
-  }
-
-  private async executeModelCommand(command: string, modelName: string, successMessage: string) {
-    try {
-      this.startSpinner(`Executing '${command}' command on model "${modelName}"...`);
-
-      let success = false;
-      const ollamaContainer = this.docker.getContainer("genlayer-ollama");
-      const exec = await ollamaContainer.exec({
-        Cmd: ["ollama", command, modelName],
-        AttachStdout: true,
-        AttachStderr: true,
-      });
-      const stream = await exec.start({ Detach: false, Tty: false });
-
-      stream.on("data", (chunk: any) => {
-        const output = chunk.toString();
-        this.setSpinnerText(output.trim());
-
-        if (output.includes("success") || output.includes("deleted")) {
-          success = true;
-        }
-      });
-
-      await new Promise<void>((resolve, reject) => {
-        stream.on("end", () => {
-          if (success) {
-            this.succeedSpinner(successMessage);
-            resolve();
-          } else {
-            this.failSpinner(`Failed to execute '${command}' on model "${modelName}".`);
-            reject('internal error');
-          }
-        });
-        stream.on("error", reject);
-      });
-    } catch (error) {
-      this.failSpinner(`Error executing command "${command}" on model "${modelName}"`, error);
-    }
-  }
-}

package/src/lib/actions/BaseAction.ts

@@ -1,295 +0,0 @@
-import {ConfigFileManager} from "../../lib/config/ConfigFileManager";
-import {KeychainManager} from "../../lib/config/KeychainManager";
-import ora, {Ora} from "ora";
-import chalk from "chalk";
-import inquirer from "inquirer";
-import { inspect } from "util";
-import {createClient, createAccount} from "genlayer-js";
-import {localnet, studionet, testnetAsimov} from "genlayer-js/chains";
-import type {GenLayerClient, GenLayerChain, Hash, Address, Account} from "genlayer-js/types";
-
-// Built-in networks - always resolve fresh from genlayer-js
-export const BUILT_IN_NETWORKS: Record<string, GenLayerChain> = {
-  "localnet": localnet,
-  "studionet": studionet,
-  "testnet-asimov": testnetAsimov,
-};
-
-/**
- * Resolves a stored network config to a fresh chain object.
- * Handles both new format (alias string) and old format (JSON object) for backwards compat.
- */
-export function resolveNetwork(stored: string | undefined): GenLayerChain {
-  if (!stored) return localnet;
-
-  // Try as alias first (new format)
-  if (BUILT_IN_NETWORKS[stored]) {
-    return BUILT_IN_NETWORKS[stored];
-  }
-
-  // Backwards compat: try parsing as JSON (old format)
-  try {
-    const parsed = JSON.parse(stored);
-    // If it has a known name, use fresh version instead
-    const alias = Object.entries(BUILT_IN_NETWORKS)
-      .find(([_, chain]) => chain.name === parsed.name)?.[0];
-    if (alias) {
-      return BUILT_IN_NETWORKS[alias];
-    }
-    // Custom network - use as-is
-    return parsed;
-  } catch {
-    throw new Error(`Unknown network: ${stored}`);
-  }
-}
-import { ethers } from "ethers";
-import { writeFileSync, existsSync, readFileSync } from "fs";
-
-export class BaseAction extends ConfigFileManager {
-  private static readonly DEFAULT_ACCOUNT_NAME = "default";
-  private static readonly MAX_PASSWORD_ATTEMPTS = 3;
-  protected static readonly MIN_PASSWORD_LENGTH = 8;
-
-  private spinner: Ora;
-  private _genlayerClient: GenLayerClient<GenLayerChain> | null = null;
-  protected keychainManager: KeychainManager;
-  protected accountOverride: string | null = null;
-
-  constructor() {
-    super();
-    this.spinner = ora({text: "", spinner: "dots"});
-    this.keychainManager = new KeychainManager();
-  }
-
-  private async decryptKeystore(keystoreJson: string, attempt: number = 1): Promise<string> {
-    try {
-      const message = attempt === 1
-        ? "Enter password to decrypt keystore:"
-        : `Invalid password. Attempt ${attempt}/${BaseAction.MAX_PASSWORD_ATTEMPTS} - Enter password to decrypt keystore:`;
-      const password = await this.promptPassword(message);
-      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreJson, password);
-
-      return wallet.privateKey;
-    } catch (error) {
-      if (attempt >= BaseAction.MAX_PASSWORD_ATTEMPTS) {
-        this.failSpinner(`Maximum password attempts exceeded (${BaseAction.MAX_PASSWORD_ATTEMPTS}/${BaseAction.MAX_PASSWORD_ATTEMPTS}).`);
-      }
-      return await this.decryptKeystore(keystoreJson, attempt + 1);
-    }
-  }
-
-  protected isValidKeystoreFormat(data: any): boolean {
-    // Standard web3 keystore format has 'crypto' (or 'Crypto') and 'address' fields
-    return Boolean(
-      data &&
-      (data.crypto || data.Crypto) &&
-      typeof data.address === "string"
-    );
-  }
-
-  private formatOutput(data: any): string {
-    if (typeof data === "string") {
-      return data;
-    }
-    return inspect(data, { depth: null, colors: false });
-  }
-
-  protected async getClient(rpcUrl?: string, readOnly: boolean = false): Promise<GenLayerClient<GenLayerChain>> {
-    if (!this._genlayerClient) {
-      const network = resolveNetwork(this.getConfig().network);
-      const account = await this.getAccount(readOnly);
-      this._genlayerClient = createClient({
-        chain: network,
-        endpoint: rpcUrl,
-        account: account,
-      });
-    }
-    return this._genlayerClient;
-  }
-
-  protected resolveAccountName(): string {
-    // Priority: explicit override > config active account > default
-    if (this.accountOverride) {
-      return this.accountOverride;
-    }
-    const activeAccount = this.getActiveAccount();
-    if (activeAccount) {
-      return activeAccount;
-    }
-    return BaseAction.DEFAULT_ACCOUNT_NAME;
-  }
-
-  private async getAccount(readOnly: boolean = false): Promise<Account | Address> {
-    const accountName = this.resolveAccountName();
-    const keystorePath = this.getKeystorePath(accountName);
-    let decryptedPrivateKey;
-    let keystoreJson: string;
-    let keystoreData: any;
-
-    if (!existsSync(keystorePath)) {
-      await this.confirmPrompt(`Account '${accountName}' not found. Would you like to create it?`);
-      decryptedPrivateKey = await this.createKeypairByName(accountName, false);
-    }
-
-    keystoreJson = readFileSync(keystorePath, "utf-8");
-    keystoreData = JSON.parse(keystoreJson);
-
-    if (!this.isValidKeystoreFormat(keystoreData)) {
-      this.failSpinner("Invalid keystore format. Expected encrypted keystore file.", undefined, false);
-      await this.confirmPrompt(`Would you like to recreate account '${accountName}'?`);
-      decryptedPrivateKey = await this.createKeypairByName(accountName, true);
-      keystoreJson = readFileSync(keystorePath, "utf-8");
-      keystoreData = JSON.parse(keystoreJson);
-    }
-
-    if (readOnly) {
-      return this.getAddress(keystoreData);
-    }
-
-    if (!decryptedPrivateKey) {
-      const cachedKey = await this.keychainManager.getPrivateKey(accountName);
-      if (cachedKey) {
-        // Verify cached key matches keystore address
-        const tempAccount = createAccount(cachedKey as Hash);
-        const cachedAddress = tempAccount.address.toLowerCase();
-        const keystoreAddress = `0x${keystoreData.address.toLowerCase().replace(/^0x/, '')}`;
-        if (cachedAddress === keystoreAddress) {
-          decryptedPrivateKey = cachedKey;
-        } else {
-          // Cached key doesn't match keystore - invalidate it
-          await this.keychainManager.removePrivateKey(accountName);
-          decryptedPrivateKey = await this.decryptKeystore(keystoreJson);
-        }
-      } else {
-        decryptedPrivateKey = await this.decryptKeystore(keystoreJson);
-      }
-    }
-    return createAccount(decryptedPrivateKey as Hash);
-  }
-
-  private getAddress(keystoreData: any): Address {
-    return keystoreData.address as Address;
-  }
-
-  protected async createKeypairByName(accountName: string, overwrite: boolean): Promise<string> {
-    const keystorePath = this.getKeystorePath(accountName);
-    this.stopSpinner();
-
-    if (existsSync(keystorePath) && !overwrite) {
-      this.failSpinner(`Account '${accountName}' already exists. Use '--overwrite' to replace it.`);
-    }
-
-    const wallet = ethers.Wallet.createRandom();
-
-    const password = await this.promptPassword("Enter a password to encrypt your keystore (minimum 8 characters):");
-    const confirmPassword = await this.promptPassword("Confirm password:");
-
-    if (password !== confirmPassword) {
-      this.failSpinner("Passwords do not match");
-    }
-
-    if (password.length < BaseAction.MIN_PASSWORD_LENGTH) {
-      this.failSpinner(`Password must be at least ${BaseAction.MIN_PASSWORD_LENGTH} characters long`);
-    }
-
-    // Write standard web3 keystore format directly
-    const encryptedJson = await wallet.encrypt(password);
-    writeFileSync(keystorePath, encryptedJson);
-
-    // Set as active account if no active account exists
-    if (!this.getActiveAccount()) {
-      this.setActiveAccount(accountName);
-    }
-
-    await this.keychainManager.removePrivateKey(accountName);
-
-    return wallet.privateKey;
-  }
-
-  protected async promptPassword(message: string): Promise<string> {
-    const answer = await inquirer.prompt([
-      {
-        type: "password",
-        name: "password",
-        message: chalk.yellow(message),
-        mask: "*",
-        validate: (input: string) => {
-          if (!input) {
-            return "Password cannot be empty";
-          }
-          return true;
-        },
-      },
-    ]);
-    return answer.password;
-  }
-
-  protected async confirmPrompt(message: string): Promise<void> {
-    const answer = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "confirmAction",
-        message: chalk.yellow(message),
-        default: true,
-      },
-    ]);
-
-    if (!answer.confirmAction) {
-      this.logError("Operation aborted!");
-      process.exit(0);
-    }
-  }
-
-  protected log(message: string, data?: any): void {
-    console.log(chalk.white(`\n${message}`));
-    if (data !== undefined) console.log(this.formatOutput(data));
-  }
-
-  protected logSuccess(message: string, data?: any): void {
-    console.log(chalk.green(`\n✔ ${message}`));
-    if (data !== undefined) console.log(chalk.green(this.formatOutput(data)));
-  }
-
-  protected logInfo(message: string, data?: any): void {
-    console.log(chalk.blue(`\nℹ ${message}`));
-    if (data !== undefined) console.log(chalk.blue(this.formatOutput(data)));
-  }
-
-  protected logWarning(message: string, data?: any): void {
-    console.log(chalk.yellow(`\n⚠ ${message}`));
-    if (data !== undefined) console.log(chalk.yellow(this.formatOutput(data)));
-  }
-
-  protected logError(message: string, error?: any): void {
-    console.error(chalk.red(`\n✖ ${message}`));
-    if (error !== undefined) console.error(chalk.red(this.formatOutput(error)));
-  }
-
-  protected startSpinner(message: string) {
-    this.spinner.text = chalk.blue(`${message}`);
-    this.spinner.start();
-  }
-
-  protected succeedSpinner(message: string, data?: any): void {
-    if (data !== undefined) this.log("Result:", data);
-    console.log('');
-    this.spinner.succeed(chalk.green(message));
-  }
-
-  protected failSpinner(message: string, error?: any, shouldExit = true): void {
-    if (error) this.log("Error:", error);
-    console.log("");
-    this.spinner.fail(chalk.red(message));
-    if (shouldExit) {
-      process.exit(1);
-    }
-  }
-
-  protected stopSpinner(): void {
-    this.spinner.stop();
-  }
-
-  protected setSpinnerText(message: string): void {
-    this.spinner.text = chalk.blue(message);
-  }
-}

package/src/lib/clients/jsonRpcClient.ts

@@ -1,41 +0,0 @@
-import fetch from "node-fetch";
-import {v4 as uuidv4} from "uuid";
-
-import {DEFAULT_JSON_RPC_URL} from "../config/simulator";
-
-export interface JsonRPCParams {
-  method: string;
-  params: any[];
-}
-
-export class JsonRpcClient {
-  serverUrl: string;
-
-  constructor(serverUrl: string) {
-    this.serverUrl = serverUrl;
-  }
-
-  async request({method, params}: JsonRPCParams): Promise<any | null> {
-    const response = await fetch(this.serverUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        jsonrpc: "2.0",
-        id: uuidv4(),
-        method,
-        params,
-      }),
-    });
-
-    if (response.ok) {
-      return response.json();
-    }
-    const result = await response.json();
-
-    throw new Error(result?.error?.message || response.statusText);
-
-  }
-}
-export const rpcClient = new JsonRpcClient(DEFAULT_JSON_RPC_URL);