fix: ChunkTransaction create all transaction_bytes when freeze (#2506)

Signed-off-by: Manish Dait <daitmanish88@gmail.com>

Author: manishdait

src/hiero_sdk_python/consensus/topic_message_submit_transaction.py

@@ -4,12 +4,12 @@
 
 from hiero_sdk_python.channels import _Channel
 from hiero_sdk_python.consensus.topic_id import TopicId
-from hiero_sdk_python.crypto.private_key import PrivateKey
 from hiero_sdk_python.executable import _Method
 from hiero_sdk_python.hapi.services import consensus_submit_message_pb2, transaction_pb2
 from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import (
     SchedulableTransactionBody,
 )
+from hiero_sdk_python.schedule.schedule_create_transaction import ScheduleCreateTransaction
 from hiero_sdk_python.transaction.chunked_transaction import ChunkedTransaction
 from hiero_sdk_python.transaction.custom_fee_limit import CustomFeeLimit
 
@@ -107,33 +107,6 @@ def set_message(self, message: bytes | str) -> TopicMessageSubmitTransaction:
         self._total_chunks = self.get_required_chunks()
         return self
 
-    def set_chunk_size(self, chunk_size: int) -> TopicMessageSubmitTransaction:
-        """
-        Set maximum chunk size in bytes.
-
-        Args:
-            chunk_size (int): The size of each chunk in bytes.
-
-        Returns:
-            TopicMessageSubmitTransaction: This transaction instance (for chaining).
-        """
-        super().set_chunk_size(chunk_size)
-        self._total_chunks = self.get_required_chunks()
-        return self
-
-    def set_max_chunks(self, max_chunks: int) -> TopicMessageSubmitTransaction:
-        """
-        Set maximum allowed chunks.
-
-        Args:
-            max_chunks (int): The maximum number of chunks allowed.
-
-        Returns:
-            TopicMessageSubmitTransaction: This transaction instance (for chaining).
-        """
-        super().set_max_chunks(max_chunks)
-        return self
-
     def set_custom_fee_limits(self, custom_fee_limits: list[CustomFeeLimit]) -> TopicMessageSubmitTransaction:
         """
         Sets the maximum custom fees that the user is willing to pay for the message.
@@ -186,27 +159,26 @@ def _build_proto_body(self) -> consensus_submit_message_pb2.ConsensusSubmitMessa
         if not self.message:
             raise ValueError("Missing required fields: message.")
 
-        content = self._message_as_bytes()
+        contents = self._message_as_bytes()
 
-        start_index = self._current_chunk_index * self.chunk_size
-        end_index = min(start_index + self.chunk_size, len(content))
-        chunk_content = content[start_index:end_index]
+        if self._total_chunks > 1 and self._current_chunk_index is not None:
+            chunk_info = consensus_submit_message_pb2.ConsensusMessageChunkInfo(
+                initialTransactionID=self._initial_transaction_id._to_proto(),
+                total=self._total_chunks,
+                number=self._current_chunk_index + 1,
+            )
 
-        body = consensus_submit_message_pb2.ConsensusSubmitMessageTransactionBody(
-            topicID=self.topic_id._to_proto() if self.topic_id else None, message=chunk_content
-        )
+            chunk_content = self._current_chunk_slice(contents)
 
-        # Multi-chunk metadata
-        if self._total_chunks > 1:
-            body.chunkInfo.CopyFrom(
-                consensus_submit_message_pb2.ConsensusMessageChunkInfo(
-                    initialTransactionID=self._initial_transaction_id._to_proto(),
-                    total=self._total_chunks,
-                    number=self._current_chunk_index + 1,
-                )
+            return consensus_submit_message_pb2.ConsensusSubmitMessageTransactionBody(
+                topicID=self.topic_id._to_proto() if self.topic_id else None,
+                message=chunk_content,
+                chunkInfo=chunk_info,
             )
 
-        return body
+        return consensus_submit_message_pb2.ConsensusSubmitMessageTransactionBody(
+            topicID=self.topic_id._to_proto() if self.topic_id else None, message=contents
+        )
 
     def build_transaction_body(self) -> transaction_pb2.TransactionBody:
         """
@@ -220,6 +192,18 @@ def build_transaction_body(self) -> transaction_pb2.TransactionBody:
         transaction_body.consensusSubmitMessage.CopyFrom(consensus_submit_message_body)
         return transaction_body
 
+    def schedule(self) -> ScheduleCreateTransaction:
+        """
+        Converts this transaction into a scheduled transaction.
+        """
+        if self.message is not None and len(self._message_as_bytes()) > self.chunk_size:
+            raise RuntimeError(
+                f"Cannot schedule TopicMessageSubmitTransaction because the message exceeds "
+                f"the maximum chunk size of {self.chunk_size} bytes"
+            )
+
+        return super().schedule()
+
     def build_scheduled_body(self) -> SchedulableTransactionBody:
         """
         Builds the scheduled transaction body for this topic message submit transaction.
@@ -243,16 +227,3 @@ def _get_method(self, channel: _Channel) -> _Method:
             _Method: The method object with bound transaction execution.
         """
         return _Method(transaction_func=channel.topic.submitMessage, query_func=None)
-
-    def sign(self, private_key: PrivateKey) -> TopicMessageSubmitTransaction:
-        """
-        Signs the transaction using the provided private key.
-
-        Args:
-            private_key (PrivateKey): The private key to sign the transaction with.
-
-        Returns:
-            TopicMessageSubmitTransaction: This transaction instance (for chaining).
-        """
-        super().sign(private_key)
-        return self

src/hiero_sdk_python/file/file_append_transaction.py

@@ -20,6 +20,7 @@
 from hiero_sdk_python.hapi.services import file_append_pb2
 from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import SchedulableTransactionBody
 from hiero_sdk_python.hbar import Hbar
+from hiero_sdk_python.schedule.schedule_create_transaction import ScheduleCreateTransaction
 from hiero_sdk_python.transaction.chunked_transaction import ChunkedTransaction
 
 
@@ -129,32 +130,6 @@ def set_contents(self, contents: str | bytes | None) -> FileAppendTransaction:
         self._total_chunks = self._calculate_total_chunks()
         return self
 
-    def set_max_chunks(self, max_chunks: int) -> FileAppendTransaction:
-        """
-        Sets the maximum number of chunks allowed for this transaction.
-
-        Args:
-            max_chunks (int): The maximum number of chunks allowed.
-
-        Returns:
-            FileAppendTransaction: This transaction instance.
-        """
-        super().set_max_chunks(max_chunks)
-        return self
-
-    def set_chunk_size(self, chunk_size: int) -> FileAppendTransaction:
-        """
-        Sets the chunk size for this transaction.
-
-        Args:
-            chunk_size (int): The size of each chunk in bytes.
-
-        Returns:
-            FileAppendTransaction: This transaction instance.
-        """
-        super().set_chunk_size(chunk_size)
-        return self
-
     def _build_proto_body(self) -> file_append_pb2.FileAppendTransactionBody:
         """
         Returns the protobuf body for the file append transaction.
@@ -169,15 +144,16 @@ def _build_proto_body(self) -> file_append_pb2.FileAppendTransactionBody:
         if self.file_id is None:
             raise ValueError("Missing required FileID")
 
-        if self.contents is None:
-            chunk_contents = b""
-        else:
-            start_index = self._current_chunk_index * self.chunk_size
-            end_index = min(start_index + self.chunk_size, len(self.contents))
-            chunk_contents = self.contents[start_index:end_index]
+        contents = self.contents if self.contents is not None else b""
+
+        if self._current_chunk_index is not None:
+            chunk_contents = self._current_chunk_slice(contents)
+            return file_append_pb2.FileAppendTransactionBody(
+                fileID=self.file_id._to_proto() if self.file_id else None, contents=chunk_contents
+            )
 
         return file_append_pb2.FileAppendTransactionBody(
-            fileID=self.file_id._to_proto() if self.file_id else None, contents=chunk_contents
+            fileID=self.file_id._to_proto() if self.file_id else None, contents=contents
         )
 
     def build_transaction_body(self) -> Any:
@@ -192,6 +168,18 @@ def build_transaction_body(self) -> Any:
         transaction_body.fileAppend.CopyFrom(file_append_body)
         return transaction_body
 
+    def schedule(self) -> ScheduleCreateTransaction:
+        """
+        Converts this transaction into a scheduled transaction.
+        """
+        if self.contents is not None and len(self.contents) > self.chunk_size:
+            raise RuntimeError(
+                f"Cannot schedule FileAppendTransaction because the contents exceeds "
+                f"the maximum chunk size of {self.chunk_size} bytes"
+            )
+
+        return super().schedule()
+
     def build_scheduled_body(self) -> SchedulableTransactionBody:
         """
         Builds the scheduled transaction body for this file append transaction.

src/hiero_sdk_python/lockable_list.py

@@ -19,7 +19,7 @@ def __init__(self):
     def _require_not_locked(self) -> None:
         """Raise an exception if the list is locked."""
         if self._locked:
-            raise RuntimeError("list is unmutable")
+            raise RuntimeError("list is immutable")
 
     def set_list(self, items: list[T]) -> _LockableList[T]:
         """Replace the contents of the list and reset the current index."""

src/hiero_sdk_python/query/fee_estimate_query.py

@@ -137,7 +137,7 @@ def execute(self, client) -> FeeEstimateResponse:
         self._ensure_frozen(self._transaction, client)
 
         if self._is_chunked():
-            return self._execute_chunked(client, url, mode)
+            return self._execute_chunked(url, mode)
 
         return self._execute_single(url, mode)
 
@@ -154,7 +154,7 @@ def _build_url(self, client: Client, mode: FeeEstimateMode) -> str:
     def _ensure_frozen(self, tx: Transaction, client) -> None:
         """Ensure the transaction is frozen before serialization."""
         if not tx._transaction_body_bytes:
-            tx.freeze_with(client) if hasattr(tx, "freeze_with") else tx.freeze()
+            tx.freeze_with(client)
 
     def _post(self, url: str, payload: bytes) -> dict:
         """POST with retry for transient failures."""
@@ -191,20 +191,13 @@ def _post(self, url: str, payload: bytes) -> dict:
         raise RuntimeError("Unreachable")
 
     def _execute_single(self, url: str, mode: FeeEstimateMode) -> FeeEstimateResponse:
-        data = self._post(url, self._transaction.to_bytes())
+        data = self._post(url, self._transaction._to_proto().SerializeToString())
         return self._to_response(data, mode)
 
-    def _execute_chunked(self, client, url: str, mode: FeeEstimateMode) -> FeeEstimateResponse:
+    def _execute_chunked(self, url: str, mode: FeeEstimateMode) -> FeeEstimateResponse:
         """
         Aggregate fees across all chunks into a single response.
         """
-
-        # Save original state to restore later
-        original_id = self._transaction.transaction_id
-        original_index = getattr(self._transaction, "_current_chunk_index", 0)
-        original_bodies = dict(self._transaction._transaction_body_bytes)
-        original_signatures = dict(self._transaction._signature_map)
-
         total_node_base = 0
         total_service_base = 0
         total_network_subtotal = 0
@@ -216,15 +209,9 @@ def _execute_chunked(self, client, url: str, mode: FeeEstimateMode) -> FeeEstima
         final_hvm = 0
 
         try:
-            for i, chunk_tx_id in enumerate(self._transaction._transaction_ids):
-                self._transaction._current_chunk_index = i
-                self._transaction.transaction_id = chunk_tx_id
-
-                self._transaction._transaction_body_bytes.clear()
+            for _ in range(self._transaction.get_required_chunks()):
+                tx_bytes = self._transaction._to_proto().SerializeToString()
 
-                self._transaction.freeze_with(client)
-
-                tx_bytes = self._transaction.to_bytes()
                 data = self._post(url, tx_bytes)
                 response = self._to_response(data, mode)
 
@@ -241,13 +228,10 @@ def _execute_chunked(self, client, url: str, mode: FeeEstimateMode) -> FeeEstima
 
                 final_hvm = response.high_volume_multiplier
 
+                self._transaction._transaction_ids.advance()
+
         finally:
-            self._transaction.transaction_id = original_id
-            self._transaction._current_chunk_index = original_index
-            self._transaction._transaction_body_bytes.clear()
-            self._transaction._transaction_body_bytes.update(original_bodies)
-            self._transaction._signature_map.clear()
-            self._transaction._signature_map.update(original_signatures)
+            self._transaction._transaction_ids.set_index(0)
 
         return FeeEstimateResponse(
             mode=mode,