genlayer 0.39.0 → 0.39.2

package/src/commands/localnet/validators.ts

@@ -89,6 +89,7 @@ export class ValidatorsAction extends BaseAction {
         method: "sim_countValidators",
         params: [],
       });
+      console.log(`Total Validators: ${result.result}`);
       this.succeedSpinner(`Total Validators: ${result.result}`);
     } catch (error) {
       this.failSpinner("Error counting validators", error);
@@ -107,15 +108,15 @@ export class ValidatorsAction extends BaseAction {
 
       const parsedStake = options.stake
         ? parseInt(options.stake, 10)
-        : currentValidator.result.stake;
+        : Number(currentValidator.result.stake);
 
-      if (isNaN(parsedStake) || parsedStake < 0) {
+      if (!Number.isInteger(parsedStake) || parsedStake < 0) {
         return this.failSpinner("Invalid stake value. Stake must be a positive integer.");
       }
 
       const updatedValidator = {
         address: options.address,
-        stake: options.stake || currentValidator.result.stake,
+        stake: parsedStake,
         provider: options.provider || currentValidator.result.provider,
         model: options.model || currentValidator.result.model,
         config: options.config ? JSON.parse(options.config) : currentValidator.result.config,
@@ -265,5 +266,3 @@ export class ValidatorsAction extends BaseAction {
     }
   }
 }
-
-

package/src/lib/clients/jsonRpcClient.ts

@@ -29,12 +29,17 @@ export class JsonRpcClient {
       }),
     });
 
-    if (response.ok) {
-      return response.json();
-    }
     const result = await response.json();
 
-    throw new Error(result?.error?.message || response.statusText);
+    if (!response.ok) {
+      throw new Error(result?.error?.message || result?.error || response.statusText);
+    }
+
+    if (result?.error) {
+      throw new Error(result.error.message || String(result.error));
+    }
+
+    return result;
 
   }
 }

package/src/lib/clients/system.ts

@@ -9,9 +9,7 @@ export async function checkCommand(command: string, toolName: string): Promise<v
   try {
     await util.promisify(exec)(command);
   }catch (error:any) {
-    if (error.stderr) {
-      throw new MissingRequirementError(toolName);
-    }
+    throw new MissingRequirementError(toolName);
   }
 }
 
@@ -50,24 +48,28 @@ export function openUrl(url: string): Promise<ChildProcess> {
 }
 
 export async function getVersion(toolName: string): Promise<string> {
+  let toolResponse: {stdout?: string; stderr?: string};
+
   try {
-    const toolResponse = await util.promisify(exec)(`${toolName} --version`);
+    toolResponse = await util.promisify(exec)(`${toolName} --version`);
+  } catch (error) {
+    throw new Error(`Error getting ${toolName} version.`);
+  }
 
-    if (toolResponse.stderr) {
-      throw new Error(toolResponse.stderr);
-    }
+  if (toolResponse.stderr) {
+    throw new Error(`Error getting ${toolName} version.`);
+  }
 
-    try {
-      const versionMatch = toolResponse.stdout.match(/(\d+\.\d+\.\d+)/);
-      if (versionMatch) {
-        return versionMatch[1];
-      }
-    } catch (err) {
-      throw new Error(`Could not parse ${toolName} version.`);
-    }
-  } catch (error) {
+  if (toolResponse.stdout == null) {
     throw new Error(`Error getting ${toolName} version.`);
   }
 
-  return "";
+  const versionMatch = toolResponse.stdout.match(/(\d+\.\d+\.\d+)/);
+  if (versionMatch) {
+    return versionMatch[1];
+  }
+
+  throw new Error(
+    `Could not parse ${toolName} version from output: "${toolResponse.stdout}". Expected format: X.Y.Z`
+  );
 }

package/tests/actions/deploy.test.ts

@@ -95,6 +95,55 @@ describe("DeployAction", () => {
     expect(mockClient.deployContract).toHaveReturnedWith(Promise.resolve("mocked_tx_hash"));
   });
 
+  test("deploys contract with fee options", async () => {
+    const options: DeployOptions = {
+      contract: "/mocked/contract/path",
+      args: [1],
+      fees: JSON.stringify({
+        distribution: {
+          leaderTimeunitsAllocation: "10",
+          rotations: ["0"],
+        },
+        messageAllocations: [{
+          messageType: "internal",
+          recipient: "0x0000000000000000000000000000000000000001",
+          budget: "5",
+        }],
+      }),
+      feeValue: "123",
+      validUntil: "999",
+    };
+    const contractContent = "contract code";
+
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
+    vi.mocked(mockClient.deployContract).mockResolvedValue("mocked_tx_hash");
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue({
+      data: {contract_address: "0xdasdsadasdasdada"},
+    });
+
+    await deployer.deploy(options);
+
+    expect(mockClient.deployContract).toHaveBeenCalledWith({
+      code: contractContent,
+      args: [1],
+      leaderOnly: false,
+      fees: {
+        distribution: {
+          leaderTimeunitsAllocation: "10",
+          rotations: ["0"],
+        },
+        messageAllocations: [{
+          messageType: 1,
+          recipient: "0x0000000000000000000000000000000000000001",
+          budget: "5",
+        }],
+        feeValue: "123",
+      },
+      validUntil: "999",
+    });
+  });
+
   test("throws error for missing contract", async () => {
     const options: DeployOptions = {};
 

package/tests/actions/estimateFees.test.ts

@@ -0,0 +1,271 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import {EstimateFeesAction} from "../../src/commands/contracts/estimateFees";
+
+vi.mock("genlayer-js");
+
+describe("EstimateFeesAction", () => {
+  let action: EstimateFeesAction;
+  const mockClient = {
+    initializeConsensusSmartContract: vi.fn(),
+    estimateTransactionFees: vi.fn(),
+    estimateTransactionFeesForWrite: vi.fn(),
+    simulateWriteContract: vi.fn(),
+    estimateTransactionFeesFromSimulation: 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);
+    action = new EstimateFeesAction();
+    vi.spyOn(action as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+    vi.spyOn(action as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(action as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(action as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(action as any, "setSpinnerText").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("builds a static fee estimate", async () => {
+    const estimate = {
+      distribution: {leaderTimeunitsAllocation: 100n, rotations: [0n]},
+      feeValue: 1100n,
+      policy: {enabled: true},
+    };
+    vi.mocked(mockClient.estimateTransactionFees).mockResolvedValue(estimate);
+
+    await action.estimate({
+      fees: JSON.stringify({
+        distribution: {
+          leaderTimeunitsAllocation: "100",
+          rotations: ["0"],
+        },
+      }),
+    });
+
+    expect(mockClient.estimateTransactionFees).toHaveBeenCalledWith({
+      leaderTimeunitsAllocation: "100",
+      rotations: ["0"],
+    });
+    expect(mockClient.simulateWriteContract).not.toHaveBeenCalled();
+    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Fee estimate generated", {
+      distribution: {leaderTimeunitsAllocation: "100", rotations: ["0"]},
+      feeValue: "1100",
+      policy: {enabled: true},
+    });
+  });
+
+  test("prints a static fee estimate as JSON without spinner output", async () => {
+    const estimate = {
+      distribution: {leaderTimeunitsAllocation: 100n, rotations: [0n]},
+      feeValue: 1100n,
+      policy: {enabled: true},
+    };
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.mocked(mockClient.estimateTransactionFees).mockResolvedValue(estimate);
+
+    await action.estimate({json: true});
+
+    expect(action["startSpinner"]).not.toHaveBeenCalled();
+    expect(action["succeedSpinner"]).not.toHaveBeenCalled();
+    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({
+      distribution: {leaderTimeunitsAllocation: "100", rotations: ["0"]},
+      feeValue: "1100",
+      policy: {enabled: true},
+    }));
+  });
+
+  test("derives a fee estimate for a target write through the SDK one-call helper", async () => {
+    const finalEstimate = {
+      distribution: {leaderTimeunitsAllocation: 100n, totalMessageFees: 110n, rotations: [0n]},
+      messageAllocations: [{messageType: 1, budget: 110n}],
+      feeValue: 1310n,
+      observed: {messageFeeBudget: 110n, messageFeeConsumed: 55n},
+      policy: {enabled: true},
+    };
+    vi.mocked(mockClient.estimateTransactionFeesForWrite).mockResolvedValue(finalEstimate);
+
+    await action.estimate({
+      contractAddress: "0x0000000000000000000000000000000000000001",
+      method: "update",
+      args: ["after"],
+      fees: JSON.stringify({
+        messageAllocations: [{
+          messageType: "internal",
+          callKeyMethod: "settle_campaign",
+          budget: "110",
+        }],
+      }),
+    });
+
+    expect(mockClient.estimateTransactionFeesForWrite).toHaveBeenCalledWith({
+      messageAllocations: [{
+        messageType: 1,
+        callKey: `0x${Buffer.from("settle_campaign", "utf8").toString("hex").padEnd(64, "0")}`,
+        budget: "110",
+      }],
+      address: "0x0000000000000000000000000000000000000001",
+      functionName: "update",
+      args: ["after"],
+    });
+    expect(mockClient.estimateTransactionFees).not.toHaveBeenCalled();
+    expect(mockClient.simulateWriteContract).not.toHaveBeenCalled();
+    expect(mockClient.estimateTransactionFeesFromSimulation).not.toHaveBeenCalled();
+    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Fee estimate generated", {
+      distribution: {leaderTimeunitsAllocation: "100", totalMessageFees: "110", rotations: ["0"]},
+      messageAllocations: [{messageType: 1, budget: "110"}],
+      feeValue: "1310",
+      observed: {messageFeeBudget: "110", messageFeeConsumed: "55"},
+      policy: {enabled: true},
+    });
+  });
+
+  test("falls back to explicit simulation when the SDK one-call helper is unavailable", async () => {
+    const legacyClient = {
+      ...mockClient,
+      estimateTransactionFeesForWrite: undefined,
+    };
+    vi.mocked(createClient).mockReturnValue(legacyClient as any);
+    const initialEstimate = {
+      distribution: {leaderTimeunitsAllocation: 100n, rotations: [0n]},
+      messageAllocations: [{messageType: 1, budget: 55n}],
+      feeValue: 1200n,
+      policy: {enabled: true},
+    };
+    const simulation = {feeAccounting: {status: "active"}};
+    const finalEstimate = {
+      distribution: {leaderTimeunitsAllocation: 100n, totalMessageFees: 55n, rotations: [0n]},
+      messageAllocations: [{messageType: 1, budget: 55n}],
+      feeValue: 1255n,
+      observed: {messageFeeConsumed: 55n},
+      policy: {enabled: true},
+    };
+    vi.mocked(mockClient.estimateTransactionFees).mockResolvedValue(initialEstimate);
+    vi.mocked(mockClient.simulateWriteContract).mockResolvedValue(simulation);
+    vi.mocked(mockClient.estimateTransactionFeesFromSimulation).mockResolvedValue(finalEstimate);
+
+    await action.estimate({
+      contractAddress: "0x0000000000000000000000000000000000000001",
+      method: "update",
+      args: ["after"],
+      fees: JSON.stringify({
+        messageAllocations: [{messageType: "internal", budget: "55"}],
+      }),
+    });
+
+    expect(mockClient.estimateTransactionFees).toHaveBeenCalledWith({
+      messageAllocations: [{messageType: 1, budget: "55"}],
+    });
+    expect(mockClient.simulateWriteContract).toHaveBeenCalledWith({
+      address: "0x0000000000000000000000000000000000000001",
+      functionName: "update",
+      args: ["after"],
+      includeReceipt: true,
+      fees: {
+        distribution: initialEstimate.distribution,
+        messageAllocations: initialEstimate.messageAllocations,
+        feeValue: initialEstimate.feeValue,
+      },
+    });
+    expect(mockClient.estimateTransactionFeesFromSimulation).toHaveBeenCalledWith({
+      messageAllocations: [{messageType: 1, budget: "55"}],
+      simulation,
+    });
+    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Fee estimate generated", {
+      distribution: {leaderTimeunitsAllocation: "100", totalMessageFees: "55", rotations: ["0"]},
+      messageAllocations: [{messageType: 1, budget: "55"}],
+      feeValue: "1255",
+      observed: {messageFeeConsumed: "55"},
+      policy: {enabled: true},
+    });
+  });
+
+  test("includes simulation fee report when requested", async () => {
+    const initialEstimate = {
+      distribution: {leaderTimeunitsAllocation: 100n, rotations: [0n]},
+      messageAllocations: [{messageType: 1, budget: 55n}],
+      feeValue: 1200n,
+      policy: {enabled: true},
+    };
+    const simulation = {
+      feeAccounting: {
+        status: "active",
+        message_fee_budget: 55n,
+        message_fee_consumed: 55n,
+        execution_fee_report: {
+          messageFees: {
+            budget: 55n,
+            declaredConsumed: 55n,
+            remaining: 0n,
+          },
+        },
+      },
+      feeReport: {
+        totalEstimatedFee: 501664n,
+      },
+    };
+    const finalEstimate = {
+      distribution: {leaderTimeunitsAllocation: 100n, totalMessageFees: 55n, rotations: [0n]},
+      messageAllocations: [{messageType: 1, budget: 55n}],
+      feeValue: 1255n,
+      observed: {messageFeeConsumed: 55n},
+      policy: {enabled: true},
+    };
+    vi.mocked(mockClient.estimateTransactionFees).mockResolvedValue(initialEstimate);
+    vi.mocked(mockClient.simulateWriteContract).mockResolvedValue(simulation);
+    vi.mocked(mockClient.estimateTransactionFeesFromSimulation).mockResolvedValue(finalEstimate);
+
+    await action.estimate({
+      contractAddress: "0x0000000000000000000000000000000000000001",
+      method: "update",
+      args: ["after"],
+      includeReport: true,
+      fees: JSON.stringify({
+        messageAllocations: [{messageType: "internal", budget: "55"}],
+      }),
+    });
+
+    expect(mockClient.estimateTransactionFeesForWrite).not.toHaveBeenCalled();
+    expect(mockClient.simulateWriteContract).toHaveBeenCalledWith({
+      address: "0x0000000000000000000000000000000000000001",
+      functionName: "update",
+      args: ["after"],
+      includeReceipt: true,
+      fees: {
+        distribution: initialEstimate.distribution,
+        messageAllocations: initialEstimate.messageAllocations,
+        feeValue: initialEstimate.feeValue,
+      },
+    });
+    expect(action["succeedSpinner"]).toHaveBeenCalledWith("Fee estimate generated", {
+      distribution: {leaderTimeunitsAllocation: "100", totalMessageFees: "55", rotations: ["0"]},
+      messageAllocations: [{messageType: 1, budget: "55"}],
+      feeValue: "1255",
+      observed: {messageFeeConsumed: "55"},
+      policy: {enabled: true},
+      simulation: {
+        feeAccounting: {
+          status: "active",
+          message_fee_budget: "55",
+          message_fee_consumed: "55",
+          execution_fee_report: {
+            messageFees: {
+              budget: "55",
+              declaredConsumed: "55",
+              remaining: "0",
+            },
+          },
+        },
+        feeReport: {
+          totalEstimatedFee: "501664",
+        },
+      },
+    });
+  });
+});

package/tests/actions/validators.test.ts

@@ -581,7 +581,7 @@ describe("ValidatorsAction", () => {
         method: "sim_updateValidator",
         params: [
           "mocked_address",
-          "200",
+          200,
           "Provider1",
           "Model1",
           { max_tokens: 500 },
@@ -624,7 +624,7 @@ describe("ValidatorsAction", () => {
         method: "sim_updateValidator",
         params: [
           "mocked_address",
-          "100",
+          100,
           "Provider2",
           "Model2",
           { max_tokens: 500 },
@@ -668,7 +668,7 @@ describe("ValidatorsAction", () => {
         method: "sim_updateValidator",
         params: [
           "mocked_address",
-          "100",
+          100,
           "Provider1",
           "Model1",
           { max_tokens: 1000 },
@@ -709,7 +709,7 @@ describe("ValidatorsAction", () => {
         method: "sim_updateValidator",
         params: [
           "mocked_address",
-          "200",
+          200,
           "Provider1",
           "Model1",
           { max_tokens: 500 },
@@ -747,4 +747,4 @@ describe("ValidatorsAction", () => {
       expect(rpcClient.request).toHaveBeenCalledTimes(1);
     });
   });
-});
+});

package/tests/actions/write.test.ts

@@ -58,6 +58,53 @@ describe("WriteAction", () => {
     );
   });
 
+  test("calls writeContract with fee options", async () => {
+    const mockHash = "0xMockedTransactionHash";
+    const mockReceipt = {status: "success"};
+
+    vi.mocked(mockClient.writeContract).mockResolvedValue(mockHash);
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await writeAction.write({
+      contractAddress: "0xMockedContract",
+      method: "updateData",
+      args: [42],
+      fees: JSON.stringify({
+        distribution: {
+          totalMessageFees: "3",
+        },
+        messageAllocations: [{
+          messageType: "external",
+          recipient: "0x0000000000000000000000000000000000000001",
+          callKeySelector: "0xaabbccdd",
+          budget: "3",
+        }],
+      }),
+      feeValue: "4",
+      validUntil: "999",
+    });
+
+    expect(mockClient.writeContract).toHaveBeenCalledWith({
+      address: "0xMockedContract",
+      functionName: "updateData",
+      args: [42],
+      value: 0n,
+      fees: {
+        distribution: {
+          totalMessageFees: "3",
+        },
+        messageAllocations: [{
+          messageType: 0,
+          recipient: "0x0000000000000000000000000000000000000001",
+          callKey: `0xaabbccdd${"0".repeat(56)}`,
+          budget: "3",
+        }],
+        feeValue: "4",
+      },
+      validUntil: "999",
+    });
+  });
+
   test("handles writeContract errors", async () => {
     vi.mocked(mockClient.writeContract).mockRejectedValue(new Error("Mocked write error"));
 

package/tests/commands/deploy.test.ts

@@ -52,6 +52,31 @@ describe("deploy command", () => {
     });
   });
 
+  test("DeployAction.deploy receives fee options", async () => {
+    const fees = '{"distribution":{"totalMessageFees":"3"}}';
+    program.parse([
+      "node",
+      "test",
+      "deploy",
+      "--contract",
+      "./path/to/contract",
+      "--fees",
+      fees,
+      "--fee-value",
+      "4",
+      "--valid-until",
+      "999",
+    ]);
+
+    expect(DeployAction.prototype.deploy).toHaveBeenCalledWith({
+      contract: "./path/to/contract",
+      args: [],
+      fees,
+      feeValue: "4",
+      validUntil: "999",
+    });
+  });
+
   test("DeployAction is instantiated when the deploy command is executed", async () => {
     program.parse(["node", "test", "deploy", "--contract", "./path/to/contract"]);
     expect(DeployAction).toHaveBeenCalledTimes(1);

package/tests/commands/estimateFees.test.ts

@@ -0,0 +1,98 @@
+import {Command} from "commander";
+import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
+import {initializeContractsCommands} from "../../src/commands/contracts";
+import {EstimateFeesAction} from "../../src/commands/contracts/estimateFees";
+
+vi.mock("../../src/commands/contracts/estimateFees");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
+
+describe("estimate-fees command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeContractsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("EstimateFeesAction.estimate is called with static estimate options", async () => {
+    const fees = '{"distribution":{"totalMessageFees":"3"}}';
+    program.parse([
+      "node",
+      "test",
+      "estimate-fees",
+      "--fees",
+      fees,
+      "--rpc",
+      "http://127.0.0.1:4000/api",
+    ]);
+
+    expect(EstimateFeesAction).toHaveBeenCalledTimes(1);
+    expect(EstimateFeesAction.prototype.estimate).toHaveBeenCalledWith({
+      args: [],
+      fees,
+      rpc: "http://127.0.0.1:4000/api",
+      contractAddress: undefined,
+      method: undefined,
+    });
+  });
+
+  test("EstimateFeesAction.estimate is called with simulation target and args", async () => {
+    program.parse([
+      "node",
+      "test",
+      "estimate-fees",
+      "0x0000000000000000000000000000000000000001",
+      "update",
+      "--args",
+      "after",
+      "2",
+    ]);
+
+    expect(EstimateFeesAction.prototype.estimate).toHaveBeenCalledWith({
+      args: ["after", 2],
+      contractAddress: "0x0000000000000000000000000000000000000001",
+      method: "update",
+    });
+  });
+
+  test("EstimateFeesAction.estimate receives json output flag", async () => {
+    program.parse([
+      "node",
+      "test",
+      "estimate-fees",
+      "--json",
+    ]);
+
+    expect(EstimateFeesAction.prototype.estimate).toHaveBeenCalledWith({
+      args: [],
+      contractAddress: undefined,
+      json: true,
+      method: undefined,
+    });
+  });
+
+  test("EstimateFeesAction.estimate receives include-report flag", async () => {
+    program.parse([
+      "node",
+      "test",
+      "estimate-fees",
+      "0x0000000000000000000000000000000000000001",
+      "update",
+      "--include-report",
+    ]);
+
+    expect(EstimateFeesAction.prototype.estimate).toHaveBeenCalledWith({
+      args: [],
+      contractAddress: "0x0000000000000000000000000000000000000001",
+      includeReport: true,
+      method: "update",
+    });
+  });
+});

package/tests/commands/write.test.ts

@@ -54,6 +54,32 @@ describe("write command", () => {
     });
   });
 
+  test("WriteAction.write receives fee options", async () => {
+    const fees = '{"distribution":{"totalMessageFees":"3"}}';
+    program.parse([
+      "node",
+      "test",
+      "write",
+      "0xMockedContract",
+      "updateCounter",
+      "--fees",
+      fees,
+      "--fee-value",
+      "4",
+      "--valid-until",
+      "999",
+    ]);
+
+    expect(WriteAction.prototype.write).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      method: "updateCounter",
+      args: [],
+      fees,
+      feeValue: "4",
+      validUntil: "999",
+    });
+  });
+
   test("WriteAction is instantiated when the write command is executed", async () => {
     program.parse(["node", "test", "write", "0xMockedContract", "anotherMethod"]);
     expect(WriteAction).toHaveBeenCalledTimes(1);