chore: added test for srialization

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

Author: manishdait

tests/unit/transaction_freeze_and_bytes_test.py

@@ -12,7 +12,6 @@
 
 from hiero_sdk_python.account.account_create_transaction import AccountCreateTransaction
 from hiero_sdk_python.account.account_id import AccountId
-from hiero_sdk_python.client.client import Client
 from hiero_sdk_python.crypto.private_key import PrivateKey
 from hiero_sdk_python.hapi.services.transaction_response_pb2 import (
     TransactionResponse as TransactionResponseProto,
@@ -533,31 +532,6 @@ def test_multiple_signatures_increase_size():
     assert len(bytes_3_sig) > len(bytes_2_sig)
 
 
-def test_changing_node_after_freeze_fails_for_to_bytes():
-    """Test that changing node_account_id after freeze causes to_bytes() to fail."""
-    operator_id = AccountId.from_string("0.0.1234")
-    node_id_1 = AccountId.from_string("0.0.3")
-    node_id_2 = AccountId.from_string("0.0.4")
-    receiver_id = AccountId.from_string("0.0.5678")
-
-    transaction = (
-        TransferTransaction().add_hbar_transfer(operator_id, -100_000_000).add_hbar_transfer(receiver_id, 100_000_000)
-    )
-
-    transaction.transaction_id = TransactionId.generate(operator_id)
-    transaction.node_account_id = node_id_1
-    transaction.freeze()
-
-    # This should work
-    bytes_node_1 = transaction.to_bytes()
-    assert isinstance(bytes_node_1, bytes)
-
-    # Change to a different node that wasn't frozen
-    transaction.node_account_id = node_id_2
-
-    # TODO: Update this to new implementation
-
-
 def test_unsigned_transaction_can_be_signed_after_to_bytes():
     """Test that you can call to_bytes(), then sign, then to_bytes() again."""
     operator_id = AccountId.from_string("0.0.1234")
@@ -680,39 +654,218 @@ def test_map_response_raises_if_proto_request_is_not_transaction():
         )
 
 
-def test_serialization():
-    client = Client.for_testnet()
-    client.set_operator(AccountId(0, 0, 5), PrivateKey.generate_ecdsa())
+def test_to_bytes_with_base_fields():
+    """Test serialization and deserialization of an unfrozen transaction with base fields"""
+    tx = (
+        AccountCreateTransaction()
+        .set_key_without_alias(PrivateKey.generate_ecdsa())
+        .set_initial_balance(1)
+        .set_account_memo("test_account")
+    )
+
+    restored_tx = Transaction.from_bytes(tx.to_bytes())
+
+    assert restored_tx.key.to_bytes() == tx.key.to_bytes()
+    assert restored_tx.initial_balance == tx.initial_balance
+    assert restored_tx.account_memo == tx.account_memo
+    assert restored_tx.transaction_id is None
+    assert len(restored_tx.node_account_ids) == 0
+    assert not restored_tx._transaction_body_bytes
+
+
+def test_to_bytes_without_freeze_multiple_node_account_ids():
+    """Test serialization and deserialization of an unfrozen transaction with multiple node account IDs."""
+    tx = (
+        AccountCreateTransaction()
+        .set_key_without_alias(PrivateKey.generate_ecdsa())
+        .set_initial_balance(1)
+        .set_account_memo("test_account")
+        .set_transaction_id(TransactionId.generate(AccountId(0, 0, 1)))
+        .set_node_account_ids([AccountId(0, 0, 3), AccountId(0, 0, 4)])
+    )
+
+    restored_tx = Transaction.from_bytes(tx.to_bytes())
+
+    assert restored_tx.key.to_bytes() == tx.key.to_bytes()
+    assert restored_tx.initial_balance == tx.initial_balance
+    assert restored_tx.account_memo == tx.account_memo
+    assert restored_tx.transaction_id == tx.transaction_id
+    assert restored_tx.node_account_ids == tx.node_account_ids
+    assert not restored_tx._transaction_body_bytes
+
+
+# Deprecated
+def test_to_bytes_without_freeze_single_node_account_id():
+    """Test serialization and deserialization of an unfrozen transaction with a single node account ID."""
+    tx = (
+        AccountCreateTransaction()
+        .set_key_without_alias(PrivateKey.generate_ecdsa())
+        .set_initial_balance(1)
+        .set_account_memo("test_account")
+        .set_transaction_id(TransactionId.generate(AccountId(0, 0, 1)))
+        .set_node_account_id(AccountId(0, 0, 3))
+    )
+
+    restored_tx = Transaction.from_bytes(tx.to_bytes())
+
+    assert restored_tx.key.to_bytes() == tx.key.to_bytes()
+    assert restored_tx.initial_balance == tx.initial_balance
+    assert restored_tx.account_memo == tx.account_memo
+    assert restored_tx.transaction_id == tx.transaction_id
+    assert restored_tx.node_account_ids == tx.node_account_ids
+    assert not restored_tx._transaction_body_bytes
 
+
+def test_to_bytes_after_freeze_multiple_node_account_ids():
+    """Test serialization and deserialization of a frozen transaction with multiple node account IDs."""
     tx = (
         AccountCreateTransaction()
-        .set_key_without_alias(PrivateKey.generate_ed25519())
+        .set_key_without_alias(PrivateKey.generate_ecdsa())
         .set_initial_balance(1)
         .set_account_memo("test_account")
-        .freeze_with(client)
-        .sign(PrivateKey.generate_ed25519())
+        .set_transaction_id(TransactionId.generate(AccountId(0, 0, 1)))
+        .set_node_account_ids([AccountId(0, 0, 3), AccountId(0, 0, 4)])
+        .freeze()
     )
 
-    print("Before serialization:")
-    print(tx.key)
-    print(tx.initial_balance)
-    print(tx.account_memo)
-    print(tx._transaction_body_bytes)
-    print(tx._signature_map)
-    print(tx.node_account_ids)
-    print(tx.transaction_id)
-    print("\n")
-
-    tx_bytes = tx.to_bytes()
-
-    new_tx = Transaction.from_bytes(tx_bytes)
-
-    print("After serialization:")
-    print(new_tx.key)
-    print(new_tx.initial_balance)
-    print(new_tx.account_memo)
-    print(new_tx._transaction_body_bytes)
-    print(new_tx._signature_map)
-    print(new_tx.node_account_ids)
-    print(new_tx.transaction_id)
-    print("\n")
+    restored_tx = Transaction.from_bytes(tx.to_bytes())
+
+    assert restored_tx.key.to_bytes() == tx.key.to_bytes()
+    assert restored_tx.initial_balance == tx.initial_balance
+    assert restored_tx.account_memo == tx.account_memo
+    assert restored_tx.transaction_id == tx.transaction_id
+    assert restored_tx.node_account_ids == tx.node_account_ids
+
+    assert restored_tx._transaction_body_bytes == tx._transaction_body_bytes
+    assert restored_tx._signature_map == tx._signature_map
+
+
+# Deprecated
+def test_to_bytes_after_freeze_single_node_account_id():
+    """Test serialization and deserialization of a frozen transaction with a single node account ID."""
+    tx = (
+        AccountCreateTransaction()
+        .set_key_without_alias(PrivateKey.generate_ecdsa())
+        .set_initial_balance(1)
+        .set_account_memo("test_account")
+        .set_transaction_id(TransactionId.generate(AccountId(0, 0, 1)))
+        .set_node_account_id(AccountId(0, 0, 3))
+        .freeze()
+    )
+
+    restored_tx = Transaction.from_bytes(tx.to_bytes())
+
+    assert restored_tx.key.to_bytes() == tx.key.to_bytes()
+    assert restored_tx.initial_balance == tx.initial_balance
+    assert restored_tx.account_memo == tx.account_memo
+    assert restored_tx.transaction_id == tx.transaction_id
+    assert restored_tx.node_account_ids == tx.node_account_ids
+
+    assert restored_tx._transaction_body_bytes == tx._transaction_body_bytes
+    assert restored_tx._signature_map == tx._signature_map
+
+
+def test_to_bytes_after_freeze_and_sign_multiple_node_account_ids():
+    """Test serialization and deserialization of a signed frozen transaction with multiple node account IDs."""
+    private_key = PrivateKey.generate_ecdsa()
+
+    tx = (
+        AccountCreateTransaction()
+        .set_key_without_alias(private_key.public_key())
+        .set_initial_balance(1)
+        .set_account_memo("test_account")
+        .set_transaction_id(TransactionId.generate(AccountId(0, 0, 1)))
+        .set_node_account_ids([AccountId(0, 0, 3), AccountId(0, 0, 4)])
+    )
+
+    tx.freeze()
+    tx.sign(private_key)
+
+    restored_tx = Transaction.from_bytes(tx.to_bytes())
+
+    assert restored_tx.key.to_bytes() == tx.key.to_bytes()
+    assert restored_tx.initial_balance == tx.initial_balance
+    assert restored_tx.account_memo == tx.account_memo
+    assert restored_tx.transaction_id == tx.transaction_id
+    assert restored_tx.node_account_ids == tx.node_account_ids
+
+    assert restored_tx._transaction_body_bytes == tx._transaction_body_bytes
+    assert restored_tx._signature_map == tx._signature_map
+
+
+# Deprecated
+def test_to_bytes_after_freeze_and_sign_single_node_account_id():
+    """Test serialization and deserialization of a signed frozen transaction with a single node account ID."""
+    private_key = PrivateKey.generate_ecdsa()
+
+    tx = (
+        AccountCreateTransaction()
+        .set_key_without_alias(private_key.public_key())
+        .set_initial_balance(1)
+        .set_account_memo("test_account")
+        .set_transaction_id(TransactionId.generate(AccountId(0, 0, 1)))
+        .set_node_account_id(AccountId(0, 0, 3))
+    )
+
+    tx.freeze()
+    tx.sign(private_key)
+
+    restored_tx = Transaction.from_bytes(tx.to_bytes())
+
+    assert restored_tx.key.to_bytes() == tx.key.to_bytes()
+    assert restored_tx.initial_balance == tx.initial_balance
+    assert restored_tx.account_memo == tx.account_memo
+    assert restored_tx.transaction_id == tx.transaction_id
+    assert restored_tx.node_account_ids == tx.node_account_ids
+
+    assert restored_tx._transaction_body_bytes == tx._transaction_body_bytes
+    assert restored_tx._signature_map == tx._signature_map
+
+
+def test_to_bytes_after_freeze_with_client(mock_client):
+    """Test serialization and deserialization of a transaction frozen with a client."""
+    tx = (
+        AccountCreateTransaction()
+        .set_key_without_alias(PrivateKey.generate_ecdsa())
+        .set_initial_balance(1)
+        .set_account_memo("test_account")
+    )
+
+    tx.freeze_with(mock_client)
+
+    restored_tx = Transaction.from_bytes(tx.to_bytes())
+
+    assert restored_tx.key.to_bytes() == tx.key.to_bytes()
+    assert restored_tx.initial_balance == tx.initial_balance
+    assert restored_tx.account_memo == tx.account_memo
+    assert restored_tx.transaction_id == tx.transaction_id
+    assert restored_tx.node_account_ids == tx.node_account_ids
+
+    assert restored_tx._transaction_body_bytes == tx._transaction_body_bytes
+    assert restored_tx._signature_map == tx._signature_map
+
+
+def test_to_bytes_after_freeze_with_client_and_sign_multiple_node_account_ids(mock_client):
+    """Test serialization and deserialization of a signed transaction frozen with a client."""
+    private_key = PrivateKey.generate_ecdsa()
+
+    tx = (
+        AccountCreateTransaction()
+        .set_key_without_alias(private_key.public_key())
+        .set_initial_balance(1)
+        .set_account_memo("test_account")
+    )
+
+    tx.freeze_with(mock_client)
+    tx.sign(private_key)
+
+    restored_tx = Transaction.from_bytes(tx.to_bytes())
+
+    assert restored_tx.key.to_bytes() == tx.key.to_bytes()
+    assert restored_tx.initial_balance == tx.initial_balance
+    assert restored_tx.account_memo == tx.account_memo
+    assert restored_tx.transaction_id == tx.transaction_id
+    assert restored_tx.node_account_ids == tx.node_account_ids
+
+    assert restored_tx._transaction_body_bytes == tx._transaction_body_bytes
+    assert restored_tx._signature_map == tx._signature_map