genlayer 0.38.8 → 0.38.10

package/tests/commands/init.test.ts

@@ -0,0 +1,101 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeGeneralCommands } from "../../src/commands/general";
+import { getCommand, getCommandOption } from "../utils";
+import simulatorService from  '../../src/lib/services/simulator'
+import {localnetCompatibleVersion} from "../../src/lib/config/simulator";
+import { InitAction } from "../../src/commands/general/init";
+
+
+vi.mock("../../src/commands/general/init");
+
+
+const openFrontendSpy = vi.spyOn(simulatorService, "openFrontend");
+const defaultOptions = {
+  numValidators: "5",
+  headless: false,
+  resetDb: false,
+  localnetVersion: localnetCompatibleVersion,
+  ollama: false,
+}
+
+vi.mock("inquirer", () => ({
+  prompt: vi.fn(() => {}),
+}));
+
+describe("init command", () => {
+  let initCommand: Command;
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeGeneralCommands(program);
+
+    initCommand = getCommand(program, "init");
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("doesn't have required arguments nor options", async () => {
+    expect(() => program.parse(["node", "test", "init"])).not.toThrow();
+  });
+
+  test("option --numValidators is accepted", async () => {
+    expect(() => program.parse(["node", "test", "init", "--numValidators", "10"])).not.toThrow();
+  });
+
+  test("option --numValidators default value is 5", async () => {
+    const numValidatorsOption = getCommandOption(initCommand, "--numValidators");
+    expect(numValidatorsOption?.defaultValue).toBe("5");
+  });
+
+
+  test("random option is not accepted", async () => {
+    initCommand?.exitOverride();
+    expect(() => program.parse(["node", "test", "init", "-random"])).toThrowError(
+      "error: unknown option '-random'"
+    );
+    expect(() => program.parse(["node", "test", "init", "--randomOption"])).toThrowError(
+      "error: unknown option '--randomOption'"
+    );
+  });
+
+  test("action is called", async () => {
+    program.parse(["node", "test", "init"]);
+    expect(InitAction).toHaveBeenCalledTimes(1);
+    expect(InitAction.prototype.execute).toHaveBeenCalledWith(defaultOptions);
+  });
+
+  test("option --headless is accepted", async () => {
+    program.parse(["node", "test", "init", "--headless"]);
+    expect(InitAction).toHaveBeenCalledTimes(1);
+    expect(InitAction.prototype.execute).toHaveBeenCalledWith({...defaultOptions, headless: true});
+    expect(openFrontendSpy).not.toHaveBeenCalled();
+  });
+
+  test("option --localnet-version is accepted", async () => {
+    program.parse(["node", "test", "init", "--localnet-version", "v1.0.0"]);
+    expect(InitAction).toHaveBeenCalledTimes(1);
+    expect(InitAction.prototype.execute).toHaveBeenCalledWith({...defaultOptions, localnetVersion: "v1.0.0"});
+    expect(openFrontendSpy).not.toHaveBeenCalled();
+  });
+
+  test("option --localnet-version description includes minimum version", async () => {
+    const localnetVersionOption = getCommandOption(initCommand, "--localnet-version");
+    expect(localnetVersionOption?.description).toBe(`Select a specific localnet version (minimum: ${localnetCompatibleVersion})`);
+  });
+
+  test("option --localnet-version default value is compatible version", async () => {
+    const localnetVersionOption = getCommandOption(initCommand, "--localnet-version");
+    expect(localnetVersionOption?.defaultValue).toBe(localnetCompatibleVersion);
+  });
+
+  test("option --ollama is accepted", async () => {
+    program.parse(["node", "test", "init", "--ollama"]);
+    expect(InitAction).toHaveBeenCalledTimes(1);
+    expect(InitAction.prototype.execute).toHaveBeenCalledWith({...defaultOptions, ollama: true});
+  });
+});

package/tests/commands/localnet.test.ts

@@ -0,0 +1,131 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeValidatorCommands } from "../../src/commands/localnet";
+import { ValidatorsAction } from "../../src/commands/localnet/validators";
+
+vi.mock("../../src/commands/localnet/validators");
+
+describe("localnet validator command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeValidatorCommands(program);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("ValidatorsAction.getValidator is called with address option", async () => {
+    program.parse(["node", "test", "localnet", "validators", "get", "--address", "mocked_address"]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.getValidator).toHaveBeenCalledWith({
+      address: "mocked_address",
+    });
+  });
+
+  test("ValidatorsAction.getValidator is called without address option", async () => {
+    program.parse(["node", "test", "localnet", "validators", "get"]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.getValidator).toHaveBeenCalledWith({});
+  });
+
+  test("ValidatorsAction.deleteValidator is called with address option", async () => {
+    program.parse(["node", "test", "localnet", "validators", "delete", "--address", "mocked_address"]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.deleteValidator).toHaveBeenCalledWith({
+      address: "mocked_address",
+    });
+  });
+
+  test("ValidatorsAction.deleteValidator is called without address option", async () => {
+    program.parse(["node", "test", "localnet", "validators", "delete"]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.deleteValidator).toHaveBeenCalledWith({});
+  });
+
+  test("ValidatorsAction.countValidators is called", async () => {
+    program.parse(["node", "test", "localnet", "validators", "count"]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.countValidators).toHaveBeenCalled();
+  });
+
+  test("ValidatorsAction.updateValidator is called with all options", async () => {
+    program.parse([
+      "node",
+      "test",
+      "localnet",
+      "validators",
+      "update",
+      "mocked_address",
+      "--stake",
+      "10",
+      "--provider",
+      "mocked_provider",
+      "--model",
+      "mocked_model",
+      '--config',
+      '{"max_tokens":500}',
+    ]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.updateValidator).toHaveBeenCalledWith({
+      address: "mocked_address",
+      stake: "10",
+      provider: "mocked_provider",
+      model: "mocked_model",
+      config: '{"max_tokens":500}',
+    });
+  });
+
+  test("ValidatorsAction.createRandomValidators is called with count and providers", async () => {
+    program.parse([
+      "node",
+      "test",
+      "localnet",
+      "validators",
+      "create-random",
+      "--count",
+      "3",
+      "--providers",
+      "provider1",
+      "provider2",
+    ]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.createRandomValidators).toHaveBeenCalledWith({
+      count: "3",
+      providers: ["provider1", "provider2"],
+      models: []
+    });
+  });
+
+  test("ValidatorsAction.createValidator is called with default stake", async () => {
+    program.parse(["node", "test", "localnet", "validators", "create"]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.createValidator).toHaveBeenCalledWith({
+      stake: "1",
+      config: undefined,
+    });
+  });
+
+  test("ValidatorsAction.createValidator is called with stake and config", async () => {
+    program.parse([
+      "node",
+      "test",
+      "localnet",
+      "validators",
+      "create",
+      "--stake",
+      "5",
+      '--config',
+      '{"temperature":0.8}',
+    ]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.createValidator).toHaveBeenCalledWith({
+      stake: "5",
+      config: '{"temperature":0.8}',
+    });
+  });
+});
+
+

package/tests/commands/network.test.ts

@@ -0,0 +1,60 @@
+import {Command} from "commander";
+import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
+import {initializeNetworkCommands} from "../../src/commands/network";
+import {NetworkActions} from "../../src/commands/network/setNetwork";
+
+vi.mock("../../src/commands/network/setNetwork");
+
+describe("network commands", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeNetworkCommands(program);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("NetworkActions.setNetwork is called with the correct network name", async () => {
+    program.parse(["node", "test", "network", "set", "localnet"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+    expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("localnet");
+  });
+
+  test("NetworkActions.setNetwork is called with testnet-asimov", async () => {
+    program.parse(["node", "test", "network", "set", "testnet-asimov"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+    expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("testnet-asimov");
+  });
+
+  test("NetworkActions.setNetwork is called with studionet", async () => {
+    program.parse(["node", "test", "network", "set", "studionet"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+    expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("studionet");
+  });
+
+  test("NetworkActions.setNetwork is called without a network name", async () => {
+    program.parse(["node", "test", "network", "set"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+    expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith(undefined);
+  });
+
+  test("NetworkActions is instantiated when the command is executed", async () => {
+    program.parse(["node", "test", "network", "set", "localnet"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+  });
+
+  test("NetworkActions.setNetwork is called without throwing errors for valid network", async () => {
+    program.parse(["node", "test", "network", "set", "localnet"]);
+    vi.mocked(NetworkActions.prototype.setNetwork).mockResolvedValue();
+    expect(() => program.parse(["node", "test", "network", "set", "localnet"])).not.toThrow();
+  });
+
+  test("NetworkActions.showInfo is called for network info", async () => {
+    program.parse(["node", "test", "network", "info"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+    expect(NetworkActions.prototype.showInfo).toHaveBeenCalled();
+  });
+});

package/tests/commands/new.test.ts

@@ -0,0 +1,68 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeScaffoldCommands } from "../../src/commands/scaffold";
+import { NewAction } from "../../src/commands/scaffold/new";
+
+vi.mock("../../src/commands/scaffold/new");
+
+describe("new command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeScaffoldCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("NewAction.createProject is called with default options", async () => {
+    program.parse(["node", "test", "new", "myProject"]);
+    expect(NewAction).toHaveBeenCalledTimes(1);
+    expect(NewAction.prototype.createProject).toHaveBeenCalledWith("myProject", {
+      path: ".",
+      overwrite: false,
+    });
+  });
+
+  test("NewAction.createProject is called with custom path", async () => {
+    program.parse(["node", "test", "new", "myProject", "--path", "./customDir"]);
+    expect(NewAction).toHaveBeenCalledTimes(1);
+    expect(NewAction.prototype.createProject).toHaveBeenCalledWith("myProject", {
+      path: "./customDir",
+      overwrite: false,
+    });
+  });
+
+  test("NewAction.createProject is called with overwrite flag", async () => {
+    program.parse(["node", "test", "new", "myProject", "--overwrite"]);
+    expect(NewAction).toHaveBeenCalledTimes(1);
+    expect(NewAction.prototype.createProject).toHaveBeenCalledWith("myProject", {
+      path: ".",
+      overwrite: true,
+    });
+  });
+
+  test("NewAction is instantiated when the new command is executed", async () => {
+    program.parse(["node", "test", "new", "myProject"]);
+    expect(NewAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const newCommand = program.commands.find((cmd) => cmd.name() === "new");
+    newCommand?.exitOverride();
+    expect(() => program.parse(["node", "test", "new", "myProject", "--unknown"])).toThrowError(
+      "error: unknown option '--unknown'"
+    );
+  });
+
+  test("NewAction.createProject is called without throwing errors for valid options", async () => {
+    program.parse(["node", "test", "new", "myProject"]);
+    vi.mocked(NewAction.prototype.createProject).mockResolvedValueOnce(undefined);
+    expect(() =>
+      program.parse(["node", "test", "new", "myProject"])
+    ).not.toThrow();
+  });
+});

package/tests/commands/parseArg.test.ts

@@ -0,0 +1,156 @@
+import {vi, describe, test, expect} from "vitest";
+import {CalldataAddress} from "genlayer-js/types";
+import {parseArg, parseScalar, coerceValue} from "../../src/commands/contracts";
+
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
+
+describe("parseScalar", () => {
+  test("parses booleans", () => {
+    expect(parseScalar("true")).toBe(true);
+    expect(parseScalar("false")).toBe(false);
+  });
+
+  test("parses null", () => {
+    expect(parseScalar("null")).toBeNull();
+  });
+
+  test("parses small integers as Number", () => {
+    expect(parseScalar("42")).toBe(42);
+    expect(parseScalar("0")).toBe(0);
+    expect(parseScalar("-1")).toBe(-1);
+  });
+
+  test("parses 0x address as CalldataAddress", () => {
+    const result = parseScalar("0x6857Ed54CbafaA74Fc0357145eC0ee1536ca45A0");
+    expect(result).toBeInstanceOf(CalldataAddress);
+    const addr = result as CalldataAddress;
+    expect(addr.bytes).toHaveLength(20);
+    expect(addr.bytes[0]).toBe(0x68);
+    expect(addr.bytes[19]).toBe(0xa0);
+  });
+
+  test("parses addr# prefix as CalldataAddress", () => {
+    const result = parseScalar("addr#6857Ed54CbafaA74Fc0357145eC0ee1536ca45A0");
+    expect(result).toBeInstanceOf(CalldataAddress);
+    const addr = result as CalldataAddress;
+    expect(addr.bytes).toHaveLength(20);
+    expect(addr.bytes[0]).toBe(0x68);
+  });
+
+  test("parses b# prefix as Uint8Array", () => {
+    const result = parseScalar("b#deadbeef");
+    expect(result).toBeInstanceOf(Uint8Array);
+    const bytes = result as Uint8Array;
+    expect(bytes).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
+  });
+
+  test("parses empty b# as empty Uint8Array", () => {
+    const result = parseScalar("b#");
+    expect(result).toBeInstanceOf(Uint8Array);
+    expect(result).toEqual(new Uint8Array([]));
+  });
+
+  test("parses non-address hex as BigInt", () => {
+    expect(parseScalar("0x1234")).toBe(BigInt("0x1234"));
+  });
+
+  test("parses large decimal as BigInt", () => {
+    const big = "99999999999999999999";
+    expect(parseScalar(big)).toBe(BigInt(big));
+  });
+
+  test("parses plain strings", () => {
+    expect(parseScalar("hello")).toBe("hello");
+    expect(parseScalar("someString")).toBe("someString");
+  });
+
+  test("does not treat invalid hex as address", () => {
+    const invalid = "0xZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ";
+    expect(parseScalar(invalid)).toBe(invalid);
+  });
+});
+
+describe("coerceValue", () => {
+  test("coerces null", () => {
+    expect(coerceValue(null)).toBeNull();
+  });
+
+  test("coerces booleans", () => {
+    expect(coerceValue(true)).toBe(true);
+    expect(coerceValue(false)).toBe(false);
+  });
+
+  test("coerces safe integers", () => {
+    expect(coerceValue(42)).toBe(42);
+  });
+
+  test("coerces arrays recursively", () => {
+    expect(coerceValue([1, "hello", null])).toEqual([1, "hello", null]);
+  });
+
+  test("coerces objects recursively", () => {
+    expect(coerceValue({key: "value", n: 42})).toEqual({key: "value", n: 42});
+  });
+
+  test("coerces address strings inside objects", () => {
+    const result = coerceValue({recipient: "0x6857Ed54CbafaA74Fc0357145eC0ee1536ca45A0"}) as any;
+    expect(result.recipient).toBeInstanceOf(CalldataAddress);
+  });
+
+  test("coerces address strings inside arrays", () => {
+    const result = coerceValue(["0x6857Ed54CbafaA74Fc0357145eC0ee1536ca45A0"]) as any[];
+    expect(result[0]).toBeInstanceOf(CalldataAddress);
+  });
+});
+
+describe("parseArg", () => {
+  test("parses scalars", () => {
+    expect(parseArg("42")).toEqual([42]);
+    expect(parseArg("true")).toEqual([true]);
+    expect(parseArg("hello")).toEqual(["hello"]);
+  });
+
+  test("parses null", () => {
+    expect(parseArg("null")).toEqual([null]);
+  });
+
+  test("parses JSON array", () => {
+    const result = parseArg('[1, 2, "three"]');
+    expect(result).toEqual([[1, 2, "three"]]);
+  });
+
+  test("parses JSON object", () => {
+    const result = parseArg('{"key": "value", "n": 42}');
+    expect(result).toEqual([{key: "value", n: 42}]);
+  });
+
+  test("parses nested JSON with address strings", () => {
+    const result = parseArg('{"to": "0x6857Ed54CbafaA74Fc0357145eC0ee1536ca45A0", "amount": 100}');
+    expect(result).toHaveLength(1);
+    const obj = result[0] as any;
+    expect(obj.to).toBeInstanceOf(CalldataAddress);
+    expect(obj.amount).toBe(100);
+  });
+
+  test("parses 0x address as CalldataAddress", () => {
+    const result = parseArg("0x6857Ed54CbafaA74Fc0357145eC0ee1536ca45A0");
+    expect(result).toHaveLength(1);
+    expect(result[0]).toBeInstanceOf(CalldataAddress);
+  });
+
+  test("accumulates with previous args", () => {
+    const result = parseArg("42", ["existing"]);
+    expect(result).toEqual(["existing", 42]);
+  });
+
+  test("treats invalid JSON as plain string", () => {
+    expect(parseArg("{not json}")).toEqual(["{not json}"]);
+  });
+
+  test("quoted string stays as string with quotes", () => {
+    // '"hello"' has literal quote chars — treated as a plain string, not JSON-unwrapped
+    expect(parseArg('"hello"')).toEqual(['"hello"']);
+  });
+});

package/tests/commands/receipt.test.ts

@@ -0,0 +1,142 @@
+import {Command} from "commander";
+import {ReceiptAction} from "../../src/commands/transactions/receipt";
+import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
+import {initializeTransactionsCommands} from "../../src/commands/transactions";
+
+vi.mock("../../src/commands/transactions/receipt");
+
+describe("receipt command", () => {
+  let program: Command;
+  const mockTxId = "0x1234567890123456789012345678901234567890123456789012345678901234";
+
+  beforeEach(() => {
+    program = new Command();
+    initializeTransactionsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("ReceiptAction.receipt is called with default options", async () => {
+    program.parse(["node", "test", "receipt", mockTxId]);
+    expect(ReceiptAction).toHaveBeenCalledTimes(1);
+    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
+      txId: mockTxId,
+      status: "FINALIZED",
+      retries: 100,
+      interval: 5000,
+    });
+  });
+
+  test("ReceiptAction.receipt is called with custom options", async () => {
+    program.parse([
+      "node",
+      "test",
+      "receipt",
+      mockTxId,
+      "--status",
+      "ACCEPTED",
+      "--retries",
+      "50",
+      "--interval",
+      "3000",
+      "--rpc",
+      "https://custom-rpc-url-for-receipt.com",
+    ]);
+    expect(ReceiptAction).toHaveBeenCalledTimes(1);
+    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
+      txId: mockTxId,
+      status: "ACCEPTED",
+      retries: 50,
+      interval: 3000,
+      rpc: "https://custom-rpc-url-for-receipt.com",
+    });
+  });
+
+  test("ReceiptAction is instantiated when the receipt command is executed", async () => {
+    program.parse(["node", "test", "receipt", mockTxId]);
+    expect(ReceiptAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const receiptCommand = program.commands.find(cmd => cmd.name() === "receipt");
+    receiptCommand?.exitOverride();
+    expect(() =>
+      program.parse(["node", "test", "receipt", mockTxId, "--invalid-option"]),
+    ).toThrowError("error: unknown option '--invalid-option'");
+  });
+
+  test("parses numeric options correctly", async () => {
+    program.parse([
+      "node",
+      "test",
+      "receipt",
+      mockTxId,
+      "--retries",
+      "25",
+      "--interval",
+      "1000",
+    ]);
+    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
+      txId: mockTxId,
+      status: "FINALIZED",
+      retries: 25,
+      interval: 1000,
+    });
+  });
+
+  test("uses fallback value for invalid numeric options", async () => {
+    program.parse([
+      "node",
+      "test",
+      "receipt", 
+      mockTxId,
+      "--retries",
+      "invalid",
+      "--interval", 
+      "notanumber",
+    ]);
+    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
+      txId: mockTxId,
+      status: "FINALIZED",
+      retries: 100,
+      interval: 5000,
+    });
+  });
+
+  test("parses --stdout flag", async () => {
+    program.parse(["node", "test", "receipt", mockTxId, "--stdout"]);
+    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
+      txId: mockTxId,
+      status: "FINALIZED",
+      retries: 100,
+      interval: 5000,
+      stdout: true,
+    });
+  });
+
+  test("parses --stderr flag", async () => {
+    program.parse(["node", "test", "receipt", mockTxId, "--stderr"]);
+    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
+      txId: mockTxId,
+      status: "FINALIZED",
+      retries: 100,
+      interval: 5000,
+      stderr: true,
+    });
+  });
+
+  test("parses both --stdout and --stderr flags", async () => {
+    program.parse(["node", "test", "receipt", mockTxId, "--stdout", "--stderr"]);
+    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
+      txId: mockTxId,
+      status: "FINALIZED",
+      retries: 100,
+      interval: 5000,
+      stdout: true,
+      stderr: true,
+    });
+  });
+});