genlayer 0.34.0 → 0.34.3

package/tests/actions/setNetwork.test.ts

@@ -1,160 +0,0 @@
-import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
-import {NetworkActions} from "../../src/commands/network/setNetwork";
-import {ConfigFileManager} from "../../src/lib/config/ConfigFileManager";
-import inquirer from "inquirer";
-import {localnet, studionet, testnetAsimov} from "genlayer-js/chains";
-
-vi.mock("../../src/lib/config/ConfigFileManager");
-vi.mock("inquirer");
-
-describe("NetworkActions", () => {
-  let networkActions: NetworkActions;
-
-  beforeEach(() => {
-    networkActions = new NetworkActions();
-    vi.clearAllMocks();
-
-    vi.spyOn(networkActions as any, "succeedSpinner").mockImplementation(() => {});
-    vi.spyOn(networkActions as any, "failSpinner").mockImplementation(() => {});
-    vi.spyOn(networkActions as any, "writeConfig").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("setNetwork method sets network by valid name", async () => {
-    await networkActions.setNetwork(localnet.name);
-
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "localnet");
-    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${localnet.name}`,
-    );
-  });
-
-  test("setNetwork method sets network by valid alias", async () => {
-    await networkActions.setNetwork("localnet");
-
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "localnet");
-    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${localnet.name}`,
-    );
-  });
-
-  test("setNetwork method sets studionet by name", async () => {
-    await networkActions.setNetwork(studionet.name);
-
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "studionet");
-    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${studionet.name}`,
-    );
-  });
-
-  test("setNetwork method sets studionet by alias", async () => {
-    await networkActions.setNetwork("studionet");
-
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "studionet");
-    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${studionet.name}`,
-    );
-  });
-
-  test("setNetwork method sets testnet-asimov by name", async () => {
-    await networkActions.setNetwork(testnetAsimov.name);
-
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "testnet-asimov");
-    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${testnetAsimov.name}`,
-    );
-  });
-
-  test("setNetwork method sets testnet-asimov by alias", async () => {
-    await networkActions.setNetwork("testnet-asimov");
-
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "testnet-asimov");
-    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${testnetAsimov.name}`,
-    );
-  });
-
-  test("setNetwork method fails for invalid network name", async () => {
-    await networkActions.setNetwork("invalidNetwork");
-
-    expect(networkActions["failSpinner"]).toHaveBeenCalledWith("Network invalidNetwork not found");
-    expect(networkActions["writeConfig"]).not.toHaveBeenCalled();
-    expect(networkActions["succeedSpinner"]).not.toHaveBeenCalled();
-  });
-
-  test("setNetwork method fails for empty network name", async () => {
-    await networkActions.setNetwork("");
-
-    expect(networkActions["failSpinner"]).toHaveBeenCalledWith("Network  not found");
-    expect(networkActions["writeConfig"]).not.toHaveBeenCalled();
-    expect(networkActions["succeedSpinner"]).not.toHaveBeenCalled();
-  });
-
-  test("setNetwork method prompts user when no network name provided", async () => {
-    vi.mocked(inquirer.prompt).mockResolvedValue({
-      selectedNetwork: "localnet",
-    });
-
-    await networkActions.setNetwork();
-
-    expect(inquirer.prompt).toHaveBeenCalledWith([
-      {
-        type: "list",
-        name: "selectedNetwork",
-        message: "Select which network do you want to use:",
-        choices: [
-          {name: localnet.name, value: "localnet"},
-          {name: studionet.name, value: "studionet"},
-          {name: testnetAsimov.name, value: "testnet-asimov"},
-        ],
-      },
-    ]);
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "localnet");
-    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${localnet.name}`,
-    );
-  });
-
-  test("setNetwork method handles interactive selection of studionet", async () => {
-    vi.mocked(inquirer.prompt).mockResolvedValue({
-      selectedNetwork: "studionet",
-    });
-
-    await networkActions.setNetwork();
-
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "studionet");
-    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${studionet.name}`,
-    );
-  });
-
-  test("setNetwork method handles interactive selection of testnet-asimov", async () => {
-    vi.mocked(inquirer.prompt).mockResolvedValue({
-      selectedNetwork: "testnet-asimov",
-    });
-
-    await networkActions.setNetwork();
-
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "testnet-asimov");
-    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${testnetAsimov.name}`,
-    );
-  });
-
-  test("setNetwork method handles case-sensitive network names", async () => {
-    await networkActions.setNetwork("LOCALNET");
-
-    expect(networkActions["failSpinner"]).toHaveBeenCalledWith("Network LOCALNET not found");
-    expect(networkActions["writeConfig"]).not.toHaveBeenCalled();
-  });
-
-  test("setNetwork method handles partial network names", async () => {
-    await networkActions.setNetwork("local");
-
-    expect(networkActions["failSpinner"]).toHaveBeenCalledWith("Network local not found");
-    expect(networkActions["writeConfig"]).not.toHaveBeenCalled();
-  });
-});

package/tests/actions/staking.test.ts

@@ -1,279 +0,0 @@
-import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
-import {ValidatorJoinAction} from "../../src/commands/staking/validatorJoin";
-import {ValidatorDepositAction} from "../../src/commands/staking/validatorDeposit";
-import {ValidatorExitAction} from "../../src/commands/staking/validatorExit";
-import {ValidatorClaimAction} from "../../src/commands/staking/validatorClaim";
-import {DelegatorJoinAction} from "../../src/commands/staking/delegatorJoin";
-import {DelegatorExitAction} from "../../src/commands/staking/delegatorExit";
-import {DelegatorClaimAction} from "../../src/commands/staking/delegatorClaim";
-import {StakingInfoAction} from "../../src/commands/staking/stakingInfo";
-
-// Mock genlayer-js
-vi.mock("genlayer-js", () => ({
-  createClient: vi.fn(),
-  createAccount: vi.fn(() => ({address: "0xMockedAddress"})),
-  formatStakingAmount: vi.fn((val: bigint) => `${Number(val) / 1e18} GEN`),
-  parseStakingAmount: vi.fn((val: string) => {
-    if (val.toLowerCase().endsWith("gen") || val.toLowerCase().endsWith("eth")) {
-      return BigInt(parseFloat(val.slice(0, -3)) * 1e18);
-    }
-    return BigInt(val);
-  }),
-  abi: {
-    STAKING_ABI: [],
-  },
-}));
-
-vi.mock("genlayer-js/chains", () => ({
-  localnet: {id: 1, name: "localnet", rpcUrls: {default: {http: ["http://localhost:8545"]}}},
-  studionet: {id: 2, name: "studionet", rpcUrls: {default: {http: ["https://studionet.genlayer.com"]}}},
-  testnetAsimov: {id: 3, name: "testnet-asimov", rpcUrls: {default: {http: ["https://testnet.genlayer.com"]}}},
-}));
-
-const mockTxResult = {
-  transactionHash: "0xMockedHash" as `0x${string}`,
-  blockNumber: 123n,
-  gasUsed: 21000n,
-};
-
-const mockValidatorJoinResult = {
-  ...mockTxResult,
-  validatorWallet: "0xValidatorWallet",
-  operator: "0xOperator",
-  amount: "42000 GEN",
-  amountRaw: 42000n * BigInt(1e18),
-};
-
-const mockDelegatorJoinResult = {
-  ...mockTxResult,
-  validator: "0xValidator",
-  delegator: "0xDelegator",
-  amount: "42 GEN",
-  amountRaw: 42n * BigInt(1e18),
-};
-
-const mockClient = {
-  validatorJoin: vi.fn(),
-  validatorDeposit: vi.fn(),
-  validatorExit: vi.fn(),
-  validatorClaim: vi.fn(),
-  delegatorJoin: vi.fn(),
-  delegatorExit: vi.fn(),
-  delegatorClaim: vi.fn(),
-  isValidator: vi.fn(),
-  getValidatorInfo: vi.fn(),
-  getStakeInfo: vi.fn(),
-  getEpochInfo: vi.fn(),
-  getEpochData: vi.fn(),
-  getActiveValidators: vi.fn(),
-  formatStakingAmount: vi.fn((val: bigint) => `${Number(val) / 1e18} GEN`),
-};
-
-function setupActionMocks(action: any) {
-  vi.spyOn(action as any, "getStakingClient").mockResolvedValue(mockClient);
-  vi.spyOn(action as any, "getReadOnlyStakingClient").mockResolvedValue(mockClient);
-  vi.spyOn(action as any, "getSignerAddress").mockResolvedValue("0xMockedSigner");
-  vi.spyOn(action as any, "startSpinner").mockImplementation(() => {});
-  vi.spyOn(action as any, "setSpinnerText").mockImplementation(() => {});
-  vi.spyOn(action as any, "succeedSpinner").mockImplementation(() => {});
-  vi.spyOn(action as any, "failSpinner").mockImplementation(() => {});
-}
-
-describe("ValidatorJoinAction", () => {
-  let action: ValidatorJoinAction;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    action = new ValidatorJoinAction();
-    setupActionMocks(action);
-    mockClient.validatorJoin.mockResolvedValue(mockValidatorJoinResult);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("joins as validator without operator", async () => {
-    await action.execute({amount: "42000gen", stakingAddress: "0xStaking"});
-
-    expect(mockClient.validatorJoin).toHaveBeenCalledWith({
-      amount: expect.any(BigInt),
-      operator: undefined,
-    });
-    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Validator created successfully!", expect.any(Object));
-  });
-
-  test("joins as validator with operator", async () => {
-    await action.execute({amount: "42000gen", operator: "0xOperator", stakingAddress: "0xStaking"});
-
-    expect(mockClient.validatorJoin).toHaveBeenCalledWith({
-      amount: expect.any(BigInt),
-      operator: "0xOperator",
-    });
-  });
-
-  test("handles errors", async () => {
-    mockClient.validatorJoin.mockRejectedValue(new Error("Join failed"));
-
-    await action.execute({amount: "42000gen", stakingAddress: "0xStaking"});
-
-    expect(action["failSpinner"]).toHaveBeenCalledWith("Failed to create validator", "Join failed");
-  });
-});
-
-// ValidatorDepositAction, ValidatorExitAction, ValidatorClaimAction tests
-// are covered by command-level tests. These actions now use viem directly
-// to call ValidatorWallet contracts and require complex viem mocking.
-
-describe("DelegatorJoinAction", () => {
-  let action: DelegatorJoinAction;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    action = new DelegatorJoinAction();
-    setupActionMocks(action);
-    mockClient.delegatorJoin.mockResolvedValue(mockDelegatorJoinResult);
-  });
-
-  test("joins as delegator successfully", async () => {
-    await action.execute({validator: "0xValidator", amount: "42gen", stakingAddress: "0xStaking"});
-
-    expect(mockClient.delegatorJoin).toHaveBeenCalledWith({
-      validator: "0xValidator",
-      amount: expect.any(BigInt),
-    });
-    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Successfully joined as delegator!", expect.any(Object));
-  });
-});
-
-describe("DelegatorExitAction", () => {
-  let action: DelegatorExitAction;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    action = new DelegatorExitAction();
-    setupActionMocks(action);
-    mockClient.delegatorExit.mockResolvedValue(mockTxResult);
-    mockClient.getEpochInfo.mockResolvedValue(mockEpochInfo);
-  });
-
-  test("exits successfully", async () => {
-    await action.execute({validator: "0xValidator", shares: "50", stakingAddress: "0xStaking"});
-
-    expect(mockClient.delegatorExit).toHaveBeenCalledWith({validator: "0xValidator", shares: 50n});
-    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Exit initiated successfully!", expect.any(Object));
-  });
-});
-
-describe("DelegatorClaimAction", () => {
-  let action: DelegatorClaimAction;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    action = new DelegatorClaimAction();
-    setupActionMocks(action);
-    mockClient.delegatorClaim.mockResolvedValue(mockTxResult);
-  });
-
-  test("claims successfully", async () => {
-    await action.execute({validator: "0xValidator", delegator: "0xDelegator", stakingAddress: "0xStaking"});
-
-    expect(mockClient.delegatorClaim).toHaveBeenCalledWith({validator: "0xValidator", delegator: "0xDelegator"});
-    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Claim successful!", expect.any(Object));
-  });
-});
-
-const mockEpochInfo = {
-  currentEpoch: 10n,
-  currentEpochStart: new Date("2024-01-01T00:00:00Z"),
-  currentEpochEnd: new Date("2024-01-01T01:00:00Z"),
-  nextEpochEstimate: new Date("2024-01-01T02:00:00Z"),
-  epochMinDuration: 3600n,
-  validatorMinStake: "42000 GEN",
-  validatorMinStakeRaw: 42000n * BigInt(1e18),
-  delegatorMinStake: "42 GEN",
-  delegatorMinStakeRaw: 42n * BigInt(1e18),
-  activeValidatorsCount: 5n,
-  inflation: "1000 GEN",
-  inflationRaw: 1000n * BigInt(1e18),
-  totalWeight: 100000n * BigInt(1e18),
-  totalClaimed: "500 GEN",
-  totalClaimedRaw: 500n * BigInt(1e18),
-};
-
-describe("StakingInfoAction", () => {
-  let action: StakingInfoAction;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    action = new StakingInfoAction();
-    setupActionMocks(action);
-    mockClient.getEpochInfo.mockResolvedValue(mockEpochInfo);
-    mockClient.getEpochData.mockResolvedValue({
-      start: BigInt(Math.floor(Date.now() / 1000) - 3600),
-      end: 0n,
-      vcount: 5n,
-      weight: 100000n,
-      inflation: 1000n * BigInt(1e18),
-      claimed: 500n * BigInt(1e18),
-      slashed: 0n,
-    });
-  });
-
-  test("gets validator info", async () => {
-    mockClient.isValidator.mockResolvedValue(true);
-    mockClient.getValidatorInfo.mockResolvedValue({
-      address: "0xValidator",
-      owner: "0xOwner",
-      operator: "0xOperator",
-      vStake: "1000 GEN",
-      vStakeRaw: 1000n,
-      vShares: 100n,
-      dStake: "500 GEN",
-      dStakeRaw: 500n,
-      dShares: 50n,
-      vDeposit: "0 GEN",
-      vDepositRaw: 0n,
-      vWithdrawal: "0 GEN",
-      vWithdrawalRaw: 0n,
-      ePrimed: 5n,
-      needsPriming: false,
-      live: true,
-      banned: false,
-      bannedEpoch: null,
-      pendingDeposits: [],
-      pendingWithdrawals: [],
-      identity: null,
-    });
-
-    await action.getValidatorInfo({validator: "0xValidator", stakingAddress: "0xStaking"});
-
-    expect(mockClient.isValidator).toHaveBeenCalledWith("0xValidator");
-    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Validator info retrieved", expect.any(Object));
-  });
-
-  test("fails if not a validator", async () => {
-    mockClient.isValidator.mockResolvedValue(false);
-
-    await action.getValidatorInfo({validator: "0xNotValidator", stakingAddress: "0xStaking"});
-
-    expect(action["failSpinner"]).toHaveBeenCalledWith("Address 0xNotValidator is not a validator");
-  });
-
-  test("gets epoch info", async () => {
-    await action.getEpochInfo({stakingAddress: "0xStaking"});
-
-    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Epoch info");
-  });
-
-  test("lists active validators", async () => {
-    mockClient.getActiveValidators.mockResolvedValue(["0xV1", "0xV2", "0xV3"]);
-
-    await action.listActiveValidators({stakingAddress: "0xStaking"});
-
-    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Active validators retrieved", {
-      count: 3,
-      validators: ["0xV1", "0xV2", "0xV3"],
-    });
-  });
-});

package/tests/actions/start.test.ts

@@ -1,235 +0,0 @@
-import {describe, beforeEach, afterEach, test, expect, vi, Mock} from "vitest";
-import inquirer from "inquirer";
-import {StartAction, StartActionOptions} from "../../src/commands/general/start";
-import {SimulatorService} from "../../src/lib/services/simulator";
-
-vi.mock("../../src/lib/services/simulator");
-vi.mock("inquirer");
-
-describe("StartAction", () => {
-  let startAction: StartAction;
-  let mockSimulatorService: SimulatorService;
-  let mockConfirmPrompt: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockSimulatorService = new SimulatorService();
-    startAction = new StartAction();
-    startAction["simulatorService"] = mockSimulatorService;
-
-    mockSimulatorService.waitForSimulatorToBeReady = vi.fn().mockResolvedValue({initialized: true});
-    mockSimulatorService.stopDockerContainers = vi.fn().mockResolvedValue(undefined);
-    mockSimulatorService.getAiProvidersOptions = vi.fn().mockResolvedValue(undefined);
-
-    mockConfirmPrompt = vi.spyOn(startAction as any, "confirmPrompt").mockResolvedValue(undefined);
-    vi.spyOn(startAction as any, "startSpinner").mockImplementation(() => {});
-    vi.spyOn(startAction as any, "setSpinnerText").mockImplementation(() => {});
-    vi.spyOn(startAction as any, "succeedSpinner").mockImplementation(() => {});
-    vi.spyOn(startAction as any, "failSpinner").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  const defaultOptions: StartActionOptions = {
-    resetValidators: false,
-    numValidators: 5,
-    headless: false,
-    resetDb: false,
-    ollama: false
-  };
-
-  test("should check if localnet is running and proceed without confirmation when not running", async () => {
-    mockSimulatorService.isLocalnetRunning = vi.fn().mockResolvedValue(false);
-
-    await startAction.execute(defaultOptions);
-
-    expect(mockSimulatorService.isLocalnetRunning).toHaveBeenCalled();
-    expect(mockConfirmPrompt).not.toHaveBeenCalled();
-    expect(mockSimulatorService.runSimulator).toHaveBeenCalled();
-  });
-
-  test("should prompt for confirmation when localnet is already running", async () => {
-    mockSimulatorService.isLocalnetRunning = vi.fn().mockResolvedValue(true);
-
-    await startAction.execute(defaultOptions);
-
-    expect(mockSimulatorService.isLocalnetRunning).toHaveBeenCalled();
-    expect(mockConfirmPrompt).toHaveBeenCalledWith(
-      "GenLayer Localnet is already running. Do you want to proceed?",
-    );
-    expect(mockSimulatorService.runSimulator).toHaveBeenCalled();
-  });
-
-  test("should start the simulator successfully", async () => {
-    mockSimulatorService.checkCliVersion = vi.fn().mockResolvedValue(undefined);
-    mockSimulatorService.runSimulator = vi.fn().mockResolvedValue(undefined);
-    mockSimulatorService.getFrontendUrl = vi.fn().mockReturnValue("http://localhost:8080");
-
-    await startAction.execute(defaultOptions);
-
-    expect(startAction["startSpinner"]).toHaveBeenCalledWith("Checking CLI version...");
-    expect(mockSimulatorService.checkCliVersion).toHaveBeenCalled();
-
-    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith(
-      "Starting GenLayer Localnet (keeping the existing validators)...",
-    );
-    expect(mockSimulatorService.runSimulator).toHaveBeenCalled();
-
-    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Waiting for the simulator to be ready...");
-    expect(mockSimulatorService.waitForSimulatorToBeReady).toHaveBeenCalled();
-
-    expect(startAction["succeedSpinner"]).toHaveBeenCalledWith(
-      "GenLayer simulator initialized successfully! Go to http://localhost:8080 in your browser to access it.",
-    );
-  });
-
-  test("should fail when simulator fails to start", async () => {
-    const errorMsg = new Error("runSimulator error");
-    (mockSimulatorService.runSimulator as Mock).mockRejectedValueOnce(errorMsg);
-
-    await startAction.execute(defaultOptions);
-
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Error starting the simulator", errorMsg);
-  });
-
-  test("should fail when waiting for simulator initialization times out", async () => {
-    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({
-      initialized: false,
-      errorCode: "TIMEOUT",
-    });
-
-    await startAction.execute(defaultOptions);
-
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
-      "The simulator is taking too long to initialize. Please try again later.",
-    );
-  });
-
-  test("should reset the database if resetDb is true", async () => {
-    const options: StartActionOptions = {...defaultOptions, resetDb: true};
-
-    mockSimulatorService.cleanDatabase = vi.fn().mockResolvedValue(undefined);
-
-    await startAction.execute(options);
-
-    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Resetting database...");
-    expect(mockSimulatorService.cleanDatabase).toHaveBeenCalled();
-  });
-
-  test("should initialize validators when resetValidators is true", async () => {
-    const options: StartActionOptions = {...defaultOptions, resetValidators: true};
-
-    mockSimulatorService.deleteAllValidators = vi.fn().mockResolvedValue(undefined);
-    mockSimulatorService.createRandomValidators = vi.fn().mockResolvedValue(undefined);
-    mockSimulatorService.getAiProvidersOptions = vi.fn().mockReturnValue(["Provider1", "Provider2"]);
-
-    vi.mocked(inquirer.prompt).mockResolvedValue({selectedLlmProviders: ["Provider1"]});
-
-    await startAction.execute(options);
-
-    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Initializing validators...");
-    expect(mockSimulatorService.deleteAllValidators).toHaveBeenCalled();
-    expect(mockSimulatorService.createRandomValidators).toHaveBeenCalledWith(5, ["Provider1"]);
-  });
-
-  test("should fail when initializing validators fails", async () => {
-    const options: StartActionOptions = {...defaultOptions, resetValidators: true};
-
-    mockSimulatorService.deleteAllValidators = vi
-      .fn()
-      .mockRejectedValue(new Error("Failed to delete validators"));
-
-    await startAction.execute(options);
-
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
-      "Unable to initialize the validators",
-      expect.any(Error),
-    );
-  });
-
-  test("should open frontend when not in headless mode", async () => {
-    mockSimulatorService.checkCliVersion = vi.fn().mockResolvedValue(undefined);
-    mockSimulatorService.runSimulator = vi.fn().mockResolvedValue(undefined);
-    mockSimulatorService.getFrontendUrl = vi.fn().mockReturnValue("http://localhost:8080");
-    mockSimulatorService.openFrontend = vi.fn().mockResolvedValue(undefined);
-
-    await startAction.execute(defaultOptions);
-
-    expect(startAction["startSpinner"]).toHaveBeenCalledWith("Opening frontend...");
-    expect(mockSimulatorService.openFrontend).toHaveBeenCalled();
-    expect(startAction["succeedSpinner"]).toHaveBeenCalledWith("Frontend opened successfully");
-  });
-
-  test("should handle errors when opening frontend", async () => {
-    const errorMsg = new Error("Failed to open frontend");
-    (mockSimulatorService.openFrontend as Mock).mockRejectedValueOnce(errorMsg);
-
-    await startAction.execute(defaultOptions);
-
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Error opening the frontend", errorMsg);
-  });
-
-  test("should log specific message if waitForSimulatorToBeReady returns TIMEOUT errorCode", async () => {
-    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({
-      initialized: false,
-      errorCode: "TIMEOUT",
-      errorMessage: "Initialization timed out",
-    });
-
-    await startAction.execute(defaultOptions);
-
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
-      "The simulator is taking too long to initialize. Please try again later.",
-    );
-  });
-
-  test("should log error message if simulator fails to initialize with ERROR code", async () => {
-    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({
-      initialized: false,
-      errorCode: "ERROR",
-      errorMessage: "Initialization failed",
-    });
-
-    await startAction.execute(defaultOptions);
-
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
-      "Unable to initialize the GenLayer simulator.",
-      "Initialization failed",
-    );
-  });
-
-  test("catches and logs error if waitForSimulatorToBeReady throws an exception", async () => {
-    const errorMsg = new Error("Unexpected initialization error");
-    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockRejectedValueOnce(errorMsg);
-
-    await startAction.execute(defaultOptions);
-
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
-      "Error waiting for the simulator to be ready",
-      errorMsg,
-    );
-  });
-
-  test("should not append frontend URL when in headless mode", async () => {
-    await startAction.execute({...defaultOptions, headless: true});
-
-    expect(startAction["succeedSpinner"]).toHaveBeenCalledWith(
-      "GenLayer simulator initialized successfully! ",
-    );
-  });
-
-  test("should exclude ollama from choices when ollama option is false", async () => {
-    await startAction.execute({ ...defaultOptions, resetValidators: true, ollama: false });
-    
-    expect(mockSimulatorService.getAiProvidersOptions).toHaveBeenCalledWith(false, ["ollama"]);
-  });
-
-  test("should include ollama in choices when ollama option is true", async () => {
-    await startAction.execute({ ...defaultOptions, resetValidators: true, ollama: true });
-
-    expect(mockSimulatorService.getAiProvidersOptions).toHaveBeenCalledWith(false, []);
-  });
-});