@hiero-ledger/sdk 2.73.2 → 2.75.0

package/src/transaction/Transaction.js

@@ -1291,6 +1291,65 @@ export default class Transaction extends Executable {
         );
     }
 
+    /**
+     * Apply maxNodesPerTransaction limit to an already frozen transaction.
+     * This trims the node list to the first N nodes while preserving existing signatures.
+     *
+     * Note: This method assumes the caller has already verified that trimming is needed.
+     *
+     * @private
+     * @param {import("../client/Client.js").default<Channel, *>} client
+     */
+    _applyMaxNodesPerTransactionLimit(client) {
+        const maxNodes = client.maxNodesPerTransaction;
+
+        if (maxNodes <= 0 || this._nodeAccountIds.length <= maxNodes) {
+            return;
+        }
+
+        if (this._logger) {
+            this._logger.debug(
+                `Trimming frozen transaction from ${this._nodeAccountIds.length} nodes to ${maxNodes} nodes based on maxNodesPerTransaction setting`,
+            );
+        }
+
+        // Trim the node account IDs to the first N nodes
+        const trimmedNodeIds = this._nodeAccountIds.list.slice(0, maxNodes);
+
+        // Trim the signed transactions to match the trimmed node list
+        // Each chunk has transactions for all nodes, so we need to trim each chunk
+        const nodeCount = this._nodeAccountIds.length;
+        const chunkCount = this._transactionIds.length;
+        const trimmedSignedTransactions = [];
+
+        for (let chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++) {
+            const chunkStart = chunkIndex * nodeCount;
+
+            // Add the first maxNodes transactions from this chunk
+            for (let nodeIndex = 0; nodeIndex < maxNodes; nodeIndex++) {
+                const transactionIndex = chunkStart + nodeIndex;
+                if (transactionIndex < this._signedTransactions.length) {
+                    trimmedSignedTransactions.push(
+                        this._signedTransactions.get(transactionIndex),
+                    );
+                }
+            }
+        }
+
+        // Clear and rebuild the transactions list since it's derived from signed transactions
+        this._transactions.clear();
+
+        // Update the node account IDs (we need to unlock, update, and relock)
+        this._nodeAccountIds.locked = false;
+
+        this._nodeAccountIds.setList(trimmedNodeIds);
+
+        this._nodeAccountIds.locked = true;
+
+        // Update the signed transactions
+        this._signedTransactions.setList(trimmedSignedTransactions);
+    }
+
     /**
      * @description Set the key that will sign the batch of which this Transaction is a part of.
      * @param {Key} batchKey
@@ -1667,6 +1726,10 @@ export default class Transaction extends Executable {
             this.freezeWith(client);
         }
 
+        // Apply maxNodesPerTransaction limit to already frozen transaction
+        // This allows changing the node count even after freezing while preserving signatures
+        this._applyMaxNodesPerTransactionLimit(client);
+
         // Valid checksums if the option is enabled
         if (client.isAutoValidateChecksumsEnabled()) {
             this._validateChecksums(client);

package/src/util.js

@@ -291,6 +291,32 @@ export function convertToBigNumber(variable) {
     throw new Error(FUNCTION_CONVERT_TO_BIGNUMBER_ERROR);
 }
 
+/**
+ * Converts amount (number, Long, BigNumber, or bigint) to Long.
+ * This utility ensures consistent amount handling across the SDK.
+ *
+ * @param {number | Long | BigNumber | bigint} amount
+ * @returns {Long}
+ */
+export function convertAmountToLong(amount) {
+    requireNonNull(amount);
+
+    // Preserve exact original behavior for existing types
+    if (Long.isLong(amount)) {
+        return amount;
+    } else if (typeof amount === "number") {
+        return Long.fromNumber(amount);
+    } else if (BigNumber.isBigNumber(amount)) {
+        return Long.fromValue(
+            amount.integerValue(BigNumber.ROUND_DOWN).toString(),
+        );
+    } else if (typeof amount === "bigint") {
+        return Long.fromValue(amount.toString());
+    } else {
+        // Handle other types that can be converted to string
+        return Long.fromValue(String(amount));
+    }
+}
 /**
  * Converts Array of Numbers or Strings to Array of BigNumbers.
  *