feat: add _require_frozen() (#92)

* feat: implement require_frozen functionality in Transaction class

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* refactor: update sign() and to_proto() to use _require_frozen()

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* test: add mock_client() in conftest as fixture

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* test: fix unit tests

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* test: add test for signing without freezing

Signed-off-by: dosi <dosi.kolev@limechain.tech>

---------

Signed-off-by: dosi <dosi.kolev@limechain.tech>

Author: Dosik13

src/hiero_sdk_python/transaction/transaction.py

@@ -146,8 +146,8 @@ def sign(self, private_key):
         Raises:
             Exception: If the transaction body has not been built.
         """
-        if self.transaction_body_bytes is None:
-            self.transaction_body_bytes = self.build_transaction_body().SerializeToString()
+        # We require the transaction to be frozen before signing
+        self._require_frozen()
 
         signature = private_key.sign(self.transaction_body_bytes)
 
@@ -172,8 +172,8 @@ def to_proto(self):
         Raises:
             Exception: If the transaction body has not been built.
         """
-        if self.transaction_body_bytes is None:
-            raise Exception("Transaction must be signed before calling to_proto()")
+        # We require the transaction to be frozen before converting to protobuf
+        self._require_frozen()
 
         signed_transaction = transaction_contents_pb2.SignedTransaction(
             bodyBytes=self.transaction_body_bytes,
@@ -320,6 +320,19 @@ def _require_not_frozen(self):
         if self.transaction_body_bytes is not None:
             raise Exception("Transaction is immutable; it has been frozen.")
 
+    def _require_frozen(self):
+        """
+        Ensures the transaction is frozen before allowing operations that require a frozen transaction.
+
+        This method checks if the transaction has been frozen by verifying that transaction_body_bytes
+        has been set.
+
+        Raises:
+            Exception: If the transaction has not been frozen yet.
+        """
+        if self.transaction_body_bytes is None:
+            raise Exception("Transaction is not frozen")
+
     def set_transaction_memo(self, memo):
         """
         Sets the memo field for the transaction.

tests/unit/conftest.py

@@ -1,5 +1,9 @@
 import pytest
 from hiero_sdk_python.account.account_id import AccountId
+from hiero_sdk_python.client.network import Network
+from hiero_sdk_python.client.client import Client
+from hiero_sdk_python.logger.log_level import LogLevel
+from hiero_sdk_python.node import _Node
 from hiero_sdk_python.consensus.topic_id import TopicId
 from hiero_sdk_python.crypto.private_key import PrivateKey
 from hiero_sdk_python.tokens.token_id import TokenId
@@ -38,4 +42,18 @@ def private_key():
 @pytest.fixture
 def topic_id():
     """Fixture to create a topic ID for testing."""
-    return TopicId(0, 0, 1234)
+    return TopicId(0, 0, 1234)
+
+@pytest.fixture
+def mock_client():
+    """Fixture to provide a mock client with hardcoded nodes for testing purposes."""
+    nodes = [_Node(AccountId(0, 0, 3), "node1.example.com:50211", None)]
+    network = Network(nodes=nodes)
+    client = Client(network)
+    client.logger.set_level(LogLevel.DISABLED)
+
+    operator_key = PrivateKey.generate()
+    operator_id = AccountId(0, 0, 1984)
+    client.set_operator(operator_id, operator_key)
+
+    return client

tests/unit/test_account_create_transaction.py

@@ -131,6 +131,25 @@ def test_account_create_transaction():
         assert receipt.status == ResponseCode.SUCCESS, "Transaction should have succeeded"
         assert receipt.accountId.num == 1234, "Should have created account with ID 1234"
 
+def test_sign_account_create_without_freezing_raises_error(mock_account_ids):
+    """Test that signing a transaction without freezing it first raises an error."""
+    operator_id, node_account_id = mock_account_ids
+    
+    new_private_key = PrivateKey.generate()
+    new_public_key = new_private_key.public_key()
+    
+    account_tx = (
+        AccountCreateTransaction()
+        .set_key(new_public_key)
+        .set_initial_balance(100000000)
+        .set_account_memo("Test account")
+    )
+    account_tx.transaction_id = generate_transaction_id(operator_id)
+    account_tx.node_account_id = node_account_id
+
+    with pytest.raises(Exception, match="Transaction is not frozen"):
+        account_tx.sign(new_private_key)
+
 @pytest.fixture
 def mock_account_ids():
     """Fixture to provide mock account IDs for testing."""

tests/unit/test_token_associate_transaction.py

@@ -50,20 +50,24 @@ def test_missing_fields():
     with pytest.raises(ValueError, match="Account ID and token IDs must be set."):
         associate_tx.build_transaction_body()
 
-# This test uses fixture mock_account_ids as parameter
-def test_sign_transaction(mock_account_ids):
+# This test uses fixture (mock_account_ids, mock_client) as parameter
+def test_sign_transaction(mock_account_ids, mock_client):
     """Test signing the token associate transaction with a private key."""
-    account_id, _, node_account_id, token_id_1, _ = mock_account_ids
+    account_id, _, _, token_id_1, _ = mock_account_ids
+    
     associate_tx = TokenAssociateTransaction()
     associate_tx.set_account_id(account_id)
     associate_tx.add_token_id(token_id_1)
     associate_tx.transaction_id = generate_transaction_id(account_id)
-    associate_tx.node_account_id = node_account_id
 
     private_key = MagicMock()
     private_key.sign.return_value = b'signature'
     private_key.public_key().to_bytes_raw.return_value = b'public_key'
-
+    
+    # Freeze the transaction
+    associate_tx.freeze_with(mock_client)
+    
+    # Sign the transaction
     associate_tx.sign(private_key)
 
     assert len(associate_tx.signature_map.sigPair) == 1
@@ -72,20 +76,22 @@ def test_sign_transaction(mock_account_ids):
     assert sig_pair.pubKeyPrefix == b'public_key'  
     assert sig_pair.ed25519 == b'signature'
 
-# This test uses fixture mock_account_ids as parameter
-def test_to_proto(mock_account_ids):
+# This test uses fixture (mock_account_ids, mock_client) as parameter
+def test_to_proto(mock_account_ids, mock_client):
     """Test converting the token associate transaction to protobuf format after signing."""
-    account_id, _, node_account_id, token_id_1, _ = mock_account_ids
+    account_id, _, _, token_id_1, _ = mock_account_ids
+    
     associate_tx = TokenAssociateTransaction()
     associate_tx.set_account_id(account_id)
     associate_tx.add_token_id(token_id_1)
     associate_tx.transaction_id = generate_transaction_id(account_id)
-    associate_tx.node_account_id = node_account_id
 
     private_key = MagicMock()
     private_key.sign.return_value = b'signature'
     private_key.public_key().to_bytes_raw.return_value = b'public_key'
 
+    associate_tx.freeze_with(mock_client)
+
     associate_tx.sign(private_key)
     proto = associate_tx.to_proto()
 

tests/unit/test_token_create_transaction.py

@@ -237,10 +237,10 @@ def test_token_creation_validation(
 
 ########### Tests for Signing and Protobuf Conversion ###########
 
-# This test uses fixture mock_account_ids as parameter
-def test_sign_transaction(mock_account_ids):
+# This test uses fixture (mock_account_ids, mock_client) as parameter
+def test_sign_transaction(mock_account_ids, mock_client):
     """Test signing the token creation transaction that has multiple keys."""
-    treasury_account, _, node_account_id, _, _ = mock_account_ids
+    treasury_account, _, _, _, _ = mock_account_ids
 
     # Mock keys
     private_key = MagicMock()
@@ -270,7 +270,8 @@ def test_sign_transaction(mock_account_ids):
     token_tx.set_freeze_key(private_key_freeze)
 
     token_tx.transaction_id = generate_transaction_id(treasury_account)
-    token_tx.node_account_id = node_account_id
+    
+    token_tx.freeze_with(mock_client)
 
     # Sign with both sign keys
     token_tx.sign(private_key) # Necessary
@@ -291,10 +292,10 @@ def test_sign_transaction(mock_account_ids):
     for sig_pair in token_tx.signature_map.sigPair:
         assert sig_pair.pubKeyPrefix not in (b"supply_public_key", b"freeze_public_key")
 
-# This test uses fixture mock_account_ids as parameter
-def test_to_proto_without_keys(mock_account_ids):
+# This test uses fixture (mock_account_ids, mock_client) as parameter
+def test_to_proto_without_keys(mock_account_ids, mock_client):
     """Test protobuf conversion when keys are not set."""
-    treasury_account, _, node_account_id, _, _ = mock_account_ids
+    treasury_account, _, _, _, _ = mock_account_ids
 
     token_tx = TokenCreateTransaction()
     token_tx.set_token_name("MyToken")
@@ -303,13 +304,14 @@ def test_to_proto_without_keys(mock_account_ids):
     token_tx.set_initial_supply(1000)
     token_tx.set_treasury_account_id(treasury_account)
     token_tx.transaction_id = generate_transaction_id(treasury_account)
-    token_tx.node_account_id = node_account_id
 
     # Mock treasury/operator key
     private_key = MagicMock()
     private_key.sign.return_value = b"signature"
     private_key.public_key().to_bytes_raw.return_value = b"public_key"
 
+    token_tx.freeze_with(mock_client)
+
     # Sign with treasury key
     token_tx.sign(private_key)
 
@@ -335,10 +337,10 @@ def test_to_proto_without_keys(mock_account_ids):
 
     assert not transaction_body.tokenCreation.HasField("adminKey")
 
-# This test uses fixture mock_account_ids as parameter
-def test_to_proto_with_keys(mock_account_ids):
+# This test uses fixture (mock_account_ids, mock_client) as parameter
+def test_to_proto_with_keys(mock_account_ids, mock_client):
     """Test converting the token creation transaction to protobuf format after signing."""
-    treasury_account, _, node_account_id, _, _ = mock_account_ids
+    treasury_account, _, _, _, _ = mock_account_ids
 
     # Mock keys
     private_key = MagicMock()
@@ -369,10 +371,11 @@ def test_to_proto_with_keys(mock_account_ids):
     token_tx.set_freeze_key(private_key_freeze)
 
     token_tx.transaction_id = generate_transaction_id(treasury_account)
-    token_tx.node_account_id = node_account_id
+
+    token_tx.freeze_with(mock_client)
 
     # Sign with required sign keys
-    token_tx.sign(private_key) 
+    token_tx.sign(private_key)
     token_tx.sign(private_key_admin)
 
     # Convert to protobuf
@@ -472,13 +475,13 @@ def test_transaction_execution_failure(mock_account_ids):
         # Verify _execute was called with client
         mock_execute.assert_called_once_with(token_tx.client)
 
-# This test uses fixture mock_account_ids as parameter
-def test_overwrite_defaults(mock_account_ids):
+# This test uses fixture (mock_account_ids, mock_client) as parameter
+def test_overwrite_defaults(mock_account_ids, mock_client):
     """
     Demonstrates that defaults in TokenCreateTransaction can be overwritten
     by calling set_* methods, and the final protobuf reflects the updated values.
     """
-    treasury_account, _, node_account_id, _, _ = mock_account_ids
+    treasury_account, _, _, _, _ = mock_account_ids
 
     # Create a new TokenCreateTransaction with all default params
     token_tx = TokenCreateTransaction()
@@ -500,7 +503,8 @@ def test_overwrite_defaults(mock_account_ids):
 
     # Set transaction/node IDs so can sign
     token_tx.transaction_id = generate_transaction_id(treasury_account)
-    token_tx.node_account_id = node_account_id
+
+    token_tx.freeze_with(mock_client)
 
     # Mock a private key and sign the transaction
     private_key = MagicMock()
@@ -621,13 +625,13 @@ def test_build_transaction_body_non_fungible(mock_account_ids):
     assert not transaction_body.tokenCreation.HasField("supplyKey")
     assert not transaction_body.tokenCreation.HasField("freezeKey")
 
-# This test uses fixture mock_account_ids as parameter
-def test_build_and_sign_nft_transaction_to_proto(mock_account_ids):
+# This test uses fixture (mock_account_ids, mock_client) as parameter
+def test_build_and_sign_nft_transaction_to_proto(mock_account_ids, mock_client):
     """
     Test building, signing, and protobuf serialization of 
     a valid Non-Fungible Unique token creation transaction.
     """
-    treasury_account, _, node_account_id, _, _ = mock_account_ids
+    treasury_account, _, _, _, _ = mock_account_ids
 
     # Mock keys
     private_key_private = MagicMock()
@@ -659,7 +663,8 @@ def test_build_and_sign_nft_transaction_to_proto(mock_account_ids):
     token_tx.set_freeze_key(private_key_freeze)
 
     token_tx.transaction_id = generate_transaction_id(treasury_account)
-    token_tx.node_account_id = node_account_id
+
+    token_tx.freeze_with(mock_client)
 
     # Sign the transaction
     token_tx.sign(private_key_private)

tests/unit/test_token_delete_transaction.py

@@ -43,18 +43,20 @@ def test_missing_token_id():
     with pytest.raises(ValueError, match="Missing required TokenID."):
         delete_tx.build_transaction_body()
 
-# This test uses fixture mock_account_ids as parameter
-def test_sign_transaction(mock_account_ids):
+# This test uses fixtures (mock_account_ids, mock_client) as parameters
+def test_sign_transaction(mock_account_ids, mock_client):
     """Test signing the token delete transaction with a private key."""
-    operator_id, _, node_account_id, token_id, _= mock_account_ids
+    operator_id, _, _, token_id, _= mock_account_ids
+    
     delete_tx = TokenDeleteTransaction()
     delete_tx.set_token_id(token_id)
     delete_tx.transaction_id = generate_transaction_id(operator_id)
-    delete_tx.node_account_id = node_account_id
 
     private_key = MagicMock()
     private_key.sign.return_value = b'signature'
     private_key.public_key().to_bytes_raw.return_value = b'public_key'
+    
+    delete_tx.freeze_with(mock_client)
 
     delete_tx.sign(private_key)
 
@@ -63,18 +65,20 @@ def test_sign_transaction(mock_account_ids):
     assert sig_pair.pubKeyPrefix == b'public_key'
     assert sig_pair.ed25519 == b'signature'
 
-# This test uses fixture mock_account_ids as parameter
-def test_to_proto(mock_account_ids):
+# This test uses fixtures (mock_account_ids, mock_client) as parameters
+def test_to_proto(mock_account_ids, mock_client):
     """Test converting the token delete transaction to protobuf format after signing."""
-    operator_id, _, node_account_id, token_id, _= mock_account_ids
+    operator_id, _, _, token_id, _= mock_account_ids
+    
     delete_tx = TokenDeleteTransaction()
     delete_tx.set_token_id(token_id)
     delete_tx.transaction_id = generate_transaction_id(operator_id)
-    delete_tx.node_account_id = node_account_id
 
     private_key = MagicMock()
     private_key.sign.return_value = b'signature'
     private_key.public_key().to_bytes_raw.return_value = b'public_key'
+    
+    delete_tx.freeze_with(mock_client)
 
     delete_tx.sign(private_key)
     proto = delete_tx.to_proto()

tests/unit/test_token_dissociate_transaction.py

@@ -72,18 +72,20 @@ def test_missing_fields():
     with pytest.raises(ValueError, match="Account ID and token IDs must be set."):
         dissociate_tx.build_transaction_body()
 
-def test_sign_transaction(mock_account_ids):
+def test_sign_transaction(mock_account_ids, mock_client):
     """Test signing the token dissociate transaction with a private key."""
-    account_id, _, node_account_id, token_id_1, _ = mock_account_ids
+    account_id, _, _, token_id_1, _ = mock_account_ids
+    
     dissociate_tx = TokenDissociateTransaction()
     dissociate_tx.set_account_id(account_id)
     dissociate_tx.add_token_id(token_id_1)
     dissociate_tx.transaction_id = generate_transaction_id(account_id)
-    dissociate_tx.node_account_id = node_account_id
 
     private_key = MagicMock()
     private_key.sign.return_value = b'signature'
     private_key.public_key().to_bytes_raw.return_value = b'public_key'
+    
+    dissociate_tx.freeze_with(mock_client)
 
     dissociate_tx.sign(private_key)
 
@@ -93,18 +95,20 @@ def test_sign_transaction(mock_account_ids):
     assert sig_pair.pubKeyPrefix == b'public_key'  
     assert sig_pair.ed25519 == b'signature'
 
-def test_to_proto(mock_account_ids):
+def test_to_proto(mock_account_ids, mock_client):
     """Test converting the token dissociate transaction to protobuf format after signing."""
-    account_id, _, node_account_id, token_id_1, _ = mock_account_ids
+    account_id, _, _, token_id_1, _ = mock_account_ids
+    
     dissociate_tx = TokenDissociateTransaction()
     dissociate_tx.set_account_id(account_id)
     dissociate_tx.add_token_id(token_id_1)
-    dissociate_tx.transaction_id = generate_transaction_id(account_id)
-    dissociate_tx.node_account_id = node_account_id
-
+    dissociate_tx.transaction_id = generate_transaction_id(account_id)  
+    
     private_key = MagicMock()
     private_key.sign.return_value = b'signature'
     private_key.public_key().to_bytes_raw.return_value = b'public_key'
+    
+    dissociate_tx.freeze_with(mock_client)
 
     dissociate_tx.sign(private_key)
     proto = dissociate_tx.to_proto()