feat: Added Transaction size calculation methods

CHANGELOG.md

@@ -7,7 +7,7 @@ This changelog is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.
 ## [Unreleased]
 
 ### Src
-- 
+- Added Transaction size calculation properties `size`, `body_size` and `body_size_all_chunks`.
 
 ### Tests
 - Refactor `mock_server` setup for network level TLS handling and added thread safety

src/hiero_sdk_python/consensus/topic_message_submit_transaction.py

@@ -259,8 +259,7 @@ def freeze_with(self, client: "Client") -> "TopicMessageSubmitTransaction":
         if self._transaction_body_bytes:
             return self
 
-        if self.transaction_id is None:
-            self.transaction_id = client.generate_transaction_id()
+        self._resolve_transaction_id(client)
 
         if not self._transaction_ids:
             base_timestamp = self.transaction_id.valid_start
@@ -417,3 +416,22 @@ def sign(self, private_key: "PrivateKey"):
 
         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.
+        """
+        self._require_frozen()
+        sizes = []
+
+        original_index = self._current_index
+        original_transaction_id = self.transaction_id
+        for transaction_id in self._transaction_ids:
+            self.transaction_id = transaction_id
+            sizes.append(self.body_size)
+
+        self._current_index = original_index
+        self.transaction_id = original_transaction_id
+        return sizes
+

src/hiero_sdk_python/file/file_append_transaction.py

@@ -28,6 +28,7 @@
 if TYPE_CHECKING:
     from hiero_sdk_python.client import Client
     from hiero_sdk_python.crypto.private_key import PrivateKey
+    from hiero_sdk_python.key import PrivateKey
     from hiero_sdk_python.channels import _Channel
     from hiero_sdk_python.executable import _Method
     from hiero_sdk_python.transaction.transaction import TransactionReceipt
@@ -284,42 +285,31 @@ def freeze_with(self, client: "Client") -> FileAppendTransaction:
             return self
 
 
-        if self.transaction_id is None:
-            self.transaction_id = client.generate_transaction_id()
+        self._resolve_transaction_id(client)
 
         # Generate transaction IDs for all chunks
-        self._transaction_ids = []
-        base_timestamp = self.transaction_id.valid_start
-
-        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
-                chunk_valid_start = timestamp_pb2.Timestamp(
-                    seconds=base_timestamp.seconds,
-                    nanos=base_timestamp.nanos + i
-                )
-                chunk_transaction_id = TransactionId(
-                    account_id=self.transaction_id.account_id,
-                    valid_start=chunk_valid_start
-                )
-            self._transaction_ids.append(chunk_transaction_id)
-
-        # We iterate through every node in the client's network
-        # For each node, set the node_account_id and build the transaction body
-        # This allows the transaction to be submitted to any node in the network
-        for node in client.network.nodes:
-            self.node_account_id = node._account_id
-            transaction_body = self.build_transaction_body()
-            self._transaction_body_bytes[node._account_id] = transaction_body.SerializeToString()
-
-        # Set the node account id to the current node in the network
-        self.node_account_id = client.network.current_node._account_id
-
-        return self
+        if not self._transaction_ids:
+            base_timestamp = self.transaction_id.valid_start
+
+            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
+                    chunk_valid_start = timestamp_pb2.Timestamp(
+                        seconds=base_timestamp.seconds,
+                        nanos=base_timestamp.nanos + i
+                    )
+                    chunk_transaction_id = TransactionId(
+                        account_id=self.transaction_id.account_id,
+                        valid_start=chunk_valid_start
+                    )
+
+                self._transaction_ids.append(chunk_transaction_id)
+
+        return super().freeze_with(client)
 
     @overload
     def execute(
@@ -461,4 +451,23 @@ def sign(self, private_key: "PrivateKey") -> FileAppendTransaction:
 
         # Call the parent sign method for the current transaction
         super().sign(private_key)
-        return self
+        return self
+
+    @property
+    def body_size_all_chunks(self) -> List[int]:
+        """
+        Returns an array of body sizes for transactions with multiple chunks.
+        """
+        self._require_frozen()
+        sizes = []
+
+        original_index = self._current_chunk_index
+        original_transaction_id = self.transaction_id
+        for transaction_id in self._transaction_ids:
+            self.transaction_id = transaction_id
+            sizes.append(self.body_size)
+
+        self._current_chunk_index = original_index
+        self.transaction_id = original_transaction_id
+        return sizes
+

src/hiero_sdk_python/node.py

@@ -124,6 +124,8 @@ def _get_channel(self):
             if self._root_certificates:
                 # Use the certificate that is provided
                 self._node_pem_cert = self._root_certificates
+                print("node cert ", self._node_pem_cert)
+
             else:
                 # Fetch pem_cert for the node
                 self._node_pem_cert = self._fetch_server_certificate_pem()

src/hiero_sdk_python/transaction/transaction.py

@@ -239,6 +239,30 @@ def _to_proto(self):
         return transaction_pb2.Transaction(
             signedTransactionBytes=signed_transaction.SerializeToString()
         )
+
+    def _resolve_transaction_id(self, client: "Client"):
+        if self.transaction_id is not None:
+            return
+
+        if client is not None:
+            operator_account_id = client.operator_account_id
+            if operator_account_id is not None:
+                self.transaction_id = client.generate_transaction_id()
+            else:
+                raise ValueError(
+                    "Client must have an operator_account or transactionId must be set."
+                )
+        else:
+            raise ValueError(
+                "Transaction ID must be set before freezing. Use freeze_with(client) or set_transaction_id()."
+            )
+
+    def _resolve_node_ids(self, client: "Client"):
+        if self.node_account_id is None and len(self.node_account_ids) == 0:
+            if client is None:
+                raise ValueError(
+                    "Node account ID must be set before freezing. Use freeze_with(client) or manually set node_account_ids."
+                )
 
     def freeze(self):
         """
@@ -258,29 +282,9 @@ def freeze(self):
         Raises:
             ValueError: If transaction_id or node_account_id are not set.
         """
-        if self._transaction_body_bytes:
-            return self
-
-        if self.transaction_id is None:
-            raise ValueError("Transaction ID must be set before freezing. Use freeze_with(client) or set_transaction_id().")
-
-        if self.node_account_id is None and len(self.node_account_ids) == 0:
-            raise ValueError("Node account ID must be set before freezing. Use freeze_with(client) or manually set node_account_ids.")
-
-        # Populate node_account_ids for backward compatibility
-        if self.node_account_id:
-            self.set_node_account_id(self.node_account_id)
-            self._transaction_body_bytes[self.node_account_id] = self.build_transaction_body().SerializeToString()
-            return self
-
-        # Build the transaction body for the single node
-        for node_account_id in self.node_account_ids:
-            self.node_account_id = node_account_id
-            self._transaction_body_bytes[node_account_id] = self.build_transaction_body().SerializeToString()
-
-        return self
+        return self.freeze_with(None)
 
-    def freeze_with(self, client):
+    def freeze_with(self, client: "Client"):
         """
         Freezes the transaction by building the transaction body and setting necessary IDs.
 
@@ -296,8 +300,10 @@ def freeze_with(self, client):
         if self._transaction_body_bytes:
             return self
 
-        if self.transaction_id is None:
-            self.transaction_id = client.generate_transaction_id()
+        # Check transaction_id and node id to be set when using freeze()
+        self._resolve_transaction_id(client)
+
+        self._resolve_node_ids(client)
 
         # We iterate through every node in the client's network
         # For each node, set the node_account_id and build the transaction body
@@ -424,7 +430,7 @@ def is_signed_by(self, public_key):
                 return True
         return False
 
-    def build_transaction_body(self):
+    def build_transaction_body(self) -> transaction_pb2.TransactionBody:
         """
         Abstract method to build the transaction body.
 
@@ -913,3 +919,15 @@ def batchify(self, client: Client, batch_key: Key):
         self.freeze_with(client)
         self.sign(client.operator_private_key)
         return self
+
+    @property
+    def size(self) -> int:
+        """Returns the total transaction size in bytes after protobuf encoding"""
+        self._require_frozen()
+        return self._make_request().ByteSize()
+
+    @property
+    def body_size(self) -> int:
+        """Returns just the transaction body size in bytes after encoding"""
+        self._require_frozen()
+        return self.build_transaction_body().ByteSize()

tests/integration/file_append_transaction_e2e_test.py

@@ -1,13 +1,15 @@
 import pytest
 from pytest import mark
 
+from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.file.file_create_transaction import FileCreateTransaction
 from hiero_sdk_python.file.file_append_transaction import FileAppendTransaction
 from hiero_sdk_python.file.file_contents_query import FileContentsQuery
 from hiero_sdk_python.file.file_id import FileId
 from hiero_sdk_python.response_code import ResponseCode
 from hiero_sdk_python.hbar import Hbar
 from hiero_sdk_python.exceptions import PrecheckError
+from hiero_sdk_python.transaction.transaction_id import TransactionId
 from tests.integration.utils import env, IntegrationTestEnv
 
 # Generate big contents for chunking tests - similar to JavaScript bigContents
@@ -304,3 +306,40 @@ def test_integration_file_append_transaction_method_chaining(env):
 
     append_receipt = append_tx.execute(env.client)
     assert append_receipt.status == ResponseCode.SUCCESS 
+
+@pytest.mark.integration
+def test_file_append_chunk_transaction_can_execute_with_manual_freeze(env):
+    """Test file append transaction can execute  with manual freeze."""
+    create_receipt = (
+        FileCreateTransaction()
+        .set_keys(env.client.operator_private_key.public_key())
+        .set_contents(b"")
+        .execute(env.client)
+    )
+
+    assert create_receipt.status == ResponseCode.SUCCESS
+    file_id = create_receipt.file_id
+
+    file_contents = FileContentsQuery().set_file_id(file_id).execute(env.client)
+    assert file_contents == b""
+
+    content = "A" * (4000) # content with (4000/1024) bytes ie approx 4 chunks
+
+    tx = (
+        FileAppendTransaction()
+        .set_file_id(file_id)
+        .set_chunk_size(1024)
+        .set_contents(content)
+        .set_transaction_id(TransactionId.generate(env.client.operator_account_id))
+        .set_node_account_id(AccountId(0,0,3))
+        .freeze()
+    )
+
+    tx.sign(env.client.operator_private_key)
+
+    receipt = tx.execute(env.client)
+
+    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

@@ -4,6 +4,7 @@
 
 import pytest
 
+from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.consensus.topic_create_transaction import TopicCreateTransaction
 from hiero_sdk_python.consensus.topic_delete_transaction import TopicDeleteTransaction
 from hiero_sdk_python.consensus.topic_message_submit_transaction import (
@@ -16,6 +17,7 @@
 from hiero_sdk_python.response_code import ResponseCode
 from hiero_sdk_python.tokens.custom_fixed_fee import CustomFixedFee
 from hiero_sdk_python.transaction.custom_fee_limit import CustomFeeLimit
+from hiero_sdk_python.transaction.transaction_id import TransactionId
 from tests.integration.utils import  env
 
 def create_topic(client, admin_key=None, submit_key=None, custom_fees=None):
@@ -342,4 +344,37 @@ def test_integration_topic_message_submit_transaction_fails_if_required_chunk_gr
     with pytest.raises(ValueError, match="Message requires 4 chunks but max_chunks=2. Increase limit with set_max_chunks()."):
         message_transaction.execute(env.client)
 
-    delete_topic(env.client, topic_id)
+    delete_topic(env.client, topic_id)
+
+
+@pytest.mark.integration
+def test_topic_message_submit_transaction_can_submit_a_large_message_manual_freeze(env):
+    """Test topic message submit transaction can submit large message with manual freeze."""
+    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
+
+    message_tx = (
+        TopicMessageSubmitTransaction()
+        .set_topic_id(topic_id)
+        .set_message(message)
+        .set_transaction_id(TransactionId.generate(env.client.operator_account_id))
+        .set_node_account_id(AccountId(0,0,3))
+        .freeze()
+    )
+
+    message_tx.sign(env.client.operator_private_key)
+    message_receipt = message_tx.execute(env.client)
+
+    assert message_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/mock_server.py

@@ -2,6 +2,7 @@
 import threading
 from concurrent import futures
 from contextlib import contextmanager
+from hiero_sdk_python.channels import _Channel
 from hiero_sdk_python.client.network import Network
 from hiero_sdk_python.client.client import Client
 from hiero_sdk_python.account.account_id import AccountId
@@ -177,6 +178,13 @@ def mock_hedera_servers(response_sequences):
             node._close()
 
         client = Client(network)
+
+        # Force non-tls channel
+        for node in client.network.nodes:
+            node._address._is_transport_security = lambda: False
+            node._set_verify_certificates(False)
+            node._close()
+
         client.logger.set_level(LogLevel.DISABLED)
         # Set the operator
         key = PrivateKey.generate()