genlayer 0.38.14 → 0.38.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.38.14",
+  "version": "0.38.16",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "type": "module",
@@ -67,7 +67,7 @@
     "dotenv": "^17.0.0",
     "ethers": "^6.13.4",
     "fs-extra": "^11.3.0",
-    "genlayer-js": "^0.27.9",
+    "genlayer-js": "^1.0.0",
     "inquirer": "^12.0.0",
     "keytar": "^7.9.0",
     "node-fetch": "^3.0.0",

package/src/commands/account/send.ts

@@ -31,18 +31,20 @@ export class SendAction extends BaseAction {
   }
 
   private parseAmount(amount: string): bigint {
-    // Support "10gen" or "10" (assumes gen) or wei values
-    const lowerAmount = amount.toLowerCase();
-    if (lowerAmount.endsWith("gen")) {
-      const value = lowerAmount.slice(0, -3);
-      return parseEther(value);
+    // Symmetric with genlayer-js `parseStakingAmount`:
+    //   "Ngen"  → N GEN (parseEther)
+    //   integer → wei (as-is)
+    //   decimal without suffix → rejected (ambiguous; was previously silently
+    //     interpreted as GEN for small values and as wei for large — a footgun
+    //     that made `send 1000` attempt to transfer 1000 GEN, not 1000 wei).
+    const trimmed = amount.trim();
+    const lower = trimmed.toLowerCase();
+    if (lower.endsWith("gen")) {
+      return parseEther(lower.slice(0, -3).trim());
     }
-    // If it's a large number (likely wei), use as-is
-    if (BigInt(amount) > 1_000_000_000_000n) {
-      return BigInt(amount);
-    }
-    // Otherwise assume it's in GEN
-    return parseEther(amount);
+    // Plain integer → wei. BigInt() throws on decimals, which is the intended
+    // failure mode for ambiguous input like "1.5".
+    return BigInt(trimmed);
   }
 
   async execute(options: SendOptions): Promise<void> {

package/src/commands/transactions/finalize.ts

@@ -0,0 +1,45 @@
+import {TransactionHash} from "genlayer-js/types";
+import {BaseAction} from "../../lib/actions/BaseAction";
+
+export interface FinalizeOptions {
+  rpc?: string;
+}
+
+export class FinalizeAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async finalize({txId, rpc}: {txId: TransactionHash; rpc?: string}): Promise<void> {
+    const client = await this.getClient(rpc);
+
+    this.startSpinner(`Finalizing transaction ${txId}...`);
+    try {
+      const evmHash = await client.finalizeTransaction({txId});
+      this.succeedSpinner("Transaction finalized", {txId, evmTransactionHash: evmHash});
+    } catch (error) {
+      this.failSpinner("Error finalizing transaction", error);
+    }
+  }
+
+  async finalizeBatch({txIds, rpc}: {txIds: TransactionHash[]; rpc?: string}): Promise<void> {
+    if (txIds.length === 0) {
+      this.failSpinner("At least one txId is required.");
+      return;
+    }
+
+    const client = await this.getClient(rpc);
+
+    this.startSpinner(`Finalizing ${txIds.length} idle transaction(s)...`);
+    try {
+      const evmHash = await client.finalizeIdlenessTxs({txIds});
+      this.succeedSpinner("Idle transactions finalized", {
+        count: txIds.length,
+        txIds,
+        evmTransactionHash: evmHash,
+      });
+    } catch (error) {
+      this.failSpinner("Error finalizing idle transactions", error);
+    }
+  }
+}

package/src/commands/transactions/index.ts

@@ -3,6 +3,7 @@ import {TransactionStatus, TransactionHash} from "genlayer-js/types";
 import {ReceiptAction, ReceiptOptions} from "./receipt";
 import {AppealAction, AppealOptions, AppealBondOptions} from "./appeal";
 import {TraceAction, TraceOptions} from "./trace";
+import {FinalizeAction, FinalizeOptions} from "./finalize";
 
 function parseIntOption(value: string, fallback: number): number {
   const parsed = parseInt(value, 10);
@@ -56,5 +57,23 @@ export function initializeTransactionsCommands(program: Command) {
       await traceAction.trace({txId, ...options});
     });
 
+  program
+    .command("finalize <txId>")
+    .description("Finalize a transaction that is ready to be finalized (public call)")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (txId: TransactionHash, options: FinalizeOptions) => {
+      const finalizeAction = new FinalizeAction();
+      await finalizeAction.finalize({txId, ...options});
+    });
+
+  program
+    .command("finalize-batch <txIds...>")
+    .description("Finalize a batch of idle transactions in a single call (public call)")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (txIds: TransactionHash[], options: FinalizeOptions) => {
+      const finalizeAction = new FinalizeAction();
+      await finalizeAction.finalizeBatch({txIds, ...options});
+    });
+
   return program;
 }

package/tests/actions/finalize.test.ts

@@ -0,0 +1,109 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import type {TransactionHash} from "genlayer-js/types";
+import {FinalizeAction} from "../../src/commands/transactions/finalize";
+
+vi.mock("genlayer-js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("genlayer-js")>();
+  return {
+    ...actual,
+    createClient: vi.fn(),
+    createAccount: vi.fn(),
+  };
+});
+
+describe("FinalizeAction", () => {
+  let finalizeAction: FinalizeAction;
+  const mockClient = {
+    finalizeTransaction: vi.fn(),
+    finalizeIdlenessTxs: vi.fn(),
+  };
+
+  const mockPrivateKey = "mocked_private_key";
+  const mockTxId = "0x1234567890123456789012345678901234567890123456789012345678901234" as TransactionHash;
+  const mockTxId2 = "0xabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd" as TransactionHash;
+  const mockEvmHash = "0xdeadbeef" as `0x${string}`;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(createClient).mockReturnValue(mockClient as any);
+    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
+    finalizeAction = new FinalizeAction();
+    vi.spyOn(finalizeAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+
+    vi.spyOn(finalizeAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(finalizeAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(finalizeAction as any, "failSpinner").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("finalize calls client.finalizeTransaction and reports the EVM hash", async () => {
+    vi.mocked(mockClient.finalizeTransaction).mockResolvedValue(mockEvmHash);
+
+    await finalizeAction.finalize({txId: mockTxId});
+
+    expect(mockClient.finalizeTransaction).toHaveBeenCalledWith({txId: mockTxId});
+    expect(finalizeAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Transaction finalized",
+      {txId: mockTxId, evmTransactionHash: mockEvmHash},
+    );
+  });
+
+  test("finalize surfaces underlying errors via failSpinner", async () => {
+    vi.mocked(mockClient.finalizeTransaction).mockRejectedValue(new Error("boom"));
+
+    await finalizeAction.finalize({txId: mockTxId});
+
+    expect(finalizeAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error finalizing transaction",
+      expect.any(Error),
+    );
+  });
+
+  test("finalize uses custom RPC URL when provided", async () => {
+    vi.mocked(mockClient.finalizeTransaction).mockResolvedValue(mockEvmHash);
+
+    await finalizeAction.finalize({txId: mockTxId, rpc: "https://custom.com"});
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({endpoint: "https://custom.com"}),
+    );
+  });
+
+  test("finalizeBatch calls client.finalizeIdlenessTxs with all ids", async () => {
+    vi.mocked(mockClient.finalizeIdlenessTxs).mockResolvedValue(mockEvmHash);
+
+    await finalizeAction.finalizeBatch({txIds: [mockTxId, mockTxId2]});
+
+    expect(mockClient.finalizeIdlenessTxs).toHaveBeenCalledWith({
+      txIds: [mockTxId, mockTxId2],
+    });
+    expect(finalizeAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Idle transactions finalized",
+      {count: 2, txIds: [mockTxId, mockTxId2], evmTransactionHash: mockEvmHash},
+    );
+  });
+
+  test("finalizeBatch rejects an empty list without calling the client", async () => {
+    await finalizeAction.finalizeBatch({txIds: []});
+
+    expect(mockClient.finalizeIdlenessTxs).not.toHaveBeenCalled();
+    expect(finalizeAction["failSpinner"]).toHaveBeenCalledWith(
+      "At least one txId is required.",
+    );
+  });
+
+  test("finalizeBatch surfaces underlying errors via failSpinner", async () => {
+    vi.mocked(mockClient.finalizeIdlenessTxs).mockRejectedValue(new Error("revert"));
+
+    await finalizeAction.finalizeBatch({txIds: [mockTxId]});
+
+    expect(finalizeAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error finalizing idle transactions",
+      expect.any(Error),
+    );
+  });
+});

package/tests/commands/finalize.test.ts

@@ -0,0 +1,83 @@
+import {Command} from "commander";
+import {FinalizeAction} from "../../src/commands/transactions/finalize";
+import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
+import {initializeTransactionsCommands} from "../../src/commands/transactions";
+
+vi.mock("../../src/commands/transactions/finalize");
+
+describe("finalize command", () => {
+  let program: Command;
+  const mockTxId = "0x1234567890123456789012345678901234567890123456789012345678901234";
+
+  beforeEach(() => {
+    program = new Command();
+    initializeTransactionsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("FinalizeAction.finalize is called with txId", async () => {
+    program.parse(["node", "test", "finalize", mockTxId]);
+    expect(FinalizeAction).toHaveBeenCalledTimes(1);
+    expect(FinalizeAction.prototype.finalize).toHaveBeenCalledWith({txId: mockTxId});
+  });
+
+  test("FinalizeAction.finalize is called with custom RPC URL", async () => {
+    program.parse(["node", "test", "finalize", mockTxId, "--rpc", "https://custom.com"]);
+    expect(FinalizeAction.prototype.finalize).toHaveBeenCalledWith({
+      txId: mockTxId,
+      rpc: "https://custom.com",
+    });
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const finalizeCommand = program.commands.find(cmd => cmd.name() === "finalize");
+    finalizeCommand?.exitOverride();
+    expect(() =>
+      program.parse(["node", "test", "finalize", mockTxId, "--invalid-option"]),
+    ).toThrowError("error: unknown option '--invalid-option'");
+  });
+});
+
+describe("finalize-batch command", () => {
+  let program: Command;
+  const mockTxId1 = "0x1111111111111111111111111111111111111111111111111111111111111111";
+  const mockTxId2 = "0x2222222222222222222222222222222222222222222222222222222222222222";
+
+  beforeEach(() => {
+    program = new Command();
+    initializeTransactionsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("FinalizeAction.finalizeBatch is called with a single txId", async () => {
+    program.parse(["node", "test", "finalize-batch", mockTxId1]);
+    expect(FinalizeAction.prototype.finalizeBatch).toHaveBeenCalledWith({
+      txIds: [mockTxId1],
+    });
+  });
+
+  test("FinalizeAction.finalizeBatch is called with multiple txIds", async () => {
+    program.parse(["node", "test", "finalize-batch", mockTxId1, mockTxId2]);
+    expect(FinalizeAction.prototype.finalizeBatch).toHaveBeenCalledWith({
+      txIds: [mockTxId1, mockTxId2],
+    });
+  });
+
+  test("FinalizeAction.finalizeBatch is called with custom RPC", async () => {
+    program.parse([
+      "node", "test", "finalize-batch", mockTxId1, mockTxId2, "--rpc", "https://custom.com",
+    ]);
+    expect(FinalizeAction.prototype.finalizeBatch).toHaveBeenCalledWith({
+      txIds: [mockTxId1, mockTxId2],
+      rpc: "https://custom.com",
+    });
+  });
+});

package/tests/smoke.test.ts

@@ -7,7 +7,10 @@ import type {Address, GenLayerChain} from "genlayer-js/types";
 
 const CLI = path.resolve(__dirname, "../dist/index.js");
 
-const TIMEOUT = 30_000;
+// Testnet validator-list fetches ALL validators + per-validator detail in
+// batches; on bradbury/asimov that routinely passes 30s. 90s gives headroom
+// without hiding real hangs.
+const TIMEOUT = 90_000;
 
 const testnets: {name: string; chain: GenLayerChain}[] = [
   {name: "Asimov", chain: testnetAsimov},