chore: refactor the to_bytes/from_bytes method

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

Author: manishdait

src/hiero_sdk_python/account/account_create_transaction.py

@@ -371,3 +371,35 @@ def _get_method(self, channel: _Channel) -> _Method:
             _Method: An instance of _Method containing the transaction and query functions.
         """
         return _Method(transaction_func=channel.crypto.createAccount, query_func=None)
+
+    @classmethod
+    def _from_protobuf(cls, transaction_body):
+        """Create account create transaction from protobuf message."""
+        transaction = super()._from_protobuf(transaction_body)
+
+        if transaction_body.HasField("cryptoCreateAccount"):
+            body = transaction_body.cryptoCreateAccount
+
+            if body.HasField("key"):
+                transaction.key = Key.from_proto_key(body.key)
+
+            transaction.initial_balance = body.initialBalance
+            transaction.receiver_signature_required = body.receiverSigRequired
+            transaction.auto_renew_period = None
+
+            if body.HasField("autoRenewPeriod"):
+                transaction.auto_renew_period = Duration._from_proto(body.autoRenewPeriod)
+
+            transaction.account_memo = body.memo if body.memo else None
+            transaction.max_automatic_token_associations = body.max_automatic_token_associations
+            transaction.alias = EvmAddress.from_bytes(body.alias) if body.alias else None
+            transaction.decline_staking_reward = body.decline_reward
+            staked_id = body.WhichOneof("staked_id")
+
+            if staked_id == "staked_account_id":
+                transaction.staked_account_id = AccountId._from_proto(body.staked_account_id)
+
+            elif staked_id == "staked_node_id":
+                transaction.staked_node_id = body.staked_node_id
+
+        return transaction

src/hiero_sdk_python/nodes/node_create_transaction.py

@@ -301,8 +301,8 @@ def _get_method(self, channel: _Channel) -> _Method:
         return _Method(transaction_func=channel.address_book.createNode, query_func=None)
 
     @classmethod
-    def _from_protobuf(cls, transaction_body, body_bytes: bytes, sig_map):
-        transaction = super()._from_protobuf(transaction_body, body_bytes, sig_map)
+    def _from_protobuf(cls, transaction_body):
+        transaction = super()._from_protobuf(transaction_body)
 
         if transaction_body.HasField("nodeCreate"):
             pb = transaction_body.nodeCreate

src/hiero_sdk_python/nodes/node_update_transaction.py

@@ -360,8 +360,8 @@ def _get_method(self, channel: _Channel) -> _Method:
         return _Method(transaction_func=channel.address_book.updateNode, query_func=None)
 
     @classmethod
-    def _from_protobuf(cls, transaction_body, body_bytes: bytes, sig_map):
-        transaction = super()._from_protobuf(transaction_body, body_bytes, sig_map)
+    def _from_protobuf(cls, transaction_body):
+        transaction = super()._from_protobuf(transaction_body)
 
         if transaction_body.HasField("nodeUpdate"):
             pb = transaction_body.nodeUpdate

src/hiero_sdk_python/nodes/registered_node_create_transaction.py

@@ -100,8 +100,8 @@ def _get_method(self, channel: _Channel) -> _Method:
         return _Method(transaction_func=channel.address_book.createRegisteredNode, query_func=None)
 
     @classmethod
-    def _from_protobuf(cls, transaction_body, body_bytes: bytes, sig_map):
-        transaction = super()._from_protobuf(transaction_body, body_bytes, sig_map)
+    def _from_protobuf(cls, transaction_body):
+        transaction = super()._from_protobuf(transaction_body)
 
         if transaction_body.HasField("registeredNodeCreate"):
             pb = transaction_body.registeredNodeCreate

src/hiero_sdk_python/nodes/registered_node_delete_transaction.py

@@ -62,8 +62,8 @@ def _get_method(self, channel: _Channel) -> _Method:
         return _Method(transaction_func=channel.address_book.deleteRegisteredNode, query_func=None)
 
     @classmethod
-    def _from_protobuf(cls, transaction_body, body_bytes: bytes, sig_map):
-        transaction = super()._from_protobuf(transaction_body, body_bytes, sig_map)
+    def _from_protobuf(cls, transaction_body):
+        transaction = super()._from_protobuf(transaction_body)
 
         # Extract registered node fields if the body contains a registeredNodeDelete message
         if transaction_body.HasField("registeredNodeDelete"):

src/hiero_sdk_python/nodes/registered_node_update_transaction.py

@@ -122,8 +122,8 @@ def _get_method(self, channel: _Channel) -> _Method:
         return _Method(transaction_func=channel.address_book.updateRegisteredNode, query_func=None)
 
     @classmethod
-    def _from_protobuf(cls, transaction_body, body_bytes: bytes, sig_map):
-        transaction = super()._from_protobuf(transaction_body, body_bytes, sig_map)
+    def _from_protobuf(cls, transaction_body):
+        transaction = super()._from_protobuf(transaction_body)
 
         if transaction_body.HasField("registeredNodeUpdate"):
             pb = transaction_body.registeredNodeUpdate

src/hiero_sdk_python/query/fee_estimate_query.py

@@ -191,7 +191,7 @@ 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:
@@ -224,7 +224,7 @@ def _execute_chunked(self, client, url: str, mode: FeeEstimateMode) -> FeeEstima
 
                 self._transaction.freeze_with(client)
 
-                tx_bytes = self._transaction.to_bytes()
+                tx_bytes = self._transaction._to_proto().SerializeToString()
                 data = self._post(url, tx_bytes)
                 response = self._to_response(data, mode)
 

src/hiero_sdk_python/query/query.py

@@ -179,15 +179,11 @@ def _make_request_header(self) -> query_header_pb2.QueryHeader:
             header.responseType = query_header_pb2.ResponseType.COST_ANSWER
             return header
 
-        if (
-            self.operator is not None
-            and self.node_account_ids[self._node_account_ids_index] is not None
-            and self.payment_amount is not None
-        ):
+        if self.operator is not None and self._node_account_id is not None and self.payment_amount is not None:
             payment_tx = self._build_query_payment_transaction(
                 payer_account_id=self.operator.account_id,
                 payer_private_key=self.operator.private_key,
-                node_account_id=self.node_account_ids[self._node_account_ids_index],
+                node_account_id=self._node_account_id,
                 amount=self.payment_amount,
             )
             header.payment.CopyFrom(payment_tx)

src/hiero_sdk_python/transaction/batch_transaction.py

@@ -95,7 +95,7 @@ def _verify_inner_transaction(self, transaction: Transaction) -> None:
             raise ValueError("Batch key needs to be set")
 
     @classmethod
-    def _from_protobuf(cls, transaction_body, body_bytes: bytes, sig_map) -> BatchTransaction:
+    def _from_protobuf(cls, transaction_body) -> BatchTransaction:
         """
         Creates a BatchTransaction instance from protobuf components.
 
@@ -107,7 +107,7 @@ def _from_protobuf(cls, transaction_body, body_bytes: bytes, sig_map) -> BatchTr
         Returns:
             BatchTransaction: A new transaction instance with all fields restored
         """
-        transaction = super()._from_protobuf(transaction_body, body_bytes, sig_map)
+        transaction = super()._from_protobuf(transaction_body)
 
         if transaction_body.HasField("atomic_batch"):
             atomic_batch = transaction_body.atomic_batch

src/hiero_sdk_python/transaction/transaction.py

@@ -8,6 +8,7 @@
 from hiero_sdk_python.crypto.key import Key
 from hiero_sdk_python.exceptions import PrecheckError
 from hiero_sdk_python.executable import _Executable, _ExecutionState
+from hiero_sdk_python.hapi.sdk.transaction_list_pb2 import TransactionList
 from hiero_sdk_python.hapi.services import basic_types_pb2, transaction_contents_pb2, transaction_pb2
 from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import SchedulableTransactionBody
 from hiero_sdk_python.hapi.services.transaction_response_pb2 import TransactionResponse as TransactionResponseProto
@@ -655,13 +656,41 @@ def to_bytes(self) -> bytes:
         Raises:
             Exception: If the transaction has not been frozen yet.
         """
-        self._require_frozen()
+        transaction_list = TransactionList()
 
-        # Get the transaction protobuf
-        transaction_proto = self._to_proto()
+        if len(self.node_account_ids) == 0:
+            transaction_body = self.build_transaction_body()
 
-        # Serialize to bytes
-        return transaction_proto.SerializeToString()
+            if self.transaction_id is not None:
+                transaction_body.transactionID.CopyFrom(self.transaction_id._to_proto())
+
+            transaction = transaction_contents_pb2.SignedTransaction(bodyBytes=transaction_body.SerializeToString())
+
+            transaction_list.transaction_list.append(
+                transaction_pb2.Transaction(signedTransactionBytes=transaction.SerializeToString())
+            )
+
+        else:
+            transaction_body = self.build_transaction_body()
+
+            if self.transaction_id is not None:
+                transaction_body.transactionID.CopyFrom(self.transaction_id._to_proto())
+
+            for node_account_id in self.node_account_ids:
+                transaction_body.nodeAccountID.CopyFrom(node_account_id._to_proto())
+                transaction = transaction_contents_pb2.SignedTransaction(bodyBytes=transaction_body.SerializeToString())
+
+                if self._transaction_body_bytes:
+                    if self._signature_map and self._signature_map[transaction_body.SerializeToString()]:
+                        transaction.sigMap.CopyFrom(self._signature_map[transaction_body.SerializeToString()])
+                    else:
+                        transaction.sigMap.CopyFrom(basic_types_pb2.SignatureMap(sigPair=[]))
+
+                transaction_list.transaction_list.append(
+                    transaction_pb2.Transaction(signedTransactionBytes=transaction.SerializeToString())
+                )
+
+        return transaction_list.SerializeToString()
 
     @staticmethod
     def from_bytes(transaction_bytes: bytes):
@@ -726,42 +755,116 @@ def from_bytes(transaction_bytes: bytes):
         """
         if not isinstance(transaction_bytes, bytes):
             raise ValueError("transaction_bytes must be bytes")
-
         if len(transaction_bytes) == 0:
             raise ValueError("transaction_bytes cannot be empty")
 
         try:
-            transaction_proto = transaction_pb2.Transaction()
-            transaction_proto.ParseFromString(transaction_bytes)
-        except Exception as e:
-            raise ValueError(f"Failed to parse transaction bytes: {e}") from e
+            return Transaction._process_transaction_list_bytes(transaction_bytes)
+        except Exception:
+            try:
+                return Transaction._process_single_transaction_bytes(transaction_bytes)
+            except Exception as e:
+                raise ValueError(f"Failed to parse transaction_bytes {e}") from e
 
+    @staticmethod
+    def _process_base_transaction_bytes(transaction_proto: transaction_pb2.Transaction):
         try:
             signed_transaction = transaction_contents_pb2.SignedTransaction()
             signed_transaction.ParseFromString(transaction_proto.signedTransactionBytes)
         except Exception as e:
             raise ValueError(f"Failed to parse signed transaction: {e}") from e
-
         try:
             transaction_body = transaction_pb2.TransactionBody()
             transaction_body.ParseFromString(signed_transaction.bodyBytes)
         except Exception as e:
             raise ValueError(f"Failed to parse transaction body: {e}") from e
-
         transaction_type = transaction_body.WhichOneof("data")
-
         if transaction_type is None:
             raise ValueError("Transaction body does not contain any transaction data")
-
         transaction_class = Transaction._get_transaction_class(transaction_type)
-
         if transaction_class is None:
             raise ValueError(f"Unknown transaction type: {transaction_type}")
 
-        return transaction_class._from_protobuf(
-            transaction_body, signed_transaction.bodyBytes, signed_transaction.sigMap
+        return transaction_class, transaction_body, signed_transaction
+
+    # Deprecated, for backward compatiblity only
+    @staticmethod
+    def _process_single_transaction_bytes(transaction_bytes):
+        try:
+            transaction_proto = transaction_pb2.Transaction()
+            transaction_proto.ParseFromString(transaction_bytes)
+        except Exception as e:
+            raise ValueError(f"Failed to parse transaction bytes: {e}") from e
+
+        transaction_class, transaction_body, signed_transaction = Transaction._process_base_transaction_bytes(
+            transaction_proto
         )
 
+        restore_transaction: Transaction = transaction_class._from_protobuf(transaction_body)
+
+        if restore_transaction._node_account_id is not None:
+            restore_transaction.set_node_account_id(restore_transaction._node_account_id)
+
+        if signed_transaction.HasField("sigMap"):
+            if signed_transaction.sigMap.sigPair:
+                restore_transaction._signature_map[signed_transaction.bodyBytes] = signed_transaction.sigMap
+
+            restore_transaction._transaction_body_bytes[restore_transaction._node_account_id] = (
+                signed_transaction.bodyBytes
+            )
+
+        return restore_transaction
+
+    @staticmethod
+    def _process_transaction_list_bytes(transaction_bytes: bytes):
+        transaction_list = TransactionList()
+        transaction_list.ParseFromString(transaction_bytes)
+
+        if not transaction_list.transaction_list:
+            raise ValueError("TransactionList contains no transactions")
+
+        restored_transaction: Transaction = None
+
+        for transaction_proto in transaction_list.transaction_list:
+            transaction_class, transaction_body, signed_transaction = Transaction._process_base_transaction_bytes(
+                transaction_proto
+            )
+
+            tmp_transaction: Transaction = transaction_class._from_protobuf(transaction_body)
+
+            node_id = tmp_transaction._node_account_id
+
+            if restored_transaction is None:
+                restored_transaction = tmp_transaction
+
+                if node_id is not None:
+                    restored_transaction.node_account_ids = [node_id]
+
+                if tmp_transaction._signature_map:
+                    for key, value in tmp_transaction._signature_map.items():
+                        restored_transaction._signature_map[key] = value
+                        restored_transaction._transaction_body_bytes[node_id] = key
+
+            else:
+                if node_id is not None and node_id not in restored_transaction.node_account_ids:
+                    restored_transaction.node_account_ids.append(node_id)
+
+                if tmp_transaction._signature_map:
+                    for key, value in tmp_transaction._signature_map.items():
+                        restored_transaction._signature_map[key] = value
+                        restored_transaction._transaction_body_bytes[node_id] = key
+
+            if signed_transaction.HasField("sigMap"):
+                if signed_transaction.sigMap.sigPair:
+                    restored_transaction._signature_map[signed_transaction.bodyBytes] = signed_transaction.sigMap
+
+                restored_transaction._transaction_body_bytes[node_id] = signed_transaction.bodyBytes
+
+        if restored_transaction is None:
+            raise ValueError("No valid transactions could be parsed from the byte stream")
+
+        return restored_transaction
+
     @staticmethod
     def _get_transaction_class(transaction_type: str):
         """
@@ -843,7 +946,7 @@ def _get_transaction_class(transaction_type: str):
             raise ValueError(f"Failed to import transaction class for type '{transaction_type}': {e}") from e
 
     @classmethod
-    def _from_protobuf(cls, transaction_body, body_bytes: bytes, sig_map):
+    def _from_protobuf(cls, transaction_body):
         """
         Creates a transaction instance from protobuf components.
 
@@ -864,7 +967,7 @@ def _from_protobuf(cls, transaction_body, body_bytes: bytes, sig_map):
             transaction.transaction_id = TransactionId._from_proto(transaction_body.transactionID)
 
         if transaction_body.HasField("nodeAccountID"):
-            transaction.node_account_id = AccountId._from_proto(transaction_body.nodeAccountID)
+            transaction._node_account_id = AccountId._from_proto(transaction_body.nodeAccountID)
 
         transaction.transaction_fee = transaction_body.transactionFee
         transaction.transaction_valid_duration = transaction_body.transactionValidDuration.seconds
@@ -879,14 +982,6 @@ def _from_protobuf(cls, transaction_body, body_bytes: bytes, sig_map):
                 CustomFeeLimit._from_proto(fee) for fee in transaction_body.max_custom_fees
             ]
 
-        if transaction.node_account_id:
-            # restore for the original frozen node
-            transaction.set_node_account_id(transaction.node_account_id)
-            transaction._transaction_body_bytes[transaction.node_account_id] = body_bytes
-
-        if sig_map and sig_map.sigPair:
-            transaction._signature_map[body_bytes] = sig_map
-
         return transaction
 
     def set_batch_key(self, key: Key):