chore: added new test for the topic submit message tx

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

Author: manishdait

src/hiero_sdk_python/consensus/topic_message_submit_transaction.py

@@ -69,7 +69,7 @@ def _message_as_bytes(self) -> bytes:
 
         return self.message.encode("utf-8") if isinstance(self.message, str) else self.message
         self._initial_transaction_id: TransactionId | None = None
-        self._chunk_info: consensus_submit_message_pb2.ConsensusMessageChunkInfo | None = None
+        self._current_chunk_index: int | None = None
 
     def get_required_chunks(self) -> int:
         """
@@ -183,16 +183,22 @@ def _build_proto_body(self) -> consensus_submit_message_pb2.ConsensusSubmitMessa
 
         content = self._message_as_bytes()
 
-        if self._chunk_info is not None:
-            start_index = (self._chunk_info.number - 1) * self.chunk_size
+        if 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,
+            )
+
+            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]
 
             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,
+                chunkInfo=chunk_info,
             )
 
         return consensus_submit_message_pb2.ConsensusSubmitMessageTransactionBody(
@@ -262,11 +268,7 @@ def freeze_with(self, client: Client) -> TopicMessageSubmitTransaction:
 
         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,
-            )
+            self._current_chunk_index = chunk
 
             node_bytes = {}
 
@@ -396,7 +398,9 @@ def body_size_all_chunks(self) -> list[int]:
 
         try:
             for i, _ in enumerate(self._transaction_ids):
+                self._current_chunk_index = i
                 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,

tests/integration/file_append_transaction_e2e_test.py

@@ -331,7 +331,7 @@ def test_file_append_chunk_transaction_can_execute_with_manual_freeze(env):
 
 
 @pytest.mark.integration
-def test(env):
+def test_serialize_chunked_file_append_transaction_can_be_executed(env):
     create_receipt = (
         FileCreateTransaction()
         .set_keys(env.client.operator_private_key.public_key())
@@ -345,25 +345,28 @@ def test(env):
     file_contents = FileContentsQuery().set_file_id(file_id).execute(env.client)
     assert file_contents == b""
 
-    content = "A" * (8192)  # content with (4000/1024) bytes ie approx 4 chunks
+    content = "A" * (8192)  # content with (8192/4096) bytes ie approx 2 chunks
 
-    tx = (
+    tx1 = (
         FileAppendTransaction()
         .set_file_id(file_id)
         .set_contents(content)
-        .set_transaction_id(TransactionId.generate(AccountId(0, 0, 101)))
-        .set_node_account_ids([AccountId(0, 0, 3), AccountId(0, 0, 4)])
+        .freeze_with(env.client)
     )
 
-    tx._default_transaction_fee = Hbar.from_hbars(10).to_tinybars()
+    tx1._default_transaction_fee = Hbar.from_hbars(10).to_tinybars()
+    tx_bytes = tx1.to_bytes()
+
+    tx2 = Transaction.from_bytes(tx_bytes)
 
-    print(tx.get_required_chunks())
-    print(tx.transaction_id)
-    print(tx.node_account_ids)
+    assert isinstance(tx2, FileAppendTransaction)
+    assert tx2.get_required_chunks() == 2
+    assert len(tx2._transaction_ids) == 2
+    assert len(tx2.node_account_ids) == len(env.client.network.nodes)
 
-    bytestx = tx.to_bytes()
-    ntx = Transaction.from_bytes(bytestx)
+    receipt = tx2.execute(env.client)
 
-    print(ntx.get_required_chunks())
-    print(ntx.transaction_id)
-    print(ntx.node_account_ids)
+    assert receipt.status == ResponseCode.SUCCESS
+    
+    file_contents = FileContentsQuery().set_file_id(file_id).execute(env.client)
+    assert file_contents == bytes(content, "utf-8")

tests/integration/topic_message_submit_transaction_e2e_test.py

@@ -325,30 +325,71 @@ def test_topic_message_submit_transaction_can_submit_a_large_message_manual_free
 
 
 @pytest.mark.integration
-def test(env):
+def test_non_freeze_serialize_chunk_topic_message_submit_transaction_can_be_executed(env):
+    """Test topic message submit transaction can execute serialize chunk transaction."""
     topic_id = create_topic(client=env.client, admin_key=env.operator_key)
 
     info = TopicInfoQuery().set_topic_id(topic_id).execute(env.client)
     assert info.sequence_number == 0
 
-    message = "ABCD"  # message with (1024 * 14) bytes ie 14 chunks
+    message = "A" * (1024 * 14)  # message with (1024 * 14) bytes ie 14 chunks
+
+    tx1 = TopicMessageSubmitTransaction().set_topic_id(topic_id).set_message(message)
+
+    tx_bytes = tx1.to_bytes()
+
+    tx2 = Transaction.from_bytes(tx_bytes)
+
+    assert isinstance(tx2, TopicMessageSubmitTransaction)
+    assert tx2.topic_id == tx1.topic_id
+    assert tx2.message == tx1.message
+
+    receipt = tx2.execute(env.client)
+
+    assert receipt.status == ResponseCode.SUCCESS
+
+    info = TopicInfoQuery().set_topic_id(topic_id).execute(env.client)
+    assert info.sequence_number == 14
+
+    delete_topic(env.client, topic_id)
 
-    message_tx = (
-        TopicMessageSubmitTransaction()
-        .set_topic_id(topic_id)
-        .set_chunk_size(1)
-        .set_message(message)
-        .freeze_with(env.client)
-    )
-    print(len(message_tx._transaction_ids))
-    print(len(message_tx._transaction_body_bytes.keys()))
 
-    bytestx = message_tx.to_bytes()
-    tx = Transaction.from_bytes(bytestx)
+@pytest.mark.integration
+def test_freeze_serialize_chunk_topic_message_submit_transaction_can_be_executed(env):
+    """Test topic message submit transaction can execute frozen serialize chunk transaction."""
+    topic_id = create_topic(client=env.client, admin_key=env.operator_key)
+
+    info = TopicInfoQuery().set_topic_id(topic_id).execute(env.client)
+    assert info.sequence_number == 0
+
+    message = "A" * (1024 * 14)  # message with (1024 * 14) bytes ie 14 chunks
+
+    tx1 = TopicMessageSubmitTransaction().set_topic_id(topic_id).set_message(message).freeze_with(env.client)
+
+    tx_bytes = tx1.to_bytes()
 
-    print(isinstance(tx, TopicMessageSubmitTransaction))
-    print(len(tx._transaction_ids))
-    print(len(tx._transaction_body_bytes.keys()))
-    tx.execute(env.client)
+    tx2 = Transaction.from_bytes(tx_bytes)
 
-    print(tx.message)
+    assert isinstance(tx2, TopicMessageSubmitTransaction)
+    assert tx2.topic_id == tx1.topic_id
+    # if transaction is frozen the serialization uses the transaction_body_bytes
+    # so the message will only contain the text for the first chunk
+    assert tx2.message != tx1.message
+    assert tx2._transaction_ids == tx1._transaction_ids
+    assert len(tx2._transaction_body_bytes) == len(tx1._transaction_body_bytes)
+
+    for transaction_id, node_bytes in tx2._transaction_body_bytes.items():
+        for node_id, _ in node_bytes.items():
+            assert (
+                tx1._transaction_body_bytes[transaction_id][node_id]
+                == tx2._transaction_body_bytes[transaction_id][node_id]
+            )
+
+    receipt = tx2.execute(env.client)
+
+    assert receipt.status == ResponseCode.SUCCESS
+
+    info = TopicInfoQuery().set_topic_id(topic_id).execute(env.client)
+    assert info.sequence_number == 14
+
+    delete_topic(env.client, topic_id)

tests/unit/topic_message_submit_transaction_test.py

@@ -8,6 +8,7 @@
 
 from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.consensus.topic_message_submit_transaction import TopicMessageSubmitTransaction
+from hiero_sdk_python.crypto.private_key import PrivateKey
 from hiero_sdk_python.exceptions import PrecheckError, ReceiptStatusError
 from hiero_sdk_python.hapi.services import (
     response_header_pb2,
@@ -22,6 +23,7 @@
 )
 from hiero_sdk_python.response_code import ResponseCode
 from hiero_sdk_python.transaction.custom_fee_limit import CustomFeeLimit
+from hiero_sdk_python.transaction.transaction import Transaction
 from hiero_sdk_python.transaction.transaction_id import TransactionId
 from hiero_sdk_python.transaction.transaction_receipt import TransactionReceipt
 from hiero_sdk_python.transaction.transaction_response import TransactionResponse
@@ -566,3 +568,165 @@ def test_execute_raises_when_message_is_empty(topic_id, mock_client):
 
     with pytest.raises(ValueError, match="Missing required fields: message"):
         transaction.freeze_with(mock_client)
+
+
+def test_frezee_with_client_generate_all_transaction_body_bytes(topic_id, mock_client):
+    """Test freeze_with() generate all required transaction body bytes."""
+    message = "A" * 40  # will create 4 chunks
+
+    transaction = TopicMessageSubmitTransaction().set_topic_id(topic_id).set_chunk_size(10).set_message(message)
+
+    assert len(transaction._transaction_ids) == 0
+    assert not transaction._transaction_body_bytes
+
+    transaction.freeze_with(mock_client)
+
+    # generated transaction ids == number of chunks i.e 4 (40/10)
+    assert len(transaction._transaction_ids) == 4
+
+    transaction_ids = transaction._transaction_ids
+    initial_transaction = transaction_ids[0]
+
+    for i, _ in enumerate(transaction_ids):
+        assert transaction_ids[i].account_id == initial_transaction.account_id
+        assert transaction_ids[i].valid_start.nanos == initial_transaction.valid_start.nanos + i
+
+    # create body bytes for each transaction_id and every node_account_ids
+    assert len(transaction._transaction_body_bytes) == 4
+    for transaction_id in transaction._transaction_ids:
+        assert len(transaction._transaction_body_bytes[transaction_id]) == len(mock_client.network.nodes)
+
+
+def test_manual_frezee_generate_all_transaction_body_bytes(topic_id):
+    """Test freeze() generate all required transaction body bytes."""
+    transaction_id = TransactionId.generate(AccountId(0, 0, 1))
+    node_account_ids = [AccountId(0, 0, 4), AccountId(0, 0, 5)]
+
+    message = "A" * 20  # will create 2 chunks
+
+    transaction = (
+        TopicMessageSubmitTransaction()
+        .set_topic_id(topic_id)
+        .set_chunk_size(10)
+        .set_message(message)
+        .set_transaction_id(transaction_id)
+        .set_node_account_ids(node_account_ids)
+    )
+
+    # single transaction_id which is set
+    assert len(transaction._transaction_ids) == 1
+    assert not transaction._transaction_body_bytes
+
+    transaction.freeze()
+
+    # generated transaction ids == number of chunks i.e 2 (20/10)
+    assert len(transaction._transaction_ids) == 2
+
+    transaction_ids = transaction._transaction_ids
+
+    assert transaction_ids[0] == transaction_id
+
+    for i, _ in enumerate(transaction_ids):
+        assert transaction_ids[i].account_id == transaction_id.account_id
+        assert transaction_ids[i].valid_start.nanos == transaction_id.valid_start.nanos + i
+
+    # create body bytes for each transaction_id and every node_account_ids
+    assert len(transaction._transaction_body_bytes) == 2
+    for transaction_id in transaction._transaction_ids:
+        assert len(transaction._transaction_body_bytes[transaction_id]) == len(node_account_ids)
+
+
+def test_serialize_chunk_transaction_preserve_signature_map(topic_id):
+    """Test serialize chunk transaction preserve signature maps."""
+    transaction_id = TransactionId.generate(AccountId(0, 0, 1))
+    node_account_ids = [AccountId(0, 0, 4), AccountId(0, 0, 5)]
+    key = PrivateKey.generate_ecdsa()
+
+    message = "A" * 20  # will create 2 chunks
+
+    tx1 = (
+        TopicMessageSubmitTransaction()
+        .set_topic_id(topic_id)
+        .set_chunk_size(10)
+        .set_message(message)
+        .set_transaction_id(transaction_id)
+        .set_node_account_ids(node_account_ids)
+        .freeze()
+        .sign(key)
+    )
+
+    assert tx1._signature_map
+
+    for transaction_id in tx1._transaction_ids:
+        for node_id in node_account_ids:
+            body_bytes = tx1._transaction_body_bytes[transaction_id][node_id]
+            sig_pairs = tx1._signature_map[body_bytes].sigPair
+
+            assert len(sig_pairs) == 1
+
+            pubkey_prefixes = {sp.pubKeyPrefix for sp in sig_pairs}
+            assert pubkey_prefixes == {key.public_key().to_bytes_raw()}
+
+    # will create transaction_bytes like
+    # {tx_id1: {node_id1: bytes, node_id2: bytes}, tx_id2: {node_id1: bytes, node_id2: bytes}}
+
+    tx_bytes = tx1.to_bytes()
+    tx2 = Transaction.from_bytes(tx_bytes)
+
+    assert isinstance(tx2, TopicMessageSubmitTransaction)
+
+    assert tx2._signature_map
+
+    for transaction_id in tx2._transaction_ids:
+        for node_id in node_account_ids:
+            body_bytes = tx2._transaction_body_bytes[transaction_id][node_id]
+            sig_pairs = tx2._signature_map[body_bytes].sigPair
+
+            assert len(sig_pairs) == 1
+
+            pubkey_prefixes = {sp.pubKeyPrefix for sp in sig_pairs}
+            assert pubkey_prefixes == {key.public_key().to_bytes_raw()}
+
+
+def test_signing_serialize_chunk_transaction_sign_all_available_bytes(topic_id):
+    """Test that signing the serialize chunk transaction sign all available bytes."""
+    transaction_id = TransactionId.generate(AccountId(0, 0, 1))
+    node_account_ids = [AccountId(0, 0, 4), AccountId(0, 0, 5)]
+
+    message = "A" * 20  # will create 2 chunks
+
+    tx1 = (
+        TopicMessageSubmitTransaction()
+        .set_topic_id(topic_id)
+        .set_chunk_size(10)
+        .set_message(message)
+        .set_transaction_id(transaction_id)
+        .set_node_account_ids(node_account_ids)
+        .freeze()
+    )
+
+    assert not tx1._signature_map
+
+    # will create transaction_bytes like
+    # {tx_id1: {node_id1: bytes, node_id2: bytes}, tx_id2: {node_id1: bytes, node_id2: bytes}}
+
+    tx_bytes = tx1.to_bytes()
+    tx2 = Transaction.from_bytes(tx_bytes)
+
+    assert isinstance(tx2, TopicMessageSubmitTransaction)
+
+    key = PrivateKey.generate_ecdsa()
+
+    tx2.sign(key)
+
+    assert tx2._signature_map
+
+    for transaction_id in tx2._transaction_ids:
+        for node_id in node_account_ids:
+            body_bytes = tx2._transaction_body_bytes[transaction_id][node_id]
+            sig_pairs = tx2._signature_map[body_bytes].sigPair
+
+            assert len(sig_pairs) == 1
+
+            pubkey_prefixes = {sp.pubKeyPrefix for sp in sig_pairs}
+            assert pubkey_prefixes == {key.public_key().to_bytes_raw()}