genlayer 0.38.8 → 0.38.10

package/tests/index.test.ts

@@ -0,0 +1,56 @@
+import {describe, it, vi, expect} from "vitest";
+import {initializeCLI} from "../src/index";
+
+vi.mock("commander", () => ({
+  program: {
+    version: vi.fn().mockReturnThis(),
+    description: vi.fn().mockReturnThis(),
+    parse: vi.fn(),
+  },
+}));
+
+vi.mock("../src/commands/general", () => ({
+  initializeGeneralCommands: vi.fn(),
+}));
+
+vi.mock("../src/commands/account", () => ({
+  initializeAccountCommands: vi.fn(),
+}));
+
+vi.mock("../src/commands/contracts", () => ({
+  initializeContractsCommands: vi.fn(),
+}));
+
+vi.mock("../src/commands/config", () => ({
+  initializeConfigCommands: vi.fn(),
+}));
+
+vi.mock("../src/commands/localnet", () => ({
+  initializeValidatorCommands: vi.fn(),
+}));
+
+vi.mock("../src/commands/update", () => ({
+  initializeUpdateCommands: vi.fn(),
+}));
+
+vi.mock("../src/commands/scaffold", () => ({
+  initializeScaffoldCommands: vi.fn(),
+}));
+
+vi.mock("../src/commands/network", () => ({
+  initializeNetworkCommands: vi.fn(),
+}));
+
+vi.mock("../src/commands/transactions", () => ({
+  initializeTransactionsCommands: vi.fn(),
+}));
+
+vi.mock("../src/commands/staking", () => ({
+  initializeStakingCommands: vi.fn(),
+}));
+
+describe("CLI", () => {
+  it("should initialize CLI", () => {
+    expect(initializeCLI).not.toThrow();
+  });
+});

package/tests/libs/baseAction.test.ts

@@ -0,0 +1,535 @@
+import {describe, test, vi, beforeEach, afterEach, expect, Mock} from "vitest";
+import {BaseAction} from "../../src/lib/actions/BaseAction";
+import inquirer from "inquirer";
+import ora, {Ora} from "ora";
+import chalk from "chalk";
+import {inspect} from "util";
+import { ethers } from "ethers";
+import { writeFileSync, existsSync, readFileSync } from "fs";
+import fs from "fs";
+import os from "os";
+import { createAccount } from "genlayer-js";
+
+vi.mock("inquirer");
+vi.mock("ora");
+vi.mock("fs");
+vi.mock("os");
+vi.mock("ethers");
+vi.mock("genlayer-js", () => ({
+  createAccount: vi.fn(),
+  createClient: vi.fn(),
+  localnet: {}
+}));
+
+describe("BaseAction", () => {
+  let baseAction: BaseAction;
+  let mockSpinner: Ora;
+  let consoleSpy: any;
+  let consoleErrorSpy: any;
+  let processExitSpy: any;
+
+  // Standard web3 keystore format
+  const mockKeystoreData = {
+    address: "1234567890123456789012345678901234567890",
+    crypto: {
+      cipher: "aes-128-ctr",
+      ciphertext: "test",
+      cipherparams: {iv: "test"},
+      kdf: "scrypt",
+      kdfparams: {},
+      mac: "test"
+    },
+    version: 3
+  };
+
+  const mockWallet = {
+    privateKey: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+    address: "0x1234567890123456789012345678901234567890",
+    encrypt: vi.fn().mockResolvedValue('{"address":"test","crypto":{"cipher":"aes-128-ctr"}}'),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process exited");
+    });
+    mockSpinner = {
+      start: vi.fn(),
+      stop: vi.fn(),
+      succeed: vi.fn(),
+      fail: vi.fn(),
+      text: "",
+    } as unknown as Ora;
+
+    (ora as unknown as Mock).mockReturnValue(mockSpinner);
+    
+    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    vi.mocked(os.tmpdir).mockReturnValue("/mocked/tmp");
+    
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify(mockKeystoreData));
+    vi.mocked(writeFileSync).mockImplementation(() => {});
+    vi.mocked(fs.readdirSync).mockReturnValue([] as any);
+    vi.mocked(fs.mkdirSync).mockImplementation(() => "/mocked/path");
+
+    // Mock ethers
+    vi.mocked(ethers.Wallet.createRandom).mockReturnValue(mockWallet as any);
+    vi.mocked(ethers.Wallet.fromEncryptedJson).mockResolvedValue(mockWallet as any);
+
+    vi.mocked(createAccount).mockReturnValue({
+      privateKey: mockWallet.privateKey,
+      address: mockWallet.address
+    } as any);
+
+    baseAction = new BaseAction();
+
+    // Mock config methods
+    vi.spyOn(baseAction as any, "getConfigByKey").mockReturnValue("./test-keypair.json");
+    vi.spyOn(baseAction as any, "getFilePath").mockImplementation(() => "./test-keypair.json");
+    vi.spyOn(baseAction as any, "writeConfig").mockImplementation(() => {});
+    vi.spyOn(baseAction as any, "getConfig").mockReturnValue({activeAccount: "default"});
+    vi.spyOn(baseAction as any, "resolveAccountName").mockReturnValue("default");
+    vi.spyOn(baseAction as any, "getKeystorePath").mockReturnValue("/mocked/home/.genlayer/keystores/default.json");
+    vi.spyOn(baseAction as any, "getActiveAccount").mockReturnValue("default");
+
+    // Mock keychainManager methods
+    vi.spyOn(baseAction["keychainManager"], "isKeychainAvailable").mockResolvedValue(false);
+    vi.spyOn(baseAction["keychainManager"], "getPrivateKey").mockResolvedValue(null);
+    vi.spyOn(baseAction["keychainManager"], "storePrivateKey").mockResolvedValue();
+    vi.spyOn(baseAction["keychainManager"], "removePrivateKey").mockResolvedValue(true);
+
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("should start the spinner with a message", () => {
+    baseAction["startSpinner"]("Loading...");
+    expect(mockSpinner.start).toHaveBeenCalled();
+    expect(mockSpinner.text).toBe(chalk.blue("Loading..."));
+  });
+
+  test("should succeed the spinner with a message", () => {
+    baseAction["succeedSpinner"]("Success");
+    expect(consoleSpy).toHaveBeenCalledWith("");
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(expect.stringContaining("Success"));
+  });
+
+  test("should fail the spinner with an error message", () => {
+    const error = new Error("Something went wrong");
+    baseAction["failSpinner"]("Failure", error, false); // Don't exit for test
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Error:"));
+    expect(consoleSpy).toHaveBeenCalledWith(inspect(error, {depth: null, colors: false}));
+    expect(consoleSpy).toHaveBeenCalledWith("");
+    expect(mockSpinner.fail).toHaveBeenCalledWith(expect.stringContaining("Failure"));
+  });
+
+  test("should fail the spinner and exit by default", () => {
+    const error = new Error("Fatal error");
+    expect(() => baseAction["failSpinner"]("Fatal", error)).toThrow("process exited");
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test("should stop the spinner", () => {
+    baseAction["stopSpinner"]();
+    expect(mockSpinner.stop).toHaveBeenCalled();
+  });
+
+  test("should set spinner text", () => {
+    baseAction["setSpinnerText"]("Updated text");
+    expect(mockSpinner.text).toBe(chalk.blue("Updated text"));
+  });
+
+  test("should confirm prompt and proceed when confirmed", async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: true});
+
+    await expect(baseAction["confirmPrompt"]("Are you sure?")).resolves.not.toThrow();
+    expect(inquirer.prompt).toHaveBeenCalled();
+  });
+
+  test("should confirm prompt and exit when declined", async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: false});
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process exited");
+    });
+
+    await expect(baseAction["confirmPrompt"]("Are you sure?")).rejects.toThrow("process exited");
+    expect(inquirer.prompt).toHaveBeenCalled();
+    expect(processExitSpy).toHaveBeenCalledWith(0);
+  });
+
+  test("should log a success message", () => {
+    baseAction["logSuccess"]("Success message");
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("✔ Success message"));
+  });
+
+  test("should log an error message", () => {
+    baseAction["logError"]("Error message");
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("✖ Error message"));
+  });
+
+  test("should log a info message", () => {
+    baseAction["logInfo"]("Info message");
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("ℹ Info message"));
+  });
+
+  test("should log a warning message", () => {
+    baseAction["logWarning"]("Warning message");
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("⚠ Warning message"));
+  });
+
+  test("should log a success message with data", () => {
+    const data = {key: "value"};
+
+    baseAction["logSuccess"]("Success message", data);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("✔ Success message"));
+    expect(consoleSpy).toHaveBeenCalledWith(chalk.green(inspect(data, {depth: null, colors: false})));
+  });
+
+  test("should log an error message with error details", () => {
+    const error = new Error("Something went wrong");
+
+    baseAction["logError"]("Error message", error);
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("✖ Error message"));
+    expect(consoleErrorSpy).toHaveBeenCalledWith(chalk.red(inspect(error, {depth: null, colors: false})));
+  });
+
+  test("should log an info message with data", () => {
+    const data = {info: "This is some info"};
+
+    baseAction["logInfo"]("Info message", data);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("ℹ Info message"));
+    expect(consoleSpy).toHaveBeenCalledWith(chalk.blue(inspect(data, {depth: null, colors: false})));
+  });
+
+  test("should log a warning message with data", () => {
+    const data = {warning: "This is a warning"};
+
+    baseAction["logWarning"]("Warning message", data);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("⚠ Warning message"));
+    expect(consoleSpy).toHaveBeenCalledWith(chalk.yellow(inspect(data, {depth: null, colors: false})));
+  });
+
+  test("should succeed the spinner with a message and log result if data is provided", () => {
+    const mockData = {key: "value"};
+
+    baseAction["succeedSpinner"]("Success", mockData);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Result:"));
+    expect(consoleSpy).toHaveBeenCalledWith(inspect(mockData, {depth: null, colors: false}));
+    expect(consoleSpy).toHaveBeenCalledWith("");
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(expect.stringContaining("Success"));
+  });
+
+  test("should return a string representation of a primitive", () => {
+    expect((baseAction as any).formatOutput("Hello")).toBe("Hello");
+    expect((baseAction as any).formatOutput(42)).toBe("42");
+    expect((baseAction as any).formatOutput(true)).toBe("true");
+  });
+
+  test("should prompt for password successfully", async () => {
+    const mockPassword = "test-password";
+    vi.mocked(inquirer.prompt).mockResolvedValue({password: mockPassword});
+
+    const result = await baseAction["promptPassword"]("Enter password:");
+    
+    expect(result).toBe(mockPassword);
+    expect(inquirer.prompt).toHaveBeenCalledWith([{
+      type: "password",
+      name: "password",
+      message: chalk.yellow("Enter password:"),
+      mask: "*",
+      validate: expect.any(Function),
+    }]);
+  });
+
+  test("should validate password input is not empty", async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValue({password: "valid-password"});
+
+    await baseAction["promptPassword"]("Enter password:");
+    
+    const mockCall = vi.mocked(inquirer.prompt).mock.calls[0];
+    const questions = mockCall[0] as any;
+    const validateFn = questions[0].validate;
+    expect(validateFn("")).toBe("Password cannot be empty");
+    expect(validateFn("valid")).toBe(true);
+  });
+
+  test("should return private key when keystore exists and is valid", async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValue({password: "correct-password"});
+
+    const account = await baseAction["getAccount"](false);
+
+    expect((account as any).privateKey).toBe(mockWallet.privateKey);
+    expect(existsSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json");
+    expect(readFileSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json", "utf-8");
+  });
+
+  test("should return address when called with readOnly=true", async () => {
+    const address = await baseAction["getAccount"](true);
+
+    expect(address).toBe(`0x${mockKeystoreData.address}`);
+    expect(existsSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json");
+    expect(readFileSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json", "utf-8");
+  });
+
+  test("should return 0x-prefixed address for readOnly even when keystore has no prefix", async () => {
+    const address = await baseAction["getAccount"](true);
+
+    expect(address).toMatch(/^0x/);
+    expect(address).toBe(`0x${mockKeystoreData.address}`);
+  });
+
+  test("should not double-prefix address that already has 0x", async () => {
+    const prefixedKeystoreData = {
+      ...mockKeystoreData,
+      address: "0x1234567890123456789012345678901234567890",
+    };
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify(prefixedKeystoreData));
+
+    const address = await baseAction["getAccount"](true);
+
+    expect(address).toBe("0x1234567890123456789012345678901234567890");
+  });
+
+  test("should create new keypair when keystore file does not exist", async () => {
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({confirmAction: true}) // confirm create new
+      .mockResolvedValueOnce({password: "new-password"}) // encrypt password
+      .mockResolvedValueOnce({password: "new-password"}); // confirm password
+
+    const account = await baseAction["getAccount"](false);
+
+    expect((account as any).privateKey).toBe(mockWallet.privateKey);
+    expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
+      expect.objectContaining({message: chalk.yellow("Account 'default' not found. Would you like to create it?")})
+    ]));
+  });
+
+  test("should fail when keystore format is invalid and user declines", async () => {
+    vi.mocked(readFileSync).mockReturnValue('{"invalid": "format"}');
+    vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: false});
+
+    await expect(baseAction["getAccount"](false)).rejects.toThrow("process exited");
+    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Invalid keystore format. Expected encrypted keystore file."));
+  });
+
+  test("should use cached key when available", async () => {
+    vi.spyOn(baseAction["keychainManager"], "isKeychainAvailable").mockResolvedValue(true);
+    vi.spyOn(baseAction["keychainManager"], "getPrivateKey").mockResolvedValue(mockWallet.privateKey);
+
+    const account = await baseAction["getAccount"](false);
+
+    expect((account as any).privateKey).toBe(mockWallet.privateKey);
+    expect(baseAction["keychainManager"].getPrivateKey).toHaveBeenCalledWith("default");
+    expect(inquirer.prompt).not.toHaveBeenCalled();
+  });
+
+  test("should create new keypair when keystore format is invalid and user confirms", async () => {
+    vi.mocked(readFileSync).mockReturnValue('{"invalid": "format"}');
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({confirmAction: true})
+      .mockResolvedValueOnce({password: "new-password"})
+      .mockResolvedValueOnce({password: "new-password"});
+
+    const account = await baseAction["getAccount"](false);
+
+    expect((account as any).privateKey).toBe(mockWallet.privateKey);
+    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Invalid keystore format. Expected encrypted keystore file."));
+    expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
+      expect.objectContaining({message: "Would you like to recreate account 'default'?"})
+    ]));
+  });
+
+  test("should decrypt keystore successfully on first attempt", async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValue({password: "correct-password"});
+
+    const result = await baseAction["decryptKeystore"](JSON.stringify(mockKeystoreData));
+
+    expect(result).toBe(mockWallet.privateKey);
+    expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
+      expect.objectContaining({message: chalk.yellow("Enter password to decrypt keystore:")})
+    ]));
+  });
+
+  test("should retry on wrong password and succeed on second attempt", async () => {
+    vi.mocked(ethers.Wallet.fromEncryptedJson)
+      .mockRejectedValueOnce(new Error("Incorrect password"))
+      .mockResolvedValueOnce(mockWallet as any);
+
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({password: "wrong-password"})
+      .mockResolvedValueOnce({password: "correct-password"});
+
+    const result = await baseAction["decryptKeystore"](JSON.stringify(mockKeystoreData));
+
+    expect(result).toBe(mockWallet.privateKey);
+    expect(inquirer.prompt).toHaveBeenCalledTimes(2);
+    expect(inquirer.prompt).toHaveBeenNthCalledWith(2, expect.arrayContaining([
+      expect.objectContaining({message: chalk.yellow("Invalid password. Attempt 2/3 - Enter password to decrypt keystore:")})
+    ]));
+  });
+
+  test("should exit after 3 failed password attempts", async () => {
+    vi.mocked(ethers.Wallet.fromEncryptedJson).mockRejectedValue(new Error("Incorrect password"));
+    vi.mocked(inquirer.prompt).mockResolvedValue({password: "wrong-password"});
+
+    await expect(baseAction["decryptKeystore"](JSON.stringify(mockKeystoreData))).rejects.toThrow("process exited");
+
+    expect(inquirer.prompt).toHaveBeenCalledTimes(3);
+    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Maximum password attempts exceeded (3/3)."));
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test("should create new keypair successfully", async () => {
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({password: "test-password"})
+      .mockResolvedValueOnce({password: "test-password"});
+
+    const result = await baseAction["createKeypairByName"]("test-account", false);
+
+    expect(result).toBe(mockWallet.privateKey);
+    expect(ethers.Wallet.createRandom).toHaveBeenCalled();
+    expect(mockWallet.encrypt).toHaveBeenCalledWith("test-password");
+    expect(writeFileSync).toHaveBeenCalled();
+    expect(baseAction["keychainManager"].removePrivateKey).toHaveBeenCalledWith("test-account");
+  });
+
+  test("should fail when account exists and overwrite is false", async () => {
+    vi.mocked(existsSync).mockReturnValue(true);
+
+    await expect(baseAction["createKeypairByName"]("test-account", false)).rejects.toThrow("process exited");
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(
+      chalk.red("Account 'test-account' already exists. Use '--overwrite' to replace it.")
+    );
+  });
+
+  test("should fail when passwords do not match", async () => {
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({password: "password1"})
+      .mockResolvedValueOnce({password: "password2"});
+
+    await expect(baseAction["createKeypairByName"]("test-account", false)).rejects.toThrow("process exited");
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Passwords do not match"));
+  });
+
+  test("should fail when password is too short", async () => {
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({password: "short"})
+      .mockResolvedValueOnce({password: "short"});
+
+    await expect(baseAction["createKeypairByName"]("test-account", false)).rejects.toThrow("process exited");
+
+    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Password must be at least 8 characters long"));
+  });
+
+  test("should overwrite existing account when overwrite is true", async () => {
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(inquirer.prompt)
+      .mockResolvedValueOnce({password: "test-password"})
+      .mockResolvedValueOnce({password: "test-password"});
+
+    const result = await baseAction["createKeypairByName"]("test-account", true);
+
+    expect(result).toBe(mockWallet.privateKey);
+    expect(writeFileSync).toHaveBeenCalled();
+    expect(baseAction["keychainManager"].removePrivateKey).toHaveBeenCalledWith("test-account");
+  });
+
+  test("should return true for valid keystore format", () => {
+    // Standard web3 keystore format
+    const validKeystore = {
+      address: "1234567890123456789012345678901234567890",
+      crypto: {cipher: "aes-128-ctr", ciphertext: "test"},
+      version: 3,
+    };
+
+    const result = baseAction["isValidKeystoreFormat"](validKeystore);
+    expect(result).toBe(true);
+  });
+
+  test("should return true for keystore with uppercase Crypto field", () => {
+    // Some tools use uppercase 'Crypto'
+    const validKeystore = {
+      address: "1234567890123456789012345678901234567890",
+      Crypto: {cipher: "aes-128-ctr", ciphertext: "test"},
+      version: 3,
+    };
+
+    const result = baseAction["isValidKeystoreFormat"](validKeystore);
+    expect(result).toBe(true);
+  });
+
+  test("should return false for keystore missing crypto field", () => {
+    const invalidKeystore = {
+      address: "1234567890123456789012345678901234567890",
+      version: 3,
+    };
+
+    const result = baseAction["isValidKeystoreFormat"](invalidKeystore);
+    expect(result).toBe(false);
+  });
+
+  test("should return false for keystore missing address", () => {
+    const invalidKeystore = {
+      crypto: {cipher: "aes-128-ctr"},
+      version: 3,
+    };
+
+    const result = baseAction["isValidKeystoreFormat"](invalidKeystore);
+    expect(result).toBe(false);
+  });
+
+  test("should return false for null or undefined keystore", () => {
+    expect(baseAction["isValidKeystoreFormat"](null)).toBe(false);
+    expect(baseAction["isValidKeystoreFormat"](undefined)).toBe(false);
+  });
+
+  describe("formatOutput", () => {
+    test("should return string as is", () => {
+      expect((baseAction as any).formatOutput("Hello")).toBe("Hello");
+    });
+
+    test("should format an object", () => {
+      const data = {key: "value", num: 42};
+      const result = (baseAction as any).formatOutput(data);
+      expect(result).toBe("{ key: 'value', num: 42 }");
+    });
+
+    test("should format an error object", () => {
+      const error = new Error("Test Error");
+      const result = (baseAction as any).formatOutput(error);
+      expect(result).toContain("Error: Test Error");
+    });
+
+    test("should format a Map object", () => {
+      const testMap = new Map([["key1", "value1"]]);
+      const result = (baseAction as any).formatOutput(testMap);
+      expect(result).toBe("Map(1) { 'key1' => 'value1' }");
+    });
+
+    test("should format a BigInt object", () => {
+      const bigIntValue = BigInt(9007199254740991);
+      const result = (baseAction as any).formatOutput(bigIntValue);
+      expect(result).toBe("9007199254740991n");
+    });
+  });
+});