genlayer 0.38.8 → 0.38.10

package/src/lib/config/simulator.ts

@@ -0,0 +1,68 @@
+export const localnetCompatibleVersion = "v0.65.0";
+export const DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
+export const CONTAINERS_NAME_PREFIX = "/genlayer-";
+export const IMAGES_NAME_PREFIX = "yeagerai";
+export const DEFAULT_RUN_SIMULATOR_COMMAND = (location: string, profiles: string) => ({
+  darwin: `osascript -e 'tell application "Terminal" to do script "cd \\"${location}\\" && docker compose build && docker compose -p genlayer ${profiles} up"'`,
+  win32: `cd /d "${location}" && docker compose build && docker compose -p genlayer ${profiles} up -d`,
+  linux: `nohup bash -c 'cd "${location}" && docker compose build && docker compose -p genlayer ${profiles} up -d'`,
+});
+export const DEFAULT_RUN_DOCKER_COMMAND = {
+  darwin: "open -a Docker",
+  win32: 'start "" "C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe"',
+  linux: "sudo systemctl start docker",
+};
+
+export const VERSION_REQUIREMENTS = {
+  docker: "25.0.0",
+  node: "18.0.0",
+};
+
+export const AVAILABLE_PLATFORMS = ["darwin", "win32", "linux"] as const;
+export type RunningPlatform = (typeof AVAILABLE_PLATFORMS)[number];
+export const STARTING_TIMEOUT_WAIT_CYLCE = 2000;
+export const STARTING_TIMEOUT_ATTEMPTS = 120;
+
+export type AiProviders = "ollama" | "openai" | "heuristai" | "geminiai" | "xai";
+export type AiProvidersEnvVars = "ollama" | "OPENAIKEY" | "HEURISTAIAPIKEY" | "GEMINI_API_KEY" | "XAI_API_KEY";
+export type AiProvidersConfigType = {
+  [key in AiProviders]: {name: string; hint: string; envVar?: AiProvidersEnvVars; cliOptionValue: string};
+};
+
+export const AI_PROVIDERS_CONFIG: AiProvidersConfigType = {
+  ollama: {
+    name: "Ollama",
+    hint: "(By default, this will download and run a local instance of Llama 3)",
+    cliOptionValue: "ollama",
+  },
+  openai: {
+    name: "OpenAI",
+    hint: "(You will need to provide an OpenAI API key)",
+    envVar: "OPENAIKEY",
+    cliOptionValue: "openai",
+  },
+  heuristai: {
+    name: "Heurist",
+    hint: '(You will need to provide an API key. Get free API credits at https://dev-api-form.heurist.ai/ with referral code: "genlayer")',
+    envVar: "HEURISTAIAPIKEY",
+    cliOptionValue: "heuristai",
+  },
+  geminiai: {
+    name: "Gemini",
+    hint: '(You will need to provide an API key.)',
+    envVar: "GEMINI_API_KEY",
+    cliOptionValue: "geminiai",
+  },
+  xai: {
+    name: "XAI",
+    hint: '(You will need to provide an API key)',
+    envVar: "XAI_API_KEY",
+    cliOptionValue: "xai",
+  },
+};
+
+export const GENLAYER_REQUIRED_CONTAINERS = [
+  "genlayer-jsonrpc",
+  "genlayer-webrequest",
+  "genlayer-postgres"
+]

package/src/lib/config/text.ts

@@ -0,0 +1,2 @@
+export const CLI_DESCRIPTION =
+  "GenLayer CLI is a development environment for the GenLayer ecosystem. It allows developers to interact with the protocol by creating accounts, sending transactions, and working with Intelligent Contracts by testing, debugging, and deploying them.";

package/src/lib/errors/missingRequirement.ts

@@ -0,0 +1,9 @@
+export class MissingRequirementError extends Error {
+  requirement: string;
+
+  constructor(requirement: string) {
+    super(`${requirement} is not installed. Please install ${requirement}.`);
+    this.name = "MissingRequirement";
+    this.requirement = requirement;
+  }
+}

package/src/lib/errors/versionRequired.ts

@@ -0,0 +1,9 @@
+export class VersionRequiredError extends Error {
+  tool: string;
+
+  constructor(tool: string, requiredVersion: string) {
+    super(`${tool} version ${requiredVersion} or higher is required. Please update ${tool}.`);
+    this.name = "VersionRequired";
+    this.tool = tool;
+  }
+}

package/src/lib/interfaces/ISimulatorService.ts

@@ -0,0 +1,39 @@
+import {AiProviders} from "../config/simulator";
+
+export interface ISimulatorService {
+  setComposeOptions(headless: boolean, disableOllama?: boolean): void;
+  getComposeOptions(): string;
+  checkInstallRequirements(): Promise<Record<string, boolean>>;
+  checkVersionRequirements(): Promise<Record<string, string>>;
+  runSimulator(): Promise<{stdout: string; stderr: string}>;
+  waitForSimulatorToBeReady(retries?: number): Promise<WaitForSimulatorToBeReadyResultType>;
+  createRandomValidators(numValidators: number, llmProviders: AiProviders[]): Promise<any>;
+  deleteAllValidators(): Promise<any>;
+  getAiProvidersOptions(withHint: boolean, excludeProviders?: AiProviders[]): Array<{name: string; value: string}>;
+  getFrontendUrl(): string;
+  openFrontend(): Promise<boolean>;
+  stopDockerContainers(): Promise<void>;
+  resetDockerContainers(): Promise<void>;
+  resetDockerImages(): Promise<void>;
+  resetDockerVolumes(): Promise<void>;
+  checkCliVersion(): Promise<void>;
+  cleanDatabase(): Promise<boolean>;
+  addConfigToEnvFile(newConfig: Record<string, string>): void;
+  normalizeLocalnetVersion(version: string): string;
+  compareVersions(version1: string, version2: string): number;
+  ensureDockerRunning(): Promise<void>;
+  isLocalnetRunning(): Promise<boolean>;
+  setupLocalhostAccess(): void;
+}
+
+
+export type WaitForSimulatorToBeReadyResultType = {
+  initialized: boolean;
+  errorCode?: "TIMEOUT" | "ERROR";
+  errorMessage?: string;
+};
+
+export type InitializeDatabaseResultType = {
+  createResponse: any;
+  tablesResponse: any;
+};

package/src/lib/services/simulator.ts

@@ -0,0 +1,386 @@
+import Docker, {ContainerInfo} from "dockerode";
+import * as fs from "fs";
+import * as dotenv from "dotenv";
+import * as path from "path";
+import * as semver from "semver";
+import updateCheck from "update-check";
+import { fileURLToPath } from "url";
+import pkg from '../../../package.json'
+
+import {rpcClient} from "../clients/jsonRpcClient";
+import {
+  DEFAULT_RUN_SIMULATOR_COMMAND,
+  DEFAULT_RUN_DOCKER_COMMAND,
+  STARTING_TIMEOUT_WAIT_CYLCE,
+  STARTING_TIMEOUT_ATTEMPTS,
+  AI_PROVIDERS_CONFIG,
+  AiProviders,
+  VERSION_REQUIREMENTS,
+  CONTAINERS_NAME_PREFIX,
+  IMAGES_NAME_PREFIX,
+  GENLAYER_REQUIRED_CONTAINERS
+} from "../config/simulator";
+import {
+  checkCommand,
+  getVersion,
+  executeCommand,
+  openUrl,
+} from "../clients/system";
+import {MissingRequirementError} from "../errors/missingRequirement";
+
+import {
+  ISimulatorService,
+  WaitForSimulatorToBeReadyResultType,
+} from "../interfaces/ISimulatorService";
+import {VersionRequiredError} from "../errors/versionRequired";
+
+
+function sleep(millliseconds: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, millliseconds));
+}
+
+export class SimulatorService implements ISimulatorService {
+  private profileOptions: string
+  private docker: Docker;
+  public location: string;
+
+  constructor() {
+    const __filename = fileURLToPath(import.meta.url);
+    this.location = path.resolve(path.dirname(__filename), '..');
+    this.profileOptions = "";
+    this.docker = new Docker();
+  }
+
+  private readEnvConfigValue(key: string): string {
+    const envFilePath = path.join(this.location, ".env");
+    // Transform the config string to object
+    const envConfig = dotenv.parse(fs.readFileSync(envFilePath, "utf8"));
+    return envConfig[key];
+  }
+
+  private async getGenlayerContainers(): Promise<ContainerInfo[]> {
+    const containers = await this.docker.listContainers({ all: true });
+    return containers.filter(container =>
+      container.Names.some(name =>
+        name.startsWith(CONTAINERS_NAME_PREFIX)
+      )
+    );
+  }
+
+  private async stopAndRemoveContainers(remove: boolean = false): Promise<void> {
+    const genlayerContainers = await this.getGenlayerContainers();
+
+    for (const containerInfo of genlayerContainers) {
+      const container = this.docker.getContainer(containerInfo.Id);
+      if (containerInfo.State === "running") {
+        await container.stop();
+      }
+
+      const isOllamaContainer = containerInfo.Names.some(name => name.includes("ollama"));
+
+      if (remove && !isOllamaContainer) {
+        await container.remove();
+      }
+    }
+  }
+
+  public addConfigToEnvFile(newConfig: Record<string, string>): void {
+    const envFilePath = path.join(this.location, ".env");
+
+    // Transform the config string to object
+    const envConfig = dotenv.parse(fs.readFileSync(envFilePath, "utf8"));
+    Object.keys(newConfig).forEach(key => {
+      envConfig[key] = newConfig[key];
+    });
+
+    // Transform the updated config object back into a string
+    const updatedConfig = Object.keys(envConfig)
+      .map(key => {
+        return `${key}=${envConfig[key]}`;
+      })
+      .join("\n");
+
+    // Write the new .env file
+    fs.writeFileSync(envFilePath, updatedConfig);
+  }
+
+  public setComposeOptions(headless: boolean, ollama: boolean = false): void {
+    let profiles = [];
+    
+    if (!headless) {
+      profiles.push("frontend");
+    }
+    
+    if (ollama) {
+      profiles.push("ollama");
+    }
+    
+    this.profileOptions = profiles.length > 0 ? `--profile ${profiles.join(" --profile ")}` : "";
+  }
+
+  public getComposeOptions(): string {
+    return this.profileOptions;
+  }
+
+  public async checkCliVersion(): Promise<void> {
+    const update = await updateCheck(pkg);
+    if (update && update.latest !== pkg.version) {
+      console.warn(`\nA new version (${update.latest}) is available! You're using version ${pkg.version}.\nRun npm install -g genlayer to update\n`);
+    }
+  }
+
+  public async ensureDockerRunning(): Promise<void> {
+    await this.docker.ping();
+  }
+
+  public async checkInstallRequirements(): Promise<Record<string, boolean>> {
+    const requirementsInstalled = {
+      docker: false,
+    };
+
+    try {
+      await checkCommand("docker --version", "docker");
+      requirementsInstalled.docker = true;
+    } catch (error: any) {
+      if (!(error instanceof MissingRequirementError)) {
+        throw error;
+      }
+    }
+
+    if (requirementsInstalled.docker) {
+      try {
+        await this.docker.ping()
+      } catch (error: any) {
+        await executeCommand(DEFAULT_RUN_DOCKER_COMMAND);
+      }
+    }
+
+    return requirementsInstalled;
+  }
+
+  public async checkVersionRequirements(): Promise<Record<string, string>> {
+    const missingVersions = {
+      docker: "",
+      node: "",
+    };
+
+    try {
+      await this.checkVersion(VERSION_REQUIREMENTS.node, "node");
+    } catch (error: any) {
+      missingVersions.node = VERSION_REQUIREMENTS.node;
+      if (!(error instanceof VersionRequiredError)) {
+        throw error;
+      }
+    }
+
+    try {
+      await this.checkVersion(VERSION_REQUIREMENTS.docker, "docker");
+    } catch (error: any) {
+      missingVersions.docker = VERSION_REQUIREMENTS.docker;
+      if (!(error instanceof VersionRequiredError)) {
+        throw error;
+      }
+    }
+
+    return missingVersions;
+  }
+
+  public async checkVersion(minVersion: string, toolName: string): Promise<void> {
+    const version = await getVersion(toolName);
+
+    if (!semver.satisfies(version, `>=${minVersion}`)) {
+      throw new VersionRequiredError(toolName, minVersion);
+    }
+  }
+
+  public runSimulator(): Promise<{stdout: string; stderr: string}> {
+    const commandsByPlatform = DEFAULT_RUN_SIMULATOR_COMMAND(this.location, this.getComposeOptions());
+    return executeCommand(commandsByPlatform);
+  }
+
+  public async waitForSimulatorToBeReady(
+    retries: number = STARTING_TIMEOUT_ATTEMPTS,
+  ): Promise<WaitForSimulatorToBeReadyResultType> {
+    try {
+      const response = await rpcClient.request({method: "ping", params: []});
+
+      //Compatibility with current simulator version
+      if (response?.result === "OK" || response?.result?.status === "OK" || response?.result?.data?.status === "OK") {
+        return { initialized: true };
+      }
+      if (retries > 0) {
+        await sleep(STARTING_TIMEOUT_WAIT_CYLCE);
+        return this.waitForSimulatorToBeReady(retries - 1);
+      }
+    } catch (error: any) {
+      if (
+        (error.name === "FetchError" ||
+          error.message.includes("Fetch Error") ||
+          error.message.includes("ECONNRESET") ||
+          error.message.includes("ECONNREFUSED") ||
+          error.message.includes("socket hang up")) &&
+        retries > 0
+      ) {
+        await sleep(STARTING_TIMEOUT_WAIT_CYLCE * 2);
+        return this.waitForSimulatorToBeReady(retries - 1);
+      }
+      return {initialized: false, errorCode: "ERROR", errorMessage: error.message};
+    }
+
+    return {initialized: false, errorCode: "TIMEOUT"};
+  }
+
+  public createRandomValidators(numValidators: number, llmProviders: AiProviders[]): Promise<any> {
+    return rpcClient.request({
+      method: "sim_createRandomValidators",
+      params: [numValidators, 1, 10, llmProviders],
+    });
+  }
+
+  public deleteAllValidators(): Promise<any> {
+    return rpcClient.request({method: "sim_deleteAllValidators", params: []});
+  }
+
+  public getAiProvidersOptions(withHint: boolean = true, excludeProviders: AiProviders[] = []): Array<{name: string; value: string}> {
+    return Object.values(AI_PROVIDERS_CONFIG)
+      .filter(providerConfig => !excludeProviders.includes(providerConfig.cliOptionValue as AiProviders))
+      .map(providerConfig => {
+        return {
+          name: `${providerConfig.name}${withHint ? ` ${providerConfig.hint}` : ""}`,
+          value: providerConfig.cliOptionValue,
+        };
+      });
+  }
+
+  public getFrontendUrl(): string {
+    const frontendPort = this.readEnvConfigValue("FRONTEND_PORT");
+    return `http://localhost:${frontendPort}`;
+  }
+
+  public async openFrontend(): Promise<boolean> {
+    await openUrl(this.getFrontendUrl());
+    return true;
+  }
+
+  public async stopDockerContainers(): Promise<void> {
+    await this.stopAndRemoveContainers(false);
+  }
+
+  public async resetDockerContainers(): Promise<void> {
+    await this.stopAndRemoveContainers(true);
+  }
+
+  public async resetDockerImages(): Promise<void> {
+    const images = await this.docker.listImages();
+    const genlayerImages = images.filter(image =>
+      image.RepoTags?.some(tag => tag.startsWith(IMAGES_NAME_PREFIX))
+    );
+
+    for (const imageInfo of genlayerImages) {
+      const image = this.docker.getImage(imageInfo.Id);
+      await image.remove({force: true});
+    }
+  }
+
+  public async resetDockerVolumes(): Promise<void> {
+    const volumes = await this.docker.listVolumes();
+    const genlayerVolumes = volumes.Volumes?.filter(volume =>
+      volume.Name.startsWith('genlayer_')
+    ) || [];
+
+    for (const volumeInfo of genlayerVolumes) {
+      const volume = this.docker.getVolume(volumeInfo.Name);
+      await volume.remove({force: true});
+    }
+  }
+
+  public async cleanDatabase(): Promise<boolean> {
+
+    try {
+      await rpcClient.request({method: "sim_clearDbTables", params: [['current_state', 'transactions']]});
+    }catch (error) {
+      console.error(error);
+    }
+    return true;
+  }
+
+  public normalizeLocalnetVersion(version: string) {
+
+    if (!version.startsWith('v')) {
+      version = 'v' + version;
+    }
+
+    const versionRegex = /^v(\d+)\.(\d+)\.(\d+)(-.+)?$/;
+    const match = version.match(versionRegex);
+
+    if (!match) {
+      console.error('Invalid version format. Expected format: v0.0.0 or v0.0.0-suffix');
+      process.exit(1);
+    }
+
+    return version
+  }
+
+  public compareVersions(version1: string, version2: string): number {
+    const v1 = version1.replace(/^v/, '');
+    const v2 = version2.replace(/^v/, '');
+    
+    const parts1 = v1.split('-')[0].split('.').map(Number);
+    const parts2 = v2.split('-')[0].split('.').map(Number);
+    
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+      const part1 = parts1[i] || 0;
+      const part2 = parts2[i] || 0;
+      
+      if (part1 < part2) return -1;
+      if (part1 > part2) return 1;
+    }
+    
+    return 0;
+  }
+
+  public setupLocalhostAccess(): void {
+    const overridePath = path.join(this.location, 'docker-compose.override.yml');
+    const overrideContent = `# Auto-generated by genlayer CLI — enables localhost access for local development
+services:
+  jsonrpc:
+    volumes:
+      - ./config-overrides/genvm-module-web.yaml:/genvm/config/genvm-module-web.yaml:ro
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+      - "anvil-local:host-gateway"
+`;
+    fs.writeFileSync(overridePath, overrideContent);
+
+    const configDir = path.join(this.location, 'config-overrides');
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    const genvmConfigPath = path.join(configDir, 'genvm-module-web.yaml');
+    const genvmConfigContent = `# Auto-generated by genlayer CLI — allows GenVM to reach localhost services
+always_allow_hosts:
+  - "localhost"
+  - "127.0.0.1"
+  - "host.docker.internal"
+  - "anvil-local"
+`;
+    fs.writeFileSync(genvmConfigPath, genvmConfigContent);
+
+    console.warn('\x1b[33m⚠ Localhost access enabled — GenVM can reach host services (Anvil, local APIs). Not for production use.\x1b[0m');
+  }
+
+  public async isLocalnetRunning(): Promise<boolean> {
+    const genlayerContainers = await this.getGenlayerContainers();
+    const runningContainers = genlayerContainers.filter(container => container.State === "running");
+    
+    return GENLAYER_REQUIRED_CONTAINERS.every(requiredContainer => 
+      runningContainers.some(container => 
+        container.Names.some(name => name.includes(requiredContainer))
+      )
+    );
+  }
+
+}
+
+export default new SimulatorService();

package/src/types/node-fetch.d.ts

@@ -0,0 +1 @@
+declare module "node-fetch";

package/tests/actions/appeal.test.ts

@@ -0,0 +1,141 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import type {TransactionHash} from "genlayer-js/types";
+import {AppealAction} from "../../src/commands/transactions/appeal";
+
+vi.mock("genlayer-js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("genlayer-js")>();
+  return {
+    ...actual,
+    createClient: vi.fn(),
+    createAccount: vi.fn(),
+  };
+});
+
+describe("AppealAction", () => {
+  let appealAction: AppealAction;
+  const mockClient = {
+    appealTransaction: vi.fn(),
+    waitForTransactionReceipt: vi.fn(),
+    initializeConsensusSmartContract: vi.fn(),
+    getMinAppealBond: vi.fn(),
+  };
+
+  const mockPrivateKey = "mocked_private_key";
+  const mockTxId = "0x1234567890123456789012345678901234567890123456789012345678901234" as TransactionHash;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(createClient).mockReturnValue(mockClient as any);
+    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
+    appealAction = new AppealAction();
+    vi.spyOn(appealAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+
+    vi.spyOn(appealAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(appealAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(appealAction as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(appealAction as any, "stopSpinner").mockImplementation(() => {});
+    vi.spyOn(appealAction as any, "setSpinnerText").mockImplementation(() => {});
+    vi.spyOn(appealAction as any, "logInfo").mockImplementation(() => {});
+    vi.spyOn(appealAction as any, "confirmPrompt").mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("auto-calculates bond and appeals successfully", async () => {
+    const mockReceipt = {status: "success"};
+    vi.mocked(mockClient.getMinAppealBond).mockResolvedValue(500000000000000000000n);
+    vi.mocked(mockClient.appealTransaction).mockResolvedValue("0xhash");
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await appealAction.appeal({txId: mockTxId});
+
+    expect(mockClient.getMinAppealBond).toHaveBeenCalledWith({txId: mockTxId});
+    expect(mockClient.appealTransaction).toHaveBeenCalledWith({
+      txId: mockTxId,
+      value: 500000000000000000000n,
+    });
+    expect(appealAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Appeal successfully executed",
+      mockReceipt,
+    );
+  });
+
+  test("uses explicit bond when provided", async () => {
+    const mockReceipt = {status: "success"};
+    vi.mocked(mockClient.appealTransaction).mockResolvedValue("0xhash");
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await appealAction.appeal({txId: mockTxId, bond: "100gen"});
+
+    expect(mockClient.getMinAppealBond).not.toHaveBeenCalled();
+    expect(mockClient.appealTransaction).toHaveBeenCalledWith({
+      txId: mockTxId,
+      value: 100000000000000000000n,
+    });
+  });
+
+  test("falls back to undefined value when bond calculation fails", async () => {
+    const mockReceipt = {status: "success"};
+    vi.mocked(mockClient.getMinAppealBond).mockRejectedValue(new Error("not supported"));
+    vi.mocked(mockClient.appealTransaction).mockResolvedValue("0xhash");
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await appealAction.appeal({txId: mockTxId});
+
+    expect(mockClient.appealTransaction).toHaveBeenCalledWith({
+      txId: mockTxId,
+      value: undefined,
+    });
+  });
+
+  test("handles appealTransaction errors", async () => {
+    vi.mocked(mockClient.getMinAppealBond).mockResolvedValue(0n);
+    vi.mocked(mockClient.appealTransaction).mockRejectedValue(new Error("Mocked appeal error"));
+
+    await appealAction.appeal({txId: mockTxId});
+
+    expect(appealAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error during appeal operation",
+      expect.any(Error),
+    );
+  });
+
+  test("uses custom RPC URL for appeal operations", async () => {
+    const rpcUrl = "https://custom-rpc-url.com";
+    const mockReceipt = {status: "success"};
+    vi.mocked(mockClient.getMinAppealBond).mockResolvedValue(0n);
+    vi.mocked(mockClient.appealTransaction).mockResolvedValue("0xhash");
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await appealAction.appeal({txId: mockTxId, rpc: rpcUrl});
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({endpoint: rpcUrl}),
+    );
+  });
+
+  test("appealBond returns minimum bond", async () => {
+    vi.mocked(mockClient.getMinAppealBond).mockResolvedValue(500000000000000000000n);
+
+    await appealAction.appealBond({txId: mockTxId});
+
+    expect(mockClient.getMinAppealBond).toHaveBeenCalledWith({txId: mockTxId});
+    expect(appealAction["succeedSpinner"]).toHaveBeenCalledWith(
+      `Minimum appeal bond: 500 GEN`,
+    );
+  });
+
+  test("appealBond handles errors", async () => {
+    vi.mocked(mockClient.getMinAppealBond).mockRejectedValue(new Error("not supported"));
+
+    await appealAction.appealBond({txId: mockTxId});
+
+    expect(appealAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error calculating appeal bond",
+      expect.any(Error),
+    );
+  });
+});