chore: updated unit test

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

Author: manishdait

src/hiero_sdk_python/consensus/topic_message_submit_transaction.py

@@ -385,18 +385,19 @@ def body_size_all_chunks(self) -> list[int]:
         self._require_frozen()
         sizes = []
 
-        original_index = self._current_chunk_index
-        original_transaction_id = self.transaction_id
+        original_transaction_index = self._current_transaction_id_index
 
         try:
-            for i, transaction_id in enumerate(self._transaction_ids):
-                self._current_chunk_index = i
-                self.transaction_id = transaction_id
-
+            for i, _ in enumerate(self._transaction_ids):
+                self._current_transaction_id_index = i
+                self._chunk_info = consensus_submit_message_pb2.ConsensusMessageChunkInfo(
+                    initialTransactionID=self._initial_transaction_id._to_proto(),
+                    total=self._total_chunks,
+                    number=i + 1,
+                )
                 sizes.append(self.body_size)
         finally:
-            self._current_chunk_index = original_index
-            self.transaction_id = original_transaction_id
+            self._current_transaction_id_index = original_transaction_index
 
         return sizes
 

src/hiero_sdk_python/file/file_append_transaction.py

@@ -420,18 +420,15 @@ def body_size_all_chunks(self) -> list[int]:
         self._require_frozen()
         sizes = []
 
-        original_index = self._current_chunk_index
-        original_transaction_id = self.transaction_id
+        original_transaction_index = self._current_transaction_id_index
 
         try:
-            for i, transaction_id in enumerate(self._transaction_ids):
+            for i, _ in enumerate(self._transaction_ids):
+                self._current_transaction_id_index = i
                 self._current_chunk_index = i
-                self.transaction_id = transaction_id
-
                 sizes.append(self.body_size)
         finally:
-            self._current_chunk_index = original_index
-            self.transaction_id = original_transaction_id
+            self._current_transaction_id_index = original_transaction_index
 
         return sizes
 

src/hiero_sdk_python/query/fee_estimate_query.py

@@ -194,17 +194,11 @@ def _execute_single(self, url: str, mode: FeeEstimateMode) -> FeeEstimateRespons
         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
@@ -215,15 +209,10 @@ def _execute_chunked(self, client, url: str, mode: FeeEstimateMode) -> FeeEstima
         final_multiplier = 0
         final_hvm = 0
 
+        self._transaction._current_transaction_id_index = 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()
-
-                self._transaction.freeze_with(client)
-
+            for i in range(len(self._transaction._transaction_ids)):
+                self._transaction._current_transaction_id_index = i
                 tx_bytes = self._transaction._to_proto().SerializeToString()
                 data = self._post(url, tx_bytes)
                 response = self._to_response(data, mode)
@@ -242,12 +231,7 @@ def _execute_chunked(self, client, url: str, mode: FeeEstimateMode) -> FeeEstima
                 final_hvm = response.high_volume_multiplier
 
         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._current_transaction_id_index = 0
 
         return FeeEstimateResponse(
             mode=mode,

src/hiero_sdk_python/transaction/transaction.py

@@ -410,9 +410,9 @@ def _generate_transaction_ids(self, initial_transaction: TransactionId, count: i
         for i in range(count):
             self._transaction_ids.append(transaction_id)
 
-            next_nanos = transaction_id.valid_start.nanos + (i + 1)
+            next_nanos = initial_transaction.valid_start.nanos + (i + 1)
             next_valid_start = timestamp_pb2.Timestamp(
-                seconds=transaction_id.valid_start.seconds + next_nanos // 1_000_000_000,
+                seconds=initial_transaction.valid_start.seconds + next_nanos // 1_000_000_000,
                 nanos=next_nanos % 1_000_000_000,
             )
 
@@ -430,7 +430,7 @@ def is_signed_by(self, public_key):
         """
         public_key_bytes = public_key.to_bytes_raw()
 
-        sig_map = self._signature_map.get(self._transaction_body_bytes.get(self._node_account_id))
+        sig_map = self._signature_map.get(self._transaction_body_bytes[self.transaction_id][self._node_account_id])
 
         if sig_map is None:
             return False

tests/unit/transaction_freeze_and_bytes_test.py

@@ -63,7 +63,8 @@ def test_freeze_with_valid_parameters():
 
     # Should have transaction body bytes set
     assert len(transaction._transaction_body_bytes) > 0
-    assert node_id in transaction._transaction_body_bytes
+    assert transaction.transaction_id in transaction._transaction_body_bytes
+    # TODO check fro node ids
 
 
 def test_freeze_is_idempotent():
@@ -464,7 +465,8 @@ def test_freeze_only_builds_for_single_node():
 
     # Should only have one node in the transaction body bytes map
     assert len(transaction._transaction_body_bytes) == 1
-    assert node_id in transaction._transaction_body_bytes
+    assert transaction.transaction_id in transaction._transaction_body_bytes
+    # TODO check fro node ids
 
 
 def test_signed_and_unsigned_bytes_are_different():
@@ -575,7 +577,8 @@ def test_transaction_freeze_with_node_ids(mock_client):
     assert tx.node_account_ids == [single_node_id]
     # Verify creates transaction_bytes for single node_id
     assert len(tx._transaction_body_bytes) == 1
-    assert set(tx._transaction_body_bytes.keys()) == {single_node_id}
+    assert set(tx._transaction_body_bytes.keys()) == {tx._transaction_ids[0]}
+    # TODO check fro node ids
 
     # Case 2 node_account_id list
     node_account_ids = [AccountId(0, 0, 3), AccountId(0, 0, 4)]
@@ -586,8 +589,9 @@ def test_transaction_freeze_with_node_ids(mock_client):
 
     assert tx.node_account_ids == node_account_ids
     # Verify creates transaction_bytes for two node_ids
-    assert len(tx._transaction_body_bytes) == 2
-    assert set(tx._transaction_body_bytes.keys()) == set(node_account_ids)
+    assert len(tx._transaction_body_bytes) == 1
+    assert set(tx._transaction_body_bytes.keys()) == {tx._transaction_ids[0]}
+    # TODO check fro node ids
 
 
 def test_transaction_freeze_with_node_ids_without_client():
@@ -606,8 +610,10 @@ def test_transaction_freeze_with_node_ids_without_client():
 
     assert tx.node_account_ids == [single_node_id]
     # Verify creates transaction_bytes for single node_id
-    assert len(tx._transaction_body_bytes) == 1
-    assert set(tx._transaction_body_bytes.keys()) == {single_node_id}
+    assert len(tx._transaction_body_bytes) == len(tx._transaction_ids)
+    assert set(tx._transaction_body_bytes.keys()) == {tx.transaction_id}
+
+    # TODO: check for node_ids
 
     # Case 2 node_account_id list
     node_account_ids = [AccountId(0, 0, 3), AccountId(0, 0, 4)]
@@ -619,8 +625,9 @@ def test_transaction_freeze_with_node_ids_without_client():
 
     assert tx.node_account_ids == node_account_ids
     # Verify creates transaction_bytes for two node_ids
-    assert len(tx._transaction_body_bytes) == 2
-    assert set(tx._transaction_body_bytes.keys()) == set(node_account_ids)
+    assert len(tx._transaction_body_bytes) == 1
+    assert set(tx._transaction_body_bytes.keys()) == {tx._transaction_ids[0]}
+    # TODO: check for the node ids
 
 
 def test_transaction_freeze_without_node_ids(mock_client):
@@ -632,8 +639,10 @@ def test_transaction_freeze_without_node_ids(mock_client):
 
     assert tx.node_account_ids == [node._account_id for node in mock_client.network.nodes]
     # Verify creates transaction_bytes for client network nodes
-    assert len(tx._transaction_body_bytes) == len(mock_client.network.nodes)
-    assert set(tx._transaction_body_bytes.keys()) == set(node._account_id for node in mock_client.network.nodes)
+    assert len(tx._transaction_body_bytes) == len(tx._transaction_ids)
+    assert set(tx._transaction_body_bytes.keys()) == set(tx_id for tx_id in tx._transaction_ids)
+
+    # TODO: check for node_ids
 
 
 def test_map_response_raises_if_proto_request_is_not_transaction():

tests/unit/transaction_test.py

@@ -342,7 +342,6 @@ def test_message_submit_chunk_tx_should_return_list_of_body_sizes(topic_id, acco
     sizes = tx.body_size_all_chunks
     assert isinstance(sizes, list)
     assert len(sizes) == 3
-    assert tx._current_chunk_index == 0
 
 
 def test_message_submit_single_chunk_tx_return_list_of_len_one(topic_id, account_id, transaction_id):
@@ -487,7 +486,8 @@ def test_high_volume_is_included_in_protobuf_output(
 
     assert transaction._transaction_body_bytes
 
-    body_bytes = next(iter(transaction._transaction_body_bytes.values()))
+    node_bytes = next(iter(transaction._transaction_body_bytes.values()))
+    body_bytes = next(iter(node_bytes.values()))
 
     body = transaction_pb2.TransactionBody()
     body.ParseFromString(body_bytes)
@@ -504,7 +504,8 @@ def test_high_volume_is_included_in_protobuf_output(
         .freeze()
     )
 
-    body_bytes_false = next(iter(transaction_false._transaction_body_bytes.values()))
+    node_bytes_false = next(iter(transaction_false._transaction_body_bytes.values()))
+    body_bytes_false = next(iter(node_bytes_false.values()))
 
     body_false = transaction_pb2.TransactionBody()
     body_false.ParseFromString(body_bytes_false)
@@ -632,7 +633,7 @@ def test_freeze_with_sets_transaction_id_and_node_ids_from_client(mock_client):
     """Test that freeze_with() populates the transaction ID and node IDs from the client."""
     tx = TransferTransaction().freeze_with(mock_client)
     expected_node_ids = [node._account_id for node in mock_client.network.nodes]
-    
+
     # Generated when freeze with using clinet
     expected_transaction_ids = tx._transaction_ids