genlayer 0.39.0 → 0.39.2

package/dist/index.js

@@ -20078,7 +20078,7 @@ var require_cli_table3 = __commonJS({
 import { program } from "commander";
 
 // package.json
-var version = "0.39.0";
+var version = "0.39.2";
 var package_default = {
   name: "genlayer",
   version,
@@ -20095,8 +20095,7 @@ var package_default = {
     "test:smoke": "vitest run --config vitest.smoke.config.ts",
     dev: "cross-env NODE_ENV=development node esbuild.config.js",
     build: "cross-env NODE_ENV=production node esbuild.config.js",
-    release: "release-it --ci",
-    "release-beta": "release-it --ci --preRelease=beta",
+    release: "./scripts/release.sh",
     postinstall: "node ./scripts/postinstall.js",
     "docs:cli": "node scripts/generate-cli-docs.mjs"
   },
@@ -20148,7 +20147,7 @@ var package_default = {
     dotenv: "^17.0.0",
     ethers: "^6.13.4",
     "fs-extra": "^11.3.0",
-    "genlayer-js": "^1.0.0",
+    "genlayer-js": "^1.1.8",
     inquirer: "^12.0.0",
     keytar: "^7.9.0",
     "node-fetch": "^3.0.0",
@@ -21585,11 +21584,14 @@ var JsonRpcClient = class {
         params
       })
     });
-    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;
   }
 };
 var rpcClient = new JsonRpcClient(DEFAULT_JSON_RPC_URL);
@@ -50340,9 +50342,20 @@ function accountActions(client) {
         params: [address, amount]
       });
     },
+    /**
+     * Returns the transaction count (next nonce) for an address.
+     *
+     * Defaults to `"pending"` so that rapid sequential submissions from the
+     * same account receive distinct nonces. Two submissions issued before the
+     * first confirms would otherwise both see the same `"latest"` count and
+     * collide with an "already known" or "replacement underpriced" error.
+     *
+     * Pass `block: "latest"` explicitly for confirmed-only state
+     * (e.g. reconciliation tooling comparing against on-chain finality).
+     */
     getCurrentNonce: async ({
       address,
-      block = "latest"
+      block = "pending"
     }) => {
       const addressToUse = address || client.account?.address;
       if (!addressToUse) {
@@ -50708,6 +50721,13 @@ var transactions = transactions_exports;
 function b64ToArray(b64) {
   return Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
 }
+function arrayToB64(bytes) {
+  let binary = "";
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    binary += String.fromCharCode(bytes[i2]);
+  }
+  return btoa(binary);
+}
 function calldataToUserFriendlyJson(cd) {
   return {
     raw: Array.from(cd),
@@ -50806,37 +50826,49 @@ function extractGenCallResult(result) {
 }
 var contractActions = (client, publicClient) => {
   return {
-    /** Retrieves the source code of a deployed contract. Studio only. */
+    /** Retrieves the source code of a deployed contract. */
     getContractCode: async (address) => {
-      if (!client.chain.isStudio) {
-        throw new Error(`getContractCode is only available on Studio networks (current chain: ${client.chain.name})`);
-      }
+      const params = client.chain.isStudio ? [address] : [{ address }];
       const result = await client.request({
         method: "gen_getContractCode",
-        params: [address]
+        params
       });
       const codeBytes = b64ToArray(result);
       return new TextDecoder().decode(codeBytes);
     },
-    /** Gets the schema (methods and constructor) of a deployed contract. Studio only. */
+    /** Gets the schema (methods and constructor) of a deployed contract. */
     getContractSchema: async (address) => {
-      if (!client.chain.isStudio) {
-        throw new Error(`getContractSchema is only available on Studio networks (current chain: ${client.chain.name})`);
+      if (client.chain.isStudio) {
+        const schema2 = await client.request({
+          method: "gen_getContractSchema",
+          params: [address]
+        });
+        return schema2;
       }
+      const codeB64 = await client.request({
+        method: "gen_getContractCode",
+        params: [{ address }]
+      });
       const schema = await client.request({
         method: "gen_getContractSchema",
-        params: [address]
+        params: [{ code: codeB64 }]
       });
       return schema;
     },
-    /** Generates a schema for contract code without deploying it. Studio only. */
+    /** Generates a schema for contract code without deploying it. */
     getContractSchemaForCode: async (contractCode) => {
-      if (!client.chain.isStudio) {
-        throw new Error(`getContractSchemaForCode is only available on Studio networks (current chain: ${client.chain.name})`);
+      if (client.chain.isStudio) {
+        const schema2 = await client.request({
+          method: "gen_getContractSchemaForCode",
+          params: [toHex(contractCode)]
+        });
+        return schema2;
       }
+      const bytes = typeof contractCode === "string" ? new TextEncoder().encode(contractCode) : contractCode;
+      const codeB64 = arrayToB64(bytes);
       const schema = await client.request({
-        method: "gen_getContractSchemaForCode",
-        params: [toHex(contractCode)]
+        method: "gen_getContractSchema",
+        params: [{ code: codeB64 }]
       });
       return schema;
     },
@@ -51202,10 +51234,11 @@ var _encodeAddTransactionData = ({
     functionName: "addTransaction",
     args: addTransactionArgs
   });
+  const validUntil = BigInt(Math.floor(Date.now() / 1e3) + 3600);
   const encodedDataV6 = encodeFunctionData({
     abi: ADD_TRANSACTION_ABI_V6,
     functionName: "addTransaction",
-    args: [...addTransactionArgs, 0n]
+    args: [...addTransactionArgs, validUntil]
   });
   if (getAddTransactionInputCount(client.chain.consensusMainContract?.abi) >= 6) {
     return {
@@ -53522,9 +53555,7 @@ async function checkCommand(command, toolName) {
   try {
     await util.promisify(exec)(command);
   } catch (error) {
-    if (error.stderr) {
-      throw new MissingRequirementError(toolName);
-    }
+    throw new MissingRequirementError(toolName);
   }
 }
 async function executeCommand(cmdsByPlatform, toolName) {
@@ -53547,23 +53578,25 @@ function openUrl(url) {
   return open_default(url);
 }
 async function getVersion2(toolName) {
+  let toolResponse;
   try {
-    const toolResponse = await util.promisify(exec)(`${toolName} --version`);
-    if (toolResponse.stderr) {
-      throw new Error(toolResponse.stderr);
-    }
-    try {
-      const versionMatch = toolResponse.stdout.match(/(\d+\.\d+\.\d+)/);
-      if (versionMatch) {
-        return versionMatch[1];
-      }
-    } catch (err) {
-      throw new Error(`Could not parse ${toolName} version.`);
-    }
+    toolResponse = await util.promisify(exec)(`${toolName} --version`);
   } catch (error) {
     throw new Error(`Error getting ${toolName} version.`);
   }
-  return "";
+  if (toolResponse.stderr) {
+    throw new Error(`Error getting ${toolName} version.`);
+  }
+  if (toolResponse.stdout == null) {
+    throw new Error(`Error getting ${toolName} version.`);
+  }
+  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`
+  );
 }
 
 // src/lib/errors/versionRequired.ts
@@ -54680,6 +54713,200 @@ import fs9 from "fs";
 import path5 from "path";
 import { pathToFileURL } from "url";
 import { buildSync } from "esbuild";
+
+// src/commands/contracts/fees.ts
+var parseJsonObject = (value, optionName) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error(`${optionName} must be valid JSON.`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${optionName} must be a JSON object.`);
+  }
+  assertSafeJsonNumbers(parsed, optionName);
+  return parsed;
+};
+var assertSafeJsonNumbers = (value, path8) => {
+  if (typeof value === "number" && !Number.isSafeInteger(value)) {
+    throw new Error(`${path8} contains an unsafe number. Quote large integer values as strings.`);
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index2) => assertSafeJsonNumbers(item, `${path8}[${index2}]`));
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) {
+      assertSafeJsonNumbers(item, `${path8}.${key}`);
+    }
+  }
+};
+var parseBigNumberishOption = (value, optionName) => {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (!/^(0x[0-9a-fA-F]+|[0-9]+)$/.test(trimmed)) {
+    throw new Error(`${optionName} must be a non-negative integer.`);
+  }
+  return trimmed;
+};
+var CALL_KEY_UNNAMED = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var bytesToPaddedCallKey = (bytes) => {
+  if (bytes.length > 32) {
+    throw new Error("call key source bytes must be 32 bytes or fewer.");
+  }
+  return `0x${toHex(bytes).slice(2).padEnd(64, "0")}`;
+};
+var deriveInternalMessageCallKey = (methodName = "") => {
+  const methodBytes = new TextEncoder().encode(methodName);
+  if (methodBytes.length < 32) {
+    return bytesToPaddedCallKey(methodBytes);
+  }
+  const hashed = keccak256(methodBytes);
+  const lastByte = Number.parseInt(hashed.slice(-2), 16) | 1;
+  return `${hashed.slice(0, -2)}${lastByte.toString(16).padStart(2, "0")}`;
+};
+var deriveExternalMessageCallKey = (selectorOrCalldata) => {
+  const bytes = hexToBytes(selectorOrCalldata);
+  if (bytes.length < 4) {
+    return CALL_KEY_UNNAMED;
+  }
+  return bytesToPaddedCallKey(bytes.slice(0, 4));
+};
+var normalizeMessageType = (messageType, index2) => {
+  if (messageType === void 0) {
+    return void 0;
+  }
+  if (typeof messageType === "number") {
+    if (messageType === 0 || messageType === 1) {
+      return messageType;
+    }
+    throw new Error(`--fees.messageAllocations[${index2}].messageType must be "internal", "external", 0, or 1.`);
+  }
+  if (typeof messageType !== "string") {
+    return void 0;
+  }
+  const normalized = messageType.toLowerCase();
+  if (normalized === "internal") {
+    return 1;
+  }
+  if (normalized === "external") {
+    return 0;
+  }
+  throw new Error(`--fees.messageAllocations[${index2}].messageType must be "internal" or "external".`);
+};
+var readStringField = (allocation, field, index2) => {
+  const value = allocation[field];
+  if (typeof value !== "string") {
+    throw new Error(`--fees.messageAllocations[${index2}].${field} must be a string.`);
+  }
+  return value;
+};
+var assertFourByteSelector = (selector, field, index2) => {
+  if (!/^0x[0-9a-fA-F]{8}$/.test(selector)) {
+    throw new Error(`--fees.messageAllocations[${index2}].${field} must be a 4-byte hex selector.`);
+  }
+};
+var assertHexBytes = (hex, field, index2) => {
+  if (!/^0x([0-9a-fA-F]{2})*$/.test(hex)) {
+    throw new Error(`--fees.messageAllocations[${index2}].${field} must be even-length hex bytes.`);
+  }
+};
+var normalizeMessageAllocationCallKey = (allocation, messageType, index2) => {
+  const helperFields = [
+    "callKeyMethod",
+    "callKeySelector",
+    "callKeyCalldata",
+    "functionSelector"
+  ].filter((field) => allocation[field] !== void 0);
+  if (allocation.callKey !== void 0 && helperFields.length > 0) {
+    throw new Error(`--fees.messageAllocations[${index2}] cannot combine callKey with call-key helper fields.`);
+  }
+  if (helperFields.length > 1) {
+    throw new Error(`--fees.messageAllocations[${index2}] must use only one call-key helper field.`);
+  }
+  const {
+    callKeyMethod,
+    callKeySelector,
+    callKeyCalldata,
+    functionSelector,
+    ...normalized
+  } = allocation;
+  if (helperFields.length === 0) {
+    return normalized;
+  }
+  const helperField = helperFields[0];
+  if (helperField === "callKeyMethod") {
+    if (messageType === 0) {
+      throw new Error(`--fees.messageAllocations[${index2}].callKeyMethod requires an internal message allocation.`);
+    }
+    normalized.messageType = messageType ?? 1;
+    normalized.callKey = deriveInternalMessageCallKey(readStringField(allocation, helperField, index2));
+    return normalized;
+  }
+  if (messageType === 1) {
+    throw new Error(`--fees.messageAllocations[${index2}].${helperField} requires an external message allocation.`);
+  }
+  const selectorOrCalldata = readStringField(allocation, helperField, index2);
+  if (helperField === "callKeySelector" || helperField === "functionSelector") {
+    assertFourByteSelector(selectorOrCalldata, helperField, index2);
+  } else {
+    assertHexBytes(selectorOrCalldata, helperField, index2);
+  }
+  normalized.messageType = messageType ?? 0;
+  normalized.callKey = deriveExternalMessageCallKey(selectorOrCalldata);
+  return normalized;
+};
+var normalizeMessageTypes = (fees) => {
+  if (!Array.isArray(fees.messageAllocations)) {
+    return fees;
+  }
+  return {
+    ...fees,
+    messageAllocations: fees.messageAllocations.map((allocation, index2) => {
+      if (!allocation || typeof allocation !== "object" || Array.isArray(allocation)) {
+        throw new Error(`--fees.messageAllocations[${index2}] must be an object.`);
+      }
+      const messageType = normalizeMessageType(allocation.messageType, index2);
+      return normalizeMessageAllocationCallKey({
+        ...allocation,
+        ...messageType === void 0 ? {} : { messageType }
+      }, messageType, index2);
+    })
+  };
+};
+var parseTransactionFees = (options) => {
+  const feeValue = parseBigNumberishOption(options.feeValue, "--fee-value");
+  let fees = options.fees ? parseJsonObject(options.fees, "--fees") : void 0;
+  if (!fees && feeValue === void 0) {
+    return void 0;
+  }
+  fees = normalizeMessageTypes(fees ?? {});
+  if (feeValue !== void 0) {
+    fees.feeValue = feeValue;
+  }
+  return fees;
+};
+var parseFeeEstimateOptions = (options) => {
+  if (!options.fees) {
+    return void 0;
+  }
+  const parsed = normalizeMessageTypes(parseJsonObject(options.fees, "--fees"));
+  if (parsed.distribution && typeof parsed.distribution === "object" && !Array.isArray(parsed.distribution)) {
+    const { distribution, messageAllocations, ...rest } = parsed;
+    return {
+      ...distribution,
+      ...messageAllocations !== void 0 ? { messageAllocations } : {},
+      ...rest
+    };
+  }
+  return parsed;
+};
+var parseValidUntil = (options) => {
+  return parseBigNumberishOption(options.validUntil, "--valid-until");
+};
+
+// src/commands/contracts/deploy.ts
 var DeployAction = class extends BaseAction {
   constructor() {
     super();
@@ -54776,6 +55003,10 @@ var DeployAction = class extends BaseAction {
       }
       const leaderOnly = false;
       const deployParams = { code: contractCode, args: options.args, leaderOnly };
+      const fees = parseTransactionFees(options);
+      const validUntil = parseValidUntil(options);
+      if (fees) deployParams.fees = fees;
+      if (validUntil !== void 0) deployParams.validUntil = validUntil;
       this.setSpinnerText("Starting contract deployment...");
       this.log("Deployment Parameters:", deployParams);
       const hash3 = await client.deployContract(deployParams);
@@ -54835,18 +55066,26 @@ var WriteAction = class extends BaseAction {
     contractAddress,
     method,
     args,
-    rpc
+    rpc,
+    fees,
+    feeValue,
+    validUntil
   }) {
     const client = await this.getClient(rpc);
     await client.initializeConsensusSmartContract();
     this.startSpinner(`Calling write method ${method} on contract at ${contractAddress}...`);
     try {
-      const hash3 = await client.writeContract({
+      const writeParams = {
         address: contractAddress,
         functionName: method,
         args,
         value: 0n
-      });
+      };
+      const parsedFees = parseTransactionFees({ fees, feeValue, validUntil });
+      const parsedValidUntil = parseValidUntil({ fees, feeValue, validUntil });
+      if (parsedFees) writeParams.fees = parsedFees;
+      if (parsedValidUntil !== void 0) writeParams.validUntil = parsedValidUntil;
+      const hash3 = await client.writeContract(writeParams);
       this.log("Write Transaction Hash:", hash3);
       const result = await client.waitForTransactionReceipt({
         hash: hash3,
@@ -54902,6 +55141,111 @@ var CodeAction = class extends BaseAction {
   }
 };
 
+// src/commands/contracts/estimateFees.ts
+var toTransactionFees = (estimate) => ({
+  distribution: estimate.distribution,
+  ...estimate.messageAllocations ? { messageAllocations: estimate.messageAllocations } : {},
+  feeValue: estimate.feeValue ?? estimate.fee_value
+});
+var toJsonSafe = (value) => {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(toJsonSafe);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [key, toJsonSafe(item)])
+    );
+  }
+  return value;
+};
+var simulationFeeReport = (simulation) => simulation.feeReport ?? simulation.feeAccounting?.execution_fee_report;
+var withSimulationReport = (estimate, simulation) => {
+  if (!simulation || typeof simulation !== "object" || Array.isArray(simulation)) {
+    return estimate;
+  }
+  const simulationRecord = simulation;
+  return {
+    ...estimate && typeof estimate === "object" && !Array.isArray(estimate) ? estimate : { estimate },
+    simulation: {
+      feeAccounting: simulationRecord.feeAccounting,
+      feeReport: simulationFeeReport(simulationRecord)
+    }
+  };
+};
+var EstimateFeesAction = class extends BaseAction {
+  constructor() {
+    super();
+  }
+  async estimate({
+    contractAddress,
+    method,
+    args,
+    rpc,
+    fees,
+    json,
+    includeReport
+  }) {
+    try {
+      const client = await this.getClient(rpc, true);
+      await client.initializeConsensusSmartContract();
+      const estimateOptions = parseFeeEstimateOptions({ fees });
+      if (!json) this.startSpinner("Estimating transaction fees...");
+      let estimate;
+      if (contractAddress || method) {
+        if (!contractAddress || !method) {
+          this.failSpinner("Both contractAddress and method are required for simulation-derived fee estimates.");
+          return;
+        }
+        if (!json) this.setSpinnerText(`Simulating ${method} on ${contractAddress}...`);
+        if (!includeReport && typeof client.estimateTransactionFeesForWrite === "function") {
+          estimate = await client.estimateTransactionFeesForWrite({
+            ...estimateOptions ?? {},
+            address: contractAddress,
+            functionName: method,
+            args: args ?? []
+          });
+        } else {
+          if (typeof client.simulateWriteContract !== "function") {
+            this.failSpinner("The active genlayer-js client does not support write simulation.");
+            return;
+          }
+          if (typeof client.estimateTransactionFeesFromSimulation !== "function") {
+            this.failSpinner("The active genlayer-js client does not support simulation-derived fee estimates.");
+            return;
+          }
+          const initialEstimate = await client.estimateTransactionFees(estimateOptions);
+          const simulation = await client.simulateWriteContract({
+            address: contractAddress,
+            functionName: method,
+            args: args ?? [],
+            includeReceipt: true,
+            fees: toTransactionFees(initialEstimate)
+          });
+          estimate = await client.estimateTransactionFeesFromSimulation({
+            ...estimateOptions ?? {},
+            simulation
+          });
+          if (includeReport) {
+            estimate = withSimulationReport(estimate, simulation);
+          }
+        }
+      } else {
+        if (includeReport) {
+          this.failSpinner("--include-report requires both contractAddress and method.");
+          return;
+        }
+        estimate = await client.estimateTransactionFees(estimateOptions);
+      }
+      if (json) {
+        console.log(JSON.stringify(toJsonSafe(estimate)));
+      } else {
+        this.succeedSpinner("Fee estimate generated", toJsonSafe(estimate));
+      }
+    } catch (error) {
+      this.failSpinner("Error estimating transaction fees", error);
+    }
+  }
+};
+
 // src/commands/contracts/index.ts
 var ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
 var ADDR_PREFIX_RE = /^addr#([0-9a-fA-F]{40})$/;
@@ -54967,8 +55311,24 @@ var ARGS_HELP = [
   `  array: '[1, 2, "three"]'`,
   `  dict: '{"key": "value"}'`
 ].join("\n");
+var FEES_HELP = [
+  "Transaction fee options JSON passed to genlayer-js.",
+  "Example:",
+  `  '{"distribution":{"leaderTimeunitsAllocation":"100","validatorTimeunitsAllocation":"200","rotations":["0"]}}'`,
+  "Omit --fee-value to let genlayer-js derive the fee deposit from FeeManager or Studio.",
+  'Message allocation messageType may be "internal", "external", 0, or 1.',
+  "Use callKeyMethod for internal messages, or callKeySelector/callKeyCalldata for external messages."
+].join("\n");
+var FEE_ESTIMATE_HELP = [
+  "Fee estimate options JSON passed to genlayer-js estimateTransactionFees.",
+  "You may pass either flat estimate options or a transaction fee object with distribution/messageAllocations.",
+  "Example:",
+  `  '{"distribution":{"leaderTimeunitsAllocation":"100","validatorTimeunitsAllocation":"200","rotations":["0"]}}'`,
+  'Message allocation messageType may be "internal", "external", 0, or 1.',
+  "Use callKeyMethod for internal messages, or callKeySelector/callKeyCalldata for external messages."
+].join("\n");
 function initializeContractsCommands(program2) {
-  program2.command("deploy").description("Deploy intelligent contracts").option("--contract <contractPath>", "Path to the smart contract to deploy").option("--rpc <rpcUrl>", "RPC URL for the network").option("--args <args...>", ARGS_HELP, parseArg, []).action(async (options) => {
+  program2.command("deploy").description("Deploy intelligent contracts").option("--contract <contractPath>", "Path to the smart contract to deploy").option("--rpc <rpcUrl>", "RPC URL for the network").option("--fees <json>", FEES_HELP).option("--fee-value <wei>", "Fee deposit value to send with the transaction").option("--valid-until <unixTimestamp>", "Unix timestamp after which the transaction is invalid").option("--args <args...>", ARGS_HELP, parseArg, []).action(async (options) => {
     const deployer = new DeployAction();
     if (options.contract) {
       await deployer.deploy(options);
@@ -54986,7 +55346,7 @@ function initializeContractsCommands(program2) {
     const callAction = new CallAction();
     await callAction.call({ contractAddress, method, ...options });
   });
-  program2.command("write <contractAddress> <method>").description("Sends a transaction to a contract method that modifies the state").option("--rpc <rpcUrl>", "RPC URL for the network").option(
+  program2.command("write <contractAddress> <method>").description("Sends a transaction to a contract method that modifies the state").option("--rpc <rpcUrl>", "RPC URL for the network").option("--fees <json>", FEES_HELP).option("--fee-value <wei>", "Fee deposit value to send with the transaction").option("--valid-until <unixTimestamp>", "Unix timestamp after which the transaction is invalid").option(
     "--args <args...>",
     ARGS_HELP,
     parseArg,
@@ -54995,6 +55355,15 @@ function initializeContractsCommands(program2) {
     const writeAction = new WriteAction();
     await writeAction.write({ contractAddress, method, ...options });
   });
+  program2.command("estimate-fees [contractAddress] [method]").description("Build a transaction fee preset, optionally from a Studio/localnet write simulation").option("--rpc <rpcUrl>", "RPC URL for the network").option("--fees <json>", FEE_ESTIMATE_HELP).option("--json", "Print the fee estimate as JSON without spinner output").option("--include-report", "Include simulation fee accounting/report in the generated estimate output").option(
+    "--args <args...>",
+    ARGS_HELP,
+    parseArg,
+    []
+  ).action(async (contractAddress, method, options) => {
+    const estimateFeesAction = new EstimateFeesAction();
+    await estimateFeesAction.estimate({ contractAddress, method, ...options });
+  });
   program2.command("schema <contractAddress>").description("Get the schema for a deployed contract").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (contractAddress, options) => {
     const schemaAction = new SchemaAction();
     await schemaAction.schema({ contractAddress, ...options });
@@ -55112,6 +55481,7 @@ var ValidatorsAction = class 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);
@@ -55125,13 +55495,13 @@ var ValidatorsAction = class extends BaseAction {
         params: [options.address]
       });
       this.log("Current Validator Details:", currentValidator.result);
-      const parsedStake = options.stake ? parseInt(options.stake, 10) : currentValidator.result.stake;
-      if (isNaN(parsedStake) || parsedStake < 0) {
+      const parsedStake = options.stake ? parseInt(options.stake, 10) : Number(currentValidator.result.stake);
+      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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.39.0",
+  "version": "0.39.2",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "type": "module",
@@ -14,8 +14,7 @@
     "test:smoke": "vitest run --config vitest.smoke.config.ts",
     "dev": "cross-env NODE_ENV=development node esbuild.config.js",
     "build": "cross-env NODE_ENV=production node esbuild.config.js",
-    "release": "release-it --ci",
-    "release-beta": "release-it --ci --preRelease=beta",
+    "release": "./scripts/release.sh",
     "postinstall": "node ./scripts/postinstall.js",
     "docs:cli": "node scripts/generate-cli-docs.mjs"
   },
@@ -67,7 +66,7 @@
     "dotenv": "^17.0.0",
     "ethers": "^6.13.4",
     "fs-extra": "^11.3.0",
-    "genlayer-js": "^1.0.0",
+    "genlayer-js": "^1.1.8",
     "inquirer": "^12.0.0",
     "keytar": "^7.9.0",
     "node-fetch": "^3.0.0",