genlayer 0.39.0 → 0.39.2

package/scripts/release.sh

@@ -0,0 +1,157 @@
+#!/usr/bin/env bash
+# Cut a release on the current stable branch.
+#
+# Bumps package.json, prepends CHANGELOG.md, commits, tags vX.Y.Z, and
+# pushes both the branch commit and the tag. publish.yml takes over from
+# the tag push (build → npm publish → GitHub Release).
+#
+# Releases are deliberate. There is no auto-bump on push; only this
+# script is supposed to create release tags. Run from the major branch
+# you want to ship a release on (e.g. v0.39 for v0.39.x).
+#
+# Usage:
+#   scripts/release.sh <X.Y.Z>     # explicit semver — recommended
+#   scripts/release.sh patch       # 0.39.1 → 0.39.2
+#   scripts/release.sh minor       # 0.39.1 → 0.40.0 — refused unless --allow-major
+#   scripts/release.sh major       # 0.39.1 → 1.0.0  — refused unless --allow-major
+#   scripts/release.sh --allow-major <X.Y.Z>
+#
+# Semver-zero rule: while the major is 0, the MINOR is the breaking-
+# change boundary (per semver). 0.39 → 0.40 IS a major bump. The script
+# refuses both `minor` and `major` keywords without --allow-major while
+# the current major is 0.
+#
+# Pre-flight (each check refuses to proceed on failure):
+#   - On a v<MAJOR>[.<MINOR>] branch (refuses on main / feature branches)
+#   - Working tree clean
+#   - Local HEAD matches origin/<branch>
+#   - Latest CI run on HEAD is green
+
+set -euo pipefail
+
+ALLOW_MAJOR=0
+if [ "${1:-}" = "--allow-major" ]; then
+  ALLOW_MAJOR=1
+  shift
+fi
+
+VERSION_ARG="${1:-}"
+if [ -z "$VERSION_ARG" ]; then
+  echo "Usage: $0 [--allow-major] <X.Y.Z>|patch|minor|major" >&2
+  exit 2
+fi
+
+repo_root="$(git rev-parse --show-toplevel)"
+cd "$repo_root"
+
+branch="$(git rev-parse --abbrev-ref HEAD)"
+if ! [[ "$branch" =~ ^v[0-9]+(\.[0-9]+)?(-dev)?$ ]]; then
+  cat >&2 <<EOF
+Refusing to release from '$branch'.
+
+Release branches in this repo are named after the major they ship
+(v0.39, v0.40, ...) or the next-major dev line (v0.40-dev). main has
+been retired — see CONTRIBUTING.md for the branch model.
+
+If you intended to ship a v0.39.x release, run:
+  git checkout v0.39 && git pull --ff-only && scripts/release.sh ...
+EOF
+  exit 1
+fi
+
+if [ -n "$(git status --porcelain)" ]; then
+  echo "Working tree not clean. Stash or commit first." >&2
+  exit 1
+fi
+
+git fetch --tags origin "$branch"
+local_sha="$(git rev-parse HEAD)"
+remote_sha="$(git rev-parse "origin/$branch")"
+if [ "$local_sha" != "$remote_sha" ]; then
+  cat >&2 <<EOF
+Local $branch ($local_sha) does not match origin/$branch ($remote_sha).
+Pull (or push) before releasing.
+EOF
+  exit 1
+fi
+
+if command -v gh >/dev/null 2>&1; then
+  status="$(gh run list --branch "$branch" --commit "$local_sha" --limit 1 --json conclusion --jq '.[0].conclusion' 2>/dev/null || echo "")"
+  case "$status" in
+    success) ;;
+    "" )
+      echo "Warning: no CI run found for $local_sha on $branch. Continuing anyway." >&2
+      ;;
+    *)
+      echo "Latest CI on $branch@$local_sha is '$status' (not success). Refusing to release a red commit." >&2
+      exit 1
+      ;;
+  esac
+fi
+
+current_version="$(node -p "require('./package.json').version")"
+
+case "$VERSION_ARG" in
+  major|minor|patch)
+    next_version="$(node -e "
+      const semver = require('semver');
+      const cur = require('./package.json').version;
+      const inc = '$VERSION_ARG';
+      const out = semver.inc(cur, inc);
+      if (!out) { console.error('semver.inc failed for', cur, inc); process.exit(1); }
+      console.log(out);
+    ")"
+    ;;
+  *)
+    next_version="$VERSION_ARG"
+    ;;
+esac
+
+if ! node -e "if (!require('semver').valid('$next_version')) process.exit(1)"; then
+  echo "Not a valid semver: $next_version" >&2
+  exit 2
+fi
+
+cur_major="${current_version%%.*}"
+next_major="${next_version%%.*}"
+cur_minor="$(node -p "require('semver').minor('$current_version')")"
+next_minor="$(node -p "require('semver').minor('$next_version')")"
+
+if [ "$cur_major" = "0" ]; then
+  if [ "$next_major" != "0" ] || [ "$next_minor" != "$cur_minor" ]; then
+    if [ "$ALLOW_MAJOR" -ne 1 ]; then
+      cat >&2 <<EOF
+Refusing $current_version → $next_version without --allow-major.
+
+This package is still on a 0.x line, so the MINOR component is the
+breaking-change boundary (per semver). 0.$cur_minor → 0.$next_minor
+counts as a major bump and should land on a new branch (v0.$next_minor)
+following the model in CONTRIBUTING.md.
+
+If you actually want this on the current branch, pass --allow-major.
+EOF
+      exit 1
+    fi
+  fi
+elif [ "$next_major" != "$cur_major" ] && [ "$ALLOW_MAJOR" -ne 1 ]; then
+  cat >&2 <<EOF
+Refusing major bump $current_version → $next_version without --allow-major.
+
+In this repo's release model, a major bump means cutting a new branch
+(v$next_major). Don't tag a major on top of the v$cur_major branch.
+EOF
+  exit 1
+fi
+
+echo "Releasing v$next_version on $branch (was v$current_version)."
+
+# release-it bumps + CHANGELOG + commit + tag + push in one shot.
+# --no-npm.publish keeps npm out of the dev machine; --no-github.release
+# defers the GH release to publish.yml on the tag arrival.
+npx release-it "$next_version" --ci \
+  --no-npm.publish \
+  --no-github.release
+
+echo
+echo "Pushed v$next_version. publish.yml will fire on the tag and ship to npm."
+echo "Track it at: https://github.com/genlayerlabs/genlayer-cli/actions"

package/src/commands/contracts/deploy.ts

@@ -4,8 +4,9 @@ import {BaseAction} from "../../lib/actions/BaseAction";
 import {pathToFileURL} from "url";
 import {TransactionStatus} from "genlayer-js/types";
 import {buildSync} from "esbuild";
+import {ContractFeeCliOptions, parseTransactionFees, parseValidUntil} from "./fees";
 
-export interface DeployOptions {
+export interface DeployOptions extends ContractFeeCliOptions {
   contract?: string;
   args?: any[];
   rpc?: string;
@@ -131,6 +132,10 @@ export class DeployAction extends BaseAction {
 
       const leaderOnly = false;
       const deployParams: any = {code: contractCode, args: options.args, leaderOnly};
+      const fees = parseTransactionFees(options);
+      const validUntil = parseValidUntil(options);
+      if (fees) deployParams.fees = fees;
+      if (validUntil !== undefined) deployParams.validUntil = validUntil;
 
       this.setSpinnerText("Starting contract deployment...");
       this.log("Deployment Parameters:", deployParams);

package/src/commands/contracts/estimateFees.ts

@@ -0,0 +1,133 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+import {ContractFeeCliOptions, parseFeeEstimateOptions} from "./fees";
+
+export interface EstimateFeesOptions extends Pick<ContractFeeCliOptions, "fees"> {
+  args?: any[];
+  rpc?: string;
+  json?: boolean;
+  includeReport?: boolean;
+}
+
+const toTransactionFees = (estimate: Record<string, any>): Record<string, any> => ({
+  distribution: estimate.distribution,
+  ...(estimate.messageAllocations ? {messageAllocations: estimate.messageAllocations} : {}),
+  feeValue: estimate.feeValue ?? estimate.fee_value,
+});
+
+const toJsonSafe = (value: any): any => {
+  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 !== undefined)
+        .map(([key, item]) => [key, toJsonSafe(item)]),
+    );
+  }
+  return value;
+};
+
+const simulationFeeReport = (simulation: Record<string, any>): Record<string, any> | undefined => (
+  simulation.feeReport ?? simulation.feeAccounting?.execution_fee_report
+);
+
+const withSimulationReport = (estimate: unknown, simulation: unknown): unknown => {
+  if (!simulation || typeof simulation !== "object" || Array.isArray(simulation)) {
+    return estimate;
+  }
+
+  const simulationRecord = simulation as Record<string, any>;
+  return {
+    ...(estimate && typeof estimate === "object" && !Array.isArray(estimate)
+      ? estimate as Record<string, any>
+      : {estimate}),
+    simulation: {
+      feeAccounting: simulationRecord.feeAccounting,
+      feeReport: simulationFeeReport(simulationRecord),
+    },
+  };
+};
+
+export class EstimateFeesAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async estimate({
+    contractAddress,
+    method,
+    args,
+    rpc,
+    fees,
+    json,
+    includeReport,
+  }: EstimateFeesOptions & {
+    contractAddress?: string;
+    method?: string;
+  }): Promise<void> {
+    try {
+      const client = await this.getClient(rpc, true);
+      await client.initializeConsensusSmartContract();
+      const estimateOptions = parseFeeEstimateOptions({fees});
+
+      if (!json) this.startSpinner("Estimating transaction fees...");
+      let estimate: unknown;
+
+      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 as any,
+            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 as any,
+            functionName: method,
+            args: args ?? [],
+            includeReceipt: true,
+            fees: toTransactionFees(initialEstimate as Record<string, any>),
+          });
+          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);
+    }
+  }
+}

package/src/commands/contracts/fees.ts

@@ -0,0 +1,236 @@
+import {hexToBytes, keccak256, toHex, type Hex} from "viem";
+
+export interface ContractFeeCliOptions {
+  fees?: string;
+  feeValue?: string;
+  validUntil?: string;
+}
+
+const parseJsonObject = (value: string, optionName: string): Record<string, any> => {
+  let parsed: unknown;
+  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 as Record<string, any>;
+};
+
+const assertSafeJsonNumbers = (value: unknown, path: string): void => {
+  if (typeof value === "number" && !Number.isSafeInteger(value)) {
+    throw new Error(`${path} contains an unsafe number. Quote large integer values as strings.`);
+  }
+
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertSafeJsonNumbers(item, `${path}[${index}]`));
+    return;
+  }
+
+  if (value && typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) {
+      assertSafeJsonNumbers(item, `${path}.${key}`);
+    }
+  }
+};
+
+const parseBigNumberishOption = (value: string | undefined, optionName: string): string | undefined => {
+  if (value === undefined) return undefined;
+  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;
+};
+
+const CALL_KEY_UNNAMED = "0x0000000000000000000000000000000000000000000000000000000000000000" as const;
+
+const bytesToPaddedCallKey = (bytes: Uint8Array): Hex => {
+  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")}` as Hex;
+};
+
+const deriveInternalMessageCallKey = (methodName = ""): Hex => {
+  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")}` as Hex;
+};
+
+const deriveExternalMessageCallKey = (selectorOrCalldata: Hex): Hex => {
+  const bytes = hexToBytes(selectorOrCalldata);
+  if (bytes.length < 4) {
+    return CALL_KEY_UNNAMED;
+  }
+  return bytesToPaddedCallKey(bytes.slice(0, 4));
+};
+
+const normalizeMessageType = (messageType: unknown, index: number): 0 | 1 | undefined => {
+  if (messageType === undefined) {
+    return undefined;
+  }
+
+  if (typeof messageType === "number") {
+    if (messageType === 0 || messageType === 1) {
+      return messageType;
+    }
+    throw new Error(`--fees.messageAllocations[${index}].messageType must be "internal", "external", 0, or 1.`);
+  }
+
+  if (typeof messageType !== "string") {
+    return undefined;
+  }
+
+  const normalized = messageType.toLowerCase();
+  if (normalized === "internal") {
+    return 1;
+  }
+  if (normalized === "external") {
+    return 0;
+  }
+  throw new Error(`--fees.messageAllocations[${index}].messageType must be "internal" or "external".`);
+};
+
+const readStringField = (allocation: Record<string, any>, field: string, index: number): string => {
+  const value = allocation[field];
+  if (typeof value !== "string") {
+    throw new Error(`--fees.messageAllocations[${index}].${field} must be a string.`);
+  }
+  return value;
+};
+
+const assertFourByteSelector = (selector: string, field: string, index: number): void => {
+  if (!/^0x[0-9a-fA-F]{8}$/.test(selector)) {
+    throw new Error(`--fees.messageAllocations[${index}].${field} must be a 4-byte hex selector.`);
+  }
+};
+
+const assertHexBytes = (hex: string, field: string, index: number): void => {
+  if (!/^0x([0-9a-fA-F]{2})*$/.test(hex)) {
+    throw new Error(`--fees.messageAllocations[${index}].${field} must be even-length hex bytes.`);
+  }
+};
+
+const normalizeMessageAllocationCallKey = (
+  allocation: Record<string, any>,
+  messageType: 0 | 1 | undefined,
+  index: number,
+): Record<string, any> => {
+  const helperFields = [
+    "callKeyMethod",
+    "callKeySelector",
+    "callKeyCalldata",
+    "functionSelector",
+  ].filter((field) => allocation[field] !== undefined);
+
+  if (allocation.callKey !== undefined && helperFields.length > 0) {
+    throw new Error(`--fees.messageAllocations[${index}] cannot combine callKey with call-key helper fields.`);
+  }
+  if (helperFields.length > 1) {
+    throw new Error(`--fees.messageAllocations[${index}] 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[${index}].callKeyMethod requires an internal message allocation.`);
+    }
+    normalized.messageType = messageType ?? 1;
+    normalized.callKey = deriveInternalMessageCallKey(readStringField(allocation, helperField, index));
+    return normalized;
+  }
+
+  if (messageType === 1) {
+    throw new Error(`--fees.messageAllocations[${index}].${helperField} requires an external message allocation.`);
+  }
+
+  const selectorOrCalldata = readStringField(allocation, helperField, index);
+  if (helperField === "callKeySelector" || helperField === "functionSelector") {
+    assertFourByteSelector(selectorOrCalldata, helperField, index);
+  } else {
+    assertHexBytes(selectorOrCalldata, helperField, index);
+  }
+  normalized.messageType = messageType ?? 0;
+  normalized.callKey = deriveExternalMessageCallKey(selectorOrCalldata as `0x${string}`);
+  return normalized;
+};
+
+const normalizeMessageTypes = (fees: Record<string, any>): Record<string, any> => {
+  if (!Array.isArray(fees.messageAllocations)) {
+    return fees;
+  }
+
+  return {
+    ...fees,
+    messageAllocations: fees.messageAllocations.map((allocation: any, index: number) => {
+      if (!allocation || typeof allocation !== "object" || Array.isArray(allocation)) {
+        throw new Error(`--fees.messageAllocations[${index}] must be an object.`);
+      }
+
+      const messageType = normalizeMessageType(allocation.messageType, index);
+      return normalizeMessageAllocationCallKey({
+        ...allocation,
+        ...(messageType === undefined ? {} : {messageType}),
+      }, messageType, index);
+    }),
+  };
+};
+
+export const parseTransactionFees = (options: ContractFeeCliOptions): Record<string, any> | undefined => {
+  const feeValue = parseBigNumberishOption(options.feeValue, "--fee-value");
+  let fees = options.fees ? parseJsonObject(options.fees, "--fees") : undefined;
+
+  if (!fees && feeValue === undefined) {
+    return undefined;
+  }
+
+  fees = normalizeMessageTypes(fees ?? {});
+  if (feeValue !== undefined) {
+    fees.feeValue = feeValue;
+  }
+  return fees;
+};
+
+export const parseFeeEstimateOptions = (options: Pick<ContractFeeCliOptions, "fees">): Record<string, any> | undefined => {
+  if (!options.fees) {
+    return undefined;
+  }
+
+  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 !== undefined ? {messageAllocations} : {}),
+      ...rest,
+    };
+  }
+  return parsed;
+};
+
+export const parseValidUntil = (options: ContractFeeCliOptions): string | undefined => {
+  return parseBigNumberishOption(options.validUntil, "--valid-until");
+};

package/src/commands/contracts/index.ts

@@ -5,6 +5,7 @@ import {CallAction, CallOptions} from "./call";
 import {WriteAction, WriteOptions} from "./write";
 import {SchemaAction, SchemaOptions} from "./schema";
 import {CodeAction, CodeOptions} from "./code";
+import {EstimateFeesAction, EstimateFeesOptions} from "./estimateFees";
 
 const ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
 const ADDR_PREFIX_RE = /^addr#([0-9a-fA-F]{40})$/;
@@ -81,12 +82,33 @@ const ARGS_HELP = [
   '  dict: \'{"key": "value"}\'',
 ].join("\n");
 
+const 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");
+
+const 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");
+
 export function initializeContractsCommands(program: Command) {
   program
     .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: DeployOptions) => {
       const deployer = new DeployAction();
@@ -117,6 +139,9 @@ export function initializeContractsCommands(program: Command) {
     .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,
@@ -128,6 +153,24 @@ export function initializeContractsCommands(program: Command) {
       await writeAction.write({contractAddress, method, ...options});
     });
 
+  program
+    .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: string | undefined, method: string | undefined, options: EstimateFeesOptions) => {
+      const estimateFeesAction = new EstimateFeesAction();
+      await estimateFeesAction.estimate({contractAddress, method, ...options});
+    });
+
   program
     .command("schema <contractAddress>")
     .description("Get the schema for a deployed contract")

package/src/commands/contracts/write.ts

@@ -1,8 +1,9 @@
 // import {simulator} from "genlayer-js/chains";
 // import type {GenLayerClient} from "genlayer-js/types";
 import {BaseAction} from "../../lib/actions/BaseAction";
+import {ContractFeeCliOptions, parseTransactionFees, parseValidUntil} from "./fees";
 
-export interface WriteOptions {
+export interface WriteOptions extends ContractFeeCliOptions {
   args: any[];
   rpc?: string;
 }
@@ -17,23 +18,35 @@ export class WriteAction extends BaseAction {
     method,
     args,
     rpc,
+    fees,
+    feeValue,
+    validUntil,
   }: {
     contractAddress: string;
     method: string;
     args: any[];
     rpc?: string;
+    fees?: string;
+    feeValue?: string;
+    validUntil?: string;
   }): Promise<void> {
     const client = await this.getClient(rpc);
     await client.initializeConsensusSmartContract();
     this.startSpinner(`Calling write method ${method} on contract at ${contractAddress}...`);
 
     try {
-      const hash = await client.writeContract({
+      const writeParams: any = {
         address: contractAddress as any,
         functionName: method,
         args,
         value: 0n,
-      });
+      };
+      const parsedFees = parseTransactionFees({fees, feeValue, validUntil});
+      const parsedValidUntil = parseValidUntil({fees, feeValue, validUntil});
+      if (parsedFees) writeParams.fees = parsedFees;
+      if (parsedValidUntil !== undefined) writeParams.validUntil = parsedValidUntil;
+
+      const hash = await client.writeContract(writeParams);
       this.log("Write Transaction Hash:", hash);
 
       const result = await client.waitForTransactionReceipt({