genlayer 0.33.1 → 0.34.1

package/src/lib/services/simulator.ts

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

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

package/tests/actions/appeal.test.ts

@@ -1,99 +0,0 @@
-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");
-
-describe("AppealAction", () => {
-  let appealAction: AppealAction;
-  const mockClient = {
-    appealTransaction: vi.fn(),
-    waitForTransactionReceipt: vi.fn(),
-    initializeConsensusSmartContract: 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(() => {});
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("calls appealTransaction successfully", async () => {
-    const mockReceipt = {status: "success"};
-
-    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
-
-    await appealAction.appeal({
-      txId: mockTxId,
-    });
-
-    expect(mockClient.appealTransaction).toHaveBeenCalledWith({
-      txId: mockTxId,
-    });
-    expect(appealAction["succeedSpinner"]).toHaveBeenCalledWith(
-      "Appeal operation successfully executed",
-      mockReceipt,
-    );
-  });
-
-  test("handles appealTransaction errors", async () => {
-    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.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
-
-    await appealAction.appeal({
-      txId: mockTxId,
-      rpc: rpcUrl,
-    });
-
-    expect(createClient).toHaveBeenCalledWith(
-      expect.objectContaining({
-        endpoint: rpcUrl,
-      }),
-    );
-    expect(mockClient.appealTransaction).toHaveBeenCalledWith({
-      txId: mockTxId,
-    });
-    expect(appealAction["succeedSpinner"]).toHaveBeenCalledWith(
-      "Appeal operation successfully executed",
-      mockReceipt,
-    );
-  });
-
-  test("initializes consensus smart contract before appeal", async () => {
-    const mockReceipt = {status: "success"};
-
-    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
-
-    await appealAction.appeal({txId: mockTxId});
-
-    expect(mockClient.initializeConsensusSmartContract).toHaveBeenCalledTimes(1);
-    expect(mockClient.appealTransaction).toHaveBeenCalled();
-  });
-}); 

package/tests/actions/call.test.ts

@@ -1,94 +0,0 @@
-import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
-import {createClient, createAccount} from "genlayer-js";
-import {CallAction} from "../../src/commands/contracts/call";
-
-vi.mock("genlayer-js");
-
-describe("CallAction", () => {
-  let callActions: CallAction;
-  const mockClient = {
-    readContract: vi.fn(),
-    writeContract: vi.fn(),
-    waitForTransactionReceipt: vi.fn(),
-    getContractSchema: vi.fn(),
-    initializeConsensusSmartContract: vi.fn(),
-  };
-
-  const mockPrivateKey = "mocked_private_key";
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(createClient).mockReturnValue(mockClient as any);
-    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
-    callActions = new CallAction();
-    vi.spyOn(callActions as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
-
-    vi.spyOn(callActions as any, "startSpinner").mockImplementation(() => {});
-    vi.spyOn(callActions as any, "succeedSpinner").mockImplementation(() => {});
-    vi.spyOn(callActions as any, "failSpinner").mockImplementation(() => {});
-    vi.spyOn(callActions as any, "log").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("calls readContract successfully", async () => {
-    const options = {args: [1, 2, "Hello"]};
-    const mockResult = "mocked_result";
-
-    vi.mocked(mockClient.readContract).mockResolvedValue(mockResult);
-
-    await callActions.call({
-      contractAddress: "0xMockedContract",
-      method: "getData",
-      ...options,
-    });
-
-    expect(mockClient.readContract).toHaveBeenCalledWith({
-      address: "0xMockedContract",
-      functionName: "getData",
-      args: [1, 2, "Hello"],
-    });
-    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith(
-      "Read operation successfully executed",
-      "mocked_result",
-    );
-  });
-
-  test("handles readContract errors", async () => {
-    vi.mocked(mockClient.readContract).mockRejectedValue(new Error("Mocked read error"));
-
-    await callActions.call({contractAddress: "0xMockedContract", method: "getData", args: [1]});
-
-    expect(callActions["failSpinner"]).toHaveBeenCalledWith("Error during read operation", expect.any(Error));
-  });
-
-  test("uses custom RPC URL when provided", async () => {
-    const options = {args: [1, 2, "Hello"], rpc: "https://custom-rpc-url.com"};
-    const mockResult = "mocked_result";
-
-    vi.mocked(mockClient.readContract).mockResolvedValue(mockResult);
-
-    await callActions.call({
-      contractAddress: "0xMockedContract",
-      method: "getData",
-      ...options,
-    });
-
-    expect(createClient).toHaveBeenCalledWith(
-      expect.objectContaining({
-        endpoint: "https://custom-rpc-url.com",
-      }),
-    );
-    expect(mockClient.readContract).toHaveBeenCalledWith({
-      address: "0xMockedContract",
-      functionName: "getData",
-      args: [1, 2, "Hello"],
-    });
-    expect(callActions["succeedSpinner"]).toHaveBeenCalledWith(
-      "Read operation successfully executed",
-      "mocked_result",
-    );
-  });
-});

package/tests/actions/code.test.ts

@@ -1,87 +0,0 @@
-import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
-import {createClient, createAccount} from "genlayer-js";
-import {CodeAction} from "../../src/commands/contracts/code";
-
-vi.mock("genlayer-js");
-
-describe("CodeAction", () => {
-  let codeAction: CodeAction;
-  const mockClient = {
-    getContractCode: vi.fn(),
-    initializeConsensusSmartContract: vi.fn(),
-  };
-
-  const mockPrivateKey = "mocked_private_key";
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(createClient).mockReturnValue(mockClient as any);
-    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
-    codeAction = new CodeAction();
-    vi.spyOn(codeAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
-
-    vi.spyOn(codeAction as any, "startSpinner").mockImplementation(() => {});
-    vi.spyOn(codeAction as any, "succeedSpinner").mockImplementation(() => {});
-    vi.spyOn(codeAction as any, "failSpinner").mockImplementation(() => {});
-    vi.spyOn(codeAction as any, "log").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("gets contract code successfully", async () => {
-    const mockResult = "0x600160...";
-
-    vi.mocked(mockClient.getContractCode).mockResolvedValue(mockResult as any);
-
-    await codeAction.code({
-      contractAddress: "0xMockedContract",
-    });
-
-    expect(mockClient.getContractCode).toHaveBeenCalledWith("0xMockedContract");
-    expect(codeAction["succeedSpinner"]).toHaveBeenCalledWith(
-      "Contract code retrieved successfully",
-      mockResult,
-    );
-  });
-
-  test("handles getContractCode errors", async () => {
-    vi.mocked(mockClient.getContractCode).mockRejectedValue(new Error("Mocked code error"));
-
-    await codeAction.code({contractAddress: "0xMockedContract"});
-
-    expect(codeAction["failSpinner"]).toHaveBeenCalledWith("Error retrieving contract code", expect.any(Error));
-  });
-
-  test("uses custom RPC URL when provided", async () => {
-    const mockResult = "0x600160...";
-    vi.mocked(mockClient.getContractCode).mockResolvedValue(mockResult as any);
-
-    await codeAction.code({
-      contractAddress: "0xMockedContract",
-      rpc: "https://custom-rpc-url.com",
-    });
-
-    expect(createClient).toHaveBeenCalledWith(
-      expect.objectContaining({
-        endpoint: "https://custom-rpc-url.com",
-      }),
-    );
-    expect(mockClient.getContractCode).toHaveBeenCalledWith("0xMockedContract");
-    expect(codeAction["succeedSpinner"]).toHaveBeenCalledWith(
-      "Contract code retrieved successfully",
-      mockResult,
-    );
-  });
-
-  test("initializes consensus smart contract", async () => {
-    vi.mocked(mockClient.getContractCode).mockResolvedValue("0x" as any);
-
-    await codeAction.code({contractAddress: "0xMockedContract"});
-
-    expect(mockClient.initializeConsensusSmartContract).toHaveBeenCalled();
-  });
-});
-
-

package/tests/actions/create.test.ts

@@ -1,65 +0,0 @@
-import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
-import {CreateAccountAction} from "../../src/commands/account/create";
-import {readFileSync, existsSync} from "fs";
-import os from "os";
-
-vi.mock("fs");
-vi.mock("os");
-
-describe("CreateAccountAction", () => {
-  let createAction: CreateAccountAction;
-  const mockKeystorePath = "/mocked/home/.genlayer/keystores/main.json";
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Setup mocks before creating the action (needed for constructor)
-    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
-    vi.mocked(existsSync).mockReturnValue(true);
-    vi.mocked(readFileSync).mockReturnValue(JSON.stringify({activeAccount: "default"}));
-
-    createAction = new CreateAccountAction();
-
-    // Mock the BaseAction methods
-    vi.spyOn(createAction as any, "startSpinner").mockImplementation(() => {});
-    vi.spyOn(createAction as any, "succeedSpinner").mockImplementation(() => {});
-    vi.spyOn(createAction as any, "failSpinner").mockImplementation(() => {});
-    vi.spyOn(createAction as any, "createKeypairByName").mockResolvedValue("0x1234567890abcdef");
-    vi.spyOn(createAction as any, "setActiveAccount").mockImplementation(() => {});
-    vi.spyOn(createAction as any, "getKeystorePath").mockReturnValue(mockKeystorePath);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("successfully creates and saves an encrypted keystore", async () => {
-    const options = {name: "main", overwrite: false, setActive: true};
-
-    await createAction.execute(options);
-
-    expect(createAction["startSpinner"]).toHaveBeenCalledWith("Creating account 'main'...");
-    expect(createAction["createKeypairByName"]).toHaveBeenCalledWith("main", false);
-    expect(createAction["setActiveAccount"]).toHaveBeenCalledWith("main");
-    expect(createAction["succeedSpinner"]).toHaveBeenCalledWith(
-      `Account 'main' created at: ${mockKeystorePath}`,
-    );
-  });
-
-  test("handles errors during keystore creation", async () => {
-    const mockError = new Error("Mocked creation error");
-    vi.spyOn(createAction as any, "createKeypairByName").mockRejectedValue(mockError);
-
-    await createAction.execute({name: "main", overwrite: true});
-
-    expect(createAction["failSpinner"]).toHaveBeenCalledWith("Failed to create account", mockError);
-  });
-
-  test("skips setting active account when setActive is false", async () => {
-    const options = {name: "validator", overwrite: false, setActive: false};
-
-    await createAction.execute(options);
-
-    expect(createAction["setActiveAccount"]).not.toHaveBeenCalled();
-    expect(createAction["succeedSpinner"]).toHaveBeenCalled();
-  });
-});