genlayer 0.38.8 → 0.38.10

package/src/commands/transactions/appeal.ts

@@ -0,0 +1,83 @@
+import {TransactionHash} from "genlayer-js/types";
+import {parseStakingAmount, formatStakingAmount} from "genlayer-js";
+import {BaseAction} from "../../lib/actions/BaseAction";
+
+export interface AppealOptions {
+  rpc?: string;
+  bond?: string;
+}
+
+export interface AppealBondOptions {
+  rpc?: string;
+}
+
+export class AppealAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async appeal({
+    txId,
+    rpc,
+    bond,
+  }: {
+    txId: TransactionHash;
+    rpc?: string;
+    bond?: string;
+  }): Promise<void> {
+    const client = await this.getClient(rpc);
+
+    try {
+      let value: bigint | undefined;
+      if (bond) {
+        value = parseStakingAmount(bond);
+      } else {
+        this.startSpinner("Calculating appeal bond...");
+        try {
+          value = await client.getMinAppealBond({txId});
+          this.stopSpinner();
+          this.logInfo(`Appeal bond: ${formatStakingAmount(value)}`);
+        } catch {
+          this.stopSpinner();
+          value = undefined;
+        }
+      }
+
+      await this.confirmPrompt("Proceed with appeal?");
+
+      this.startSpinner(`Appealing transaction ${txId}...`);
+      const hash = await client.appealTransaction({
+        txId,
+        value,
+      });
+
+      this.setSpinnerText("Waiting for finalization...");
+      const result = await client.waitForTransactionReceipt({
+        hash,
+        retries: 100,
+        interval: 5000,
+      });
+      this.succeedSpinner("Appeal successfully executed", result);
+    } catch (error) {
+      this.failSpinner("Error during appeal operation", error);
+    }
+  }
+
+  async appealBond({
+    txId,
+    rpc,
+  }: {
+    txId: TransactionHash;
+    rpc?: string;
+  }): Promise<void> {
+    const client = await this.getClient(rpc, true);
+    this.startSpinner(`Calculating appeal bond for ${txId}...`);
+
+    try {
+      const bond = await client.getMinAppealBond({txId});
+      this.succeedSpinner(`Minimum appeal bond: ${formatStakingAmount(bond)}`);
+    } catch (error) {
+      this.failSpinner("Error calculating appeal bond", error);
+    }
+  }
+}

package/src/commands/transactions/index.ts

@@ -0,0 +1,60 @@
+import {Command} from "commander";
+import {TransactionStatus, TransactionHash} from "genlayer-js/types";
+import {ReceiptAction, ReceiptOptions} from "./receipt";
+import {AppealAction, AppealOptions, AppealBondOptions} from "./appeal";
+import {TraceAction, TraceOptions} from "./trace";
+
+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("--bond <amount>", "Appeal bond amount (e.g. 500gen, 0.5gen). Auto-calculated if omitted")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (txId: TransactionHash, options: AppealOptions) => {
+      const appealAction = new AppealAction();
+      await appealAction.appeal({txId, ...options});
+    });
+
+  program
+    .command("appeal-bond <txId>")
+    .description("Show minimum appeal bond required for a transaction")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (txId: TransactionHash, options: AppealBondOptions) => {
+      const appealAction = new AppealAction();
+      await appealAction.appealBond({txId, ...options});
+    });
+
+  program
+    .command("trace <txId>")
+    .description("Get execution trace for a transaction (return data, stdout, stderr, GenVM logs)")
+    .option("--round <round>", "Consensus round number (default: 0)", (value) => parseIntOption(value, 0), 0)
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (txId: TransactionHash, options: TraceOptions) => {
+      const traceAction = new TraceAction();
+      await traceAction.trace({txId, ...options});
+    });
+
+  return program;
+}

package/src/commands/transactions/receipt.ts

@@ -0,0 +1,90 @@
+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/transactions/trace.ts

@@ -0,0 +1,42 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+import {TransactionHash} from "genlayer-js/types";
+
+export interface TraceParams {
+  txId: TransactionHash;
+  round?: number;
+  rpc?: string;
+}
+
+export interface TraceOptions extends Omit<TraceParams, 'txId'> {}
+
+export class TraceAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async trace({
+    txId,
+    round = 0,
+    rpc,
+  }: TraceParams): Promise<void> {
+    const client = await this.getClient(rpc, true);
+    this.startSpinner(`Fetching execution trace for ${txId} (round: ${round})...`);
+
+    try {
+      const result = await client.request({
+        method: "gen_dbg_traceTransaction" as any,
+        params: [{txID: txId, round}],
+      });
+
+      const trace = (result as any);
+      if (!trace) {
+        this.failSpinner("No trace found", `No execution trace found for transaction ${txId}`);
+        return;
+      }
+
+      this.succeedSpinner("Execution trace retrieved", trace);
+    } catch (error) {
+      this.failSpinner("Error retrieving execution trace", error);
+    }
+  }
+}

package/src/commands/update/index.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,103 @@
+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);
+    }
+  }
+}