feat: added support to serialize chunk transactions

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

Author: manishdait

src/hiero_sdk_python/consensus/topic_message_submit_transaction.py

@@ -6,9 +6,8 @@
 from hiero_sdk_python.channels import _Channel
 from hiero_sdk_python.client.client import Client
 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, timestamp_pb2, transaction_pb2
+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,
 )
@@ -49,11 +48,9 @@ def __init__(
         self.chunk_size: int = chunk_size or 1024
         self.max_chunks: int = max_chunks or 20
 
-        self._current_chunk_index = 0
         self._total_chunks = self.get_required_chunks()
         self._initial_transaction_id: TransactionId | None = None
-        self._transaction_ids: list[TransactionId] = []
-        self._signing_keys: list[PrivateKey] = []
+        self._chunk_info: consensus_submit_message_pb2.ConsensusMessageChunkInfo | None = None
 
     def get_required_chunks(self) -> int:
         """
@@ -190,25 +187,22 @@ def _build_proto_body(self) -> consensus_submit_message_pb2.ConsensusSubmitMessa
 
         content = self.message.encode("utf-8")
 
-        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._chunk_info is not None:
+            start_index = (self._chunk_info.number - 1) * self.chunk_size
+            end_index = min(start_index + self.chunk_size, len(content))
 
-        body = consensus_submit_message_pb2.ConsensusSubmitMessageTransactionBody(
-            topicID=self.topic_id._to_proto() if self.topic_id else None, message=chunk_content
-        )
+            chunk_content = content[start_index:end_index]
 
-        # 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=self._chunk_info,
             )
 
-        return body
+        return consensus_submit_message_pb2.ConsensusSubmitMessageTransactionBody(
+            topicID=self.topic_id._to_proto() if self.topic_id else None,
+            message=content,
+        )
 
     def build_transaction_body(self) -> transaction_pb2.TransactionBody:
         """
@@ -252,27 +246,33 @@ def freeze_with(self, client: Client) -> TopicMessageSubmitTransaction:
             return self
 
         self._resolve_transaction_id(client)
+        self._resolve_node_ids(client)
 
-        if not self._transaction_ids:
-            base_timestamp = self.transaction_id.valid_start
+        required_chunks = self.get_required_chunks()
+        self._generate_transaction_ids(self._transaction_ids[0], required_chunks)
 
-            for i in range(self.get_required_chunks()):
-                if i == 0:
-                    if self._initial_transaction_id is None:
-                        self._initial_transaction_id = self.transaction_id
+        self._initial_transaction_id = self._transaction_ids[0]
+
+        for chunk in range(self.get_required_chunks()):
+            self._current_transaction_id_index = chunk
+            self._chunk_info = consensus_submit_message_pb2.ConsensusMessageChunkInfo(
+                initialTransactionID=self._initial_transaction_id._to_proto(),
+                total=required_chunks,
+                number=chunk + 1,
+            )
 
-                    chunk_transaction_id = self.transaction_id
-                else:
-                    next_nanos = base_timestamp.nanos + i
+            node_bytes = {}
 
-                    chunk_valid_start = timestamp_pb2.Timestamp(
-                        seconds=base_timestamp.seconds + next_nanos // 1_000_000_000, nanos=next_nanos % 1_000_000_000
-                    )
-                    chunk_transaction_id = TransactionId(
-                        account_id=self.transaction_id.account_id, valid_start=chunk_valid_start
-                    )
+            for node_account_id in self.node_account_ids:
+                self._node_account_id = node_account_id
 
-                self._transaction_ids.append(chunk_transaction_id)
+                transaction_body = self.build_transaction_body()
+                transaction_body.transactionID.CopyFrom(self._transaction_ids[chunk]._to_proto())
+                transaction_body.nodeAccountID.CopyFrom(node_account_id._to_proto())
+
+                node_bytes[node_account_id] = transaction_body.SerializeToString()
+
+            self._transaction_body_bytes[self._transaction_ids[chunk]] = node_bytes
 
         return super().freeze_with(client)
 
@@ -363,47 +363,22 @@ def execute_all(
         """
         self._validate_chunking()
 
-        if self.get_required_chunks() == 1:
+        if not self._transaction_body_bytes:
+            self.freeze_with(client)
+
+        if len(self._transaction_ids) == 1:
             return [super().execute(client, timeout, wait_for_receipt, validate_status)]
 
         # Multi-chunk transaction - execute all chunks
         responses = []
-
-        for chunk_index in range(self.get_required_chunks()):
-            self._current_chunk_index = chunk_index
-
-            if self._transaction_ids and chunk_index < len(self._transaction_ids):
-                self.transaction_id = self._transaction_ids[chunk_index]
-
-            self._transaction_body_bytes.clear()
-            self._signature_map.clear()
-
-            self.freeze_with(client)
-
-            for signing_key in self._signing_keys:
-                super().sign(signing_key)
-
-            # Execute the chunk
+        self._current_transaction_id_index = 0
+        for index in range(len(self._transaction_ids)):
+            self._current_transaction_id_index = index
             response = super().execute(client, timeout, wait_for_receipt, validate_status)
             responses.append(response)
 
         return responses
 
-    def sign(self, private_key: PrivateKey):
-        """
-        Signs the transaction using the provided private key.
-
-        For multi-chunk transactions, this stores the signing key for later use.
-
-        Args:
-            private_key (PrivateKey): The private key to sign the transaction with.
-        """
-        if private_key not in self._signing_keys:
-            self._signing_keys.append(private_key)
-
-        super().sign(private_key)
-        return self
-
     @property
     def body_size_all_chunks(self) -> list[int]:
         """Returns an array of body sizes for transactions with multiple chunks."""
@@ -424,3 +399,17 @@ def body_size_all_chunks(self) -> list[int]:
             self.transaction_id = original_transaction_id
 
         return sizes
+
+    @classmethod
+    def _from_protobuf(cls, transaction_body):
+        transaction = super()._from_protobuf(transaction_body)
+
+        if transaction_body.HasField("consensusSubmitMessage"):
+            body = transaction_body.consensusSubmitMessage
+
+            if body.HasField("topicID"):
+                transaction.topic_id = TopicId._from_proto(body.topicID)
+            transaction.message = body.message.decode("utf-8") if body.message else None
+            transaction._total_chunks = transaction.get_required_chunks()
+
+        return transaction

src/hiero_sdk_python/file/file_append_transaction.py

@@ -17,20 +17,18 @@
 from typing import TYPE_CHECKING, Any, Literal, overload
 
 from hiero_sdk_python.file.file_id import FileId
-from hiero_sdk_python.hapi.services import file_append_pb2, timestamp_pb2
+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.transaction.transaction import Transaction
-from hiero_sdk_python.transaction.transaction_id import TransactionId
 
 
 # Use TYPE_CHECKING to avoid circular import errors
 if TYPE_CHECKING:
     from hiero_sdk_python.channels import _Channel
     from hiero_sdk_python.client.client import Client
-    from hiero_sdk_python.crypto.private_key import PrivateKey
     from hiero_sdk_python.executable import _Method
     from hiero_sdk_python.transaction.transaction import TransactionReceipt
     from hiero_sdk_python.transaction.transaction_response import TransactionResponse
@@ -76,10 +74,8 @@ def __init__(
         self._default_transaction_fee = Hbar(5).to_tinybars()
 
         # Internal tracking for chunking
-        self._current_chunk_index: int = 0
+        self._current_chunk_index: int | None = None
         self._total_chunks: int = self._calculate_total_chunks()
-        self._transaction_ids: list[TransactionId] = []
-        self._signing_keys: list[PrivateKey] = []  # Use string annotation to avoid import issues
 
     def _encode_contents(self, contents: str | bytes | None) -> bytes | None:
         """
@@ -190,15 +186,18 @@ 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:
+        contents = self.contents if self.contents is not None else b""
+
+        if self._current_chunk_index is not None:
             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]
+            end_index = min(start_index + self.chunk_size, len(contents))
 
+            chunk_contents = contents[start_index:end_index]
+            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:
@@ -287,28 +286,27 @@ def freeze_with(self, client: Client) -> FileAppendTransaction:
             return self
 
         self._resolve_transaction_id(client)
+        self._resolve_node_ids(client)
+
+        required_chunks = self.get_required_chunks()
+        self._generate_transaction_ids(self._transaction_ids[0], required_chunks)
 
-        # Generate transaction IDs for all chunks
-        if not self._transaction_ids:
-            base_timestamp = self.transaction_id.valid_start
+        for chunk in range(required_chunks):
+            self._current_chunk_index = chunk
+            self._current_transaction_id_index = chunk
 
-            for i in range(self.get_required_chunks()):
-                if i == 0:
-                    # First chunk uses the original transaction ID
-                    chunk_transaction_id = self.transaction_id
-                else:
-                    # Subsequent chunks get incremented timestamps
-                    # Add i nanoseconds to space out chunks
-                    next_nanos = base_timestamp.nanos + i
+            node_bytes = {}
 
-                    chunk_valid_start = timestamp_pb2.Timestamp(
-                        seconds=base_timestamp.seconds + next_nanos // 1_000_000_000, nanos=next_nanos % 1_000_000_000
-                    )
-                    chunk_transaction_id = TransactionId(
-                        account_id=self.transaction_id.account_id, valid_start=chunk_valid_start
-                    )
+            for node_account_id in self.node_account_ids:
+                self._node_account_id = node_account_id
 
-                self._transaction_ids.append(chunk_transaction_id)
+                transaction_body = self.build_transaction_body()
+                transaction_body.transactionID.CopyFrom(self._transaction_ids[chunk]._to_proto())
+                transaction_body.nodeAccountID.CopyFrom(node_account_id._to_proto())
+
+                node_bytes[node_account_id] = transaction_body.SerializeToString()
+
+            self._transaction_body_bytes[self._transaction_ids[chunk]] = node_bytes
 
         return super().freeze_with(client)
 
@@ -399,57 +397,23 @@ def execute_all(
         """
         self._validate_chunking()
 
-        if self.get_required_chunks() == 1:
-            # Single chunk transaction
+        if not self._transaction_body_bytes:
+            self.freeze_with(client)
+
+        # Single chunk transaction
+        if len(self._transaction_ids) == 1:
             return [super().execute(client, timeout, wait_for_receipt, validate_status)]
 
         # Multi-chunk transaction - execute all chunks
         responses = []
-
-        for chunk_index in range(self.get_required_chunks()):
-            self._current_chunk_index = chunk_index
-
-            # Set the transaction ID for this chunk
-            if self._transaction_ids and chunk_index < len(self._transaction_ids):
-                self.transaction_id = self._transaction_ids[chunk_index]
-            # Clear the frozen state to allow rebuilding with new transaction ID
-            self._transaction_body_bytes.clear()
-            self._signature_map.clear()
-
-            # Freeze the transaction for this chunk if not already frozen
-            self.freeze_with(client)
-
-            # Sign with all stored signing keys for this chunk
-            for signing_key in self._signing_keys:
-                # Call parent sign directly to avoid modifying _signing_keys
-                super().sign(signing_key)
-
-            # Execute the chunk
+        self._current_transaction_id_index = 0
+        for index in range(len(self._transaction_ids)):
+            self._current_transaction_id_index = index
             response = super().execute(client, timeout, wait_for_receipt, validate_status)
             responses.append(response)
 
         return responses
 
-    def sign(self, private_key: PrivateKey) -> FileAppendTransaction:
-        """
-        Signs the transaction using the provided private key.
-
-        For multi-chunk transactions, this stores the signing key for later use.
-
-        Args:
-            private_key (PrivateKey): The private key to sign the transaction with.
-
-        Returns:
-            FileAppendTransaction: The current transaction instance for method chaining.
-        """
-        # Store the signing key for multi-chunk transactions (avoid duplicates)
-        if private_key not in self._signing_keys:
-            self._signing_keys.append(private_key)
-
-        # Call the parent sign method for the current transaction
-        super().sign(private_key)
-        return self
-
     @property
     def body_size_all_chunks(self) -> list[int]:
         """Returns an array of body sizes for transactions with multiple chunks."""
@@ -470,3 +434,10 @@ def body_size_all_chunks(self) -> list[int]:
             self.transaction_id = original_transaction_id
 
         return sizes
+
+    @classmethod
+    def _from_protobuf(cls, transaction_body):
+        transaction = super()._from_protobuf(transaction_body)
+        if transaction_body.HasField("fileAppend"):
+            transaction._from_proto(transaction_body.fileAppend)
+        return transaction