chore: deprecated the node_account_id to use node_account_ids

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

Author: manishdait

src/hiero_sdk_python/executable.py

@@ -86,11 +86,32 @@ def __init__(self):
         self._grpc_deadline: float | None = None
         self._request_timeout: float | None = None
 
-        self.node_account_id: AccountId | None = None
+        self._node_account_id: AccountId | None = None
         self.node_account_ids: list[AccountId] = []
 
         self._used_node_account_id: AccountId | None = None
         self._node_account_ids_index: int = 0
+    
+    @property
+    def node_account_id(self) -> AccountId | None:
+        warnings.warn(
+            "'node_account_id' is deprecated; use 'node_account_ids' instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+
+        return self._node_account_id
+
+    @node_account_id.setter
+    def node_account_id(self, account_id: AccountId) -> None:
+        warnings.warn(
+            "'node_account_id' is deprecated; use 'node_account_ids' instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+
+        self.node_account_ids = [account_id] if account_id is not None else []
+
 
     def set_node_account_ids(self, node_account_ids: list[AccountId]):
         """
@@ -115,6 +136,12 @@ def set_node_account_id(self, node_account_id: AccountId):
         Returns:
             The current instance of the class for chaining.
         """
+        warnings.warn(
+            "Method 'set_node_account_id()' is deprecated; use 'set_node_account_ids()' instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+
         return self.set_node_account_ids([node_account_id])
 
     def set_max_attempts(self, max_attempts: int):
@@ -346,9 +373,10 @@ def _resolve_execution_config(self, client: Client, timeout: int | float | None)
             if getattr(self, attr) is None:
                 setattr(self, attr, default)
 
-        # nodes to which the executaion must be run against, if not provided used nodes from client
         if not self.node_account_ids:
-            self.node_account_ids = [node._account_id for node in client.network._healthy_nodes]
+            self.node_account_ids = [
+                node._account_id for node in client.network.nodes
+            ]
 
         if not self.node_account_ids:
             raise RuntimeError("No healthy nodes available for execution")
@@ -429,10 +457,10 @@ def _execute(self, client: Client, timeout: int | float | None = None):
             node = client.network._get_node(node_id)
 
             if node is None:
-                raise RuntimeError(f"No node found for node_account_id: {self.node_account_id}")
+                raise RuntimeError(f"No node found for node_account_id: {self._node_account_id}")
 
             # Store for logging and receipts
-            self.node_account_id = node._account_id
+            self._node_account_id = node._account_id
 
             # Create a channel wrapper from the client's channel
             channel = node._get_channel()
@@ -442,7 +470,7 @@ def _execute(self, client: Client, timeout: int | float | None = None):
                 "requestId",
                 self._get_request_id(),
                 "nodeAccountID",
-                self.node_account_id,
+                self._node_account_id,
                 "attempt",
                 attempt + 1,
                 "maxAttempts",
@@ -483,7 +511,7 @@ def _execute(self, client: Client, timeout: int | float | None = None):
             logger.trace(
                 f"{self.__class__.__name__} status received",
                 "nodeAccountID",
-                self.node_account_id,
+                self._node_account_id,
                 "network",
                 client.network.network,
                 "state",
@@ -518,7 +546,7 @@ def _execute(self, client: Client, timeout: int | float | None = None):
                 case _ExecutionState.FINISHED:
                     # If the transaction completed successfully, map the response and return it
                     logger.trace(f"{self.__class__.__name__} finished execution")
-                    return self._map_response(response, self.node_account_id, proto_request)
+                    return self._map_response(response, self._node_account_id, proto_request)
 
         logger.error(
             "Exceeded maximum attempts for request",
@@ -529,7 +557,7 @@ def _execute(self, client: Client, timeout: int | float | None = None):
         )
         raise MaxAttemptsError(
             "Exceeded maximum attempts or request timeout",
-            self.node_account_id,
+            self._node_account_id,
             err_persistant,
         )
 

src/hiero_sdk_python/query/query.py

@@ -179,11 +179,11 @@ def _make_request_header(self) -> query_header_pb2.QueryHeader:
             header.responseType = query_header_pb2.ResponseType.COST_ANSWER
             return header
 
-        if self.operator is not None and self.node_account_id is not None and self.payment_amount is not None:
+        if self.operator is not None and self.node_account_ids[self._node_account_ids_index] is not None and self.payment_amount is not None:
             payment_tx = self._build_query_payment_transaction(
                 payer_account_id=self.operator.account_id,
                 payer_private_key=self.operator.private_key,
-                node_account_id=self.node_account_id,
+                node_account_id=self.node_account_ids[self._node_account_ids_index],
                 amount=self.payment_amount,
             )
             header.payment.CopyFrom(payment_tx)

src/hiero_sdk_python/transaction/transaction.py

@@ -216,9 +216,9 @@ def _to_proto(self):
         # We require the transaction to be frozen before converting to protobuf
         self._require_frozen()
 
-        body_bytes = self._transaction_body_bytes.get(self.node_account_id)
+        body_bytes = self._transaction_body_bytes.get(self._node_account_id)
         if body_bytes is None:
-            raise ValueError(f"No transaction body found for node {self.node_account_id}")
+            raise ValueError(f"No transaction body found for node {self._node_account_id}")
 
         # Get signature map, or create empty one if transaction is not signed
         sig_map = self._signature_map.get(body_bytes)
@@ -245,7 +245,7 @@ def _resolve_transaction_id(self, client: Client):
             )
 
     def _resolve_node_ids(self, client: Client):
-        if self.node_account_id is None and len(self.node_account_ids) == 0 and client is None:
+        if self._node_account_id is None and len(self.node_account_ids) == 0 and client is None:
             raise ValueError(
                 "Node account ID must be set before freezing. Use freeze_with(client) or manually set node_account_ids."
             )
@@ -297,27 +297,27 @@ def freeze_with(self, client: Client):
 
         if self.batch_key:
             # For Inner Transaction of batch transaction node_account_id=0.0.0
-            self.node_account_id = AccountId(0, 0, 0)
-            self._transaction_body_bytes[AccountId(0, 0, 0)] = self.build_transaction_body().SerializeToString()
-            return self
+            self._node_account_id = AccountId(0, 0, 0)
+            self.node_account_ids = [AccountId(0, 0, 0)]
 
-        # Single node
-        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
+            transaction_body = self.build_transaction_body()
+            transaction_body.transactionID.CopyFrom(self.transaction_id._to_proto())
+            transaction_body.nodeAccountID.CopyFrom(self._node_account_id._to_proto())
 
-        # Multiple node
-        if len(self.node_account_ids) > 0:
-            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()
+            self._transaction_body_bytes[AccountId(0, 0, 0)] = transaction_body.SerializeToString()
 
-        else:
-            # Use all nodes from client network
-            for node in client.network.nodes:
-                self.node_account_id = node._account_id
-                self._transaction_body_bytes[node._account_id] = self.build_transaction_body().SerializeToString()
+        # If nodes not set by user use all nodes from client network
+        if len(self.node_account_ids) == 0:
+            self.node_account_ids = [node._account_id for node in client.network.nodes]
+
+        for node_account_id in self.node_account_ids:
+            self._node_account_id = node_account_id
+
+            transaction_body = self.build_transaction_body()
+            transaction_body.transactionID.CopyFrom(self.transaction_id._to_proto())
+            transaction_body.nodeAccountID.CopyFrom(node_account_id._to_proto())
+
+            self._transaction_body_bytes[node_account_id] = transaction_body.SerializeToString()
 
         return self
 
@@ -405,7 +405,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.get(self._node_account_id))
 
         if sig_map is None:
             return False
@@ -452,20 +452,7 @@ def build_base_transaction_body(self) -> transaction_pb2.TransactionBody:
         Raises:
             ValueError: If required IDs are not set.
         """
-        if self.transaction_id is None:
-            if self.operator_account_id is None:
-                raise ValueError("Operator account ID is not set.")
-            self.transaction_id = TransactionId.generate(self.operator_account_id)
-
-        transaction_id_proto = self.transaction_id._to_proto()
-
-        selected_node = self.node_account_id or (self.node_account_ids[0] if self.node_account_ids else None)
-        if selected_node is None:
-            raise ValueError("Node account ID is not set.")
-
         transaction_body = transaction_pb2.TransactionBody()
-        transaction_body.transactionID.CopyFrom(transaction_id_proto)
-        transaction_body.nodeAccountID.CopyFrom(selected_node._to_proto())
 
         fee = self._transaction_fee or self._default_transaction_fee
         if hasattr(fee, "to_tinybars"):

tests/unit/executable_test.py

@@ -838,11 +838,12 @@ def test_executable_overrides_client_config(mock_client):
 
 def test_no_healthy_nodes_raises(mock_client):
     """Test that execution fails if no healthy nodes are available."""
-    mock_client.network._healthy_nodes = []
-
     tx = AccountCreateTransaction().set_key_without_alias(PrivateKey.generate().public_key()).set_initial_balance(1)
 
-    with pytest.raises(RuntimeError, match="No healthy nodes available"):
+    for node in mock_client.network.nodes:
+        node.is_healthy = lambda: False
+
+    with pytest.raises(RuntimeError, match="All nodes are unhealthy"):
         tx.execute(mock_client)
 
 

tests/unit/token_airdrop_transaction_test.py

@@ -161,22 +161,24 @@ def test_add_zero_transfer_amount(mock_account_ids):
         airdrop_tx.add_approved_token_transfer_with_decimals(token_id, account_id, 0, 1)
 
 
+# TODO: Flaing wrong
 def test_add_unbalanced_transfer_amount(mock_account_ids):
     sender, receiver, _, token_id, _ = mock_account_ids
     airdrop_tx = TokenAirdropTransaction()
     airdrop_tx.add_token_transfer(token_id, sender, -1)
     airdrop_tx.add_token_transfer(token_id, receiver, -2)
 
     with pytest.raises(ValueError):
-        airdrop_tx.build_transaction_body()
+        airdrop_tx.freeze()
 
 
+# TODO: Flaing wrong
 def test_add_invalid_transfer(mock_account_ids):
     _, _, _, _, _ = mock_account_ids
     airdrop_tx = TokenAirdropTransaction()
 
     with pytest.raises(ValueError):
-        airdrop_tx.build_transaction_body()
+        airdrop_tx.freeze()
 
 
 def test_sign_transaction(mock_account_ids, mock_client):

tests/unit/token_pause_transaction_test.py

@@ -33,11 +33,9 @@ def test_build_transaction_body(mock_account_ids, token_id):
     pause_tx.operator_account_id = account_id
     pause_tx.node_account_id = node_account_id
 
-    transaction_body = pause_tx.build_transaction_body()  # Will generate a transaction_id
+    transaction_body = pause_tx.build_transaction_body()
 
     assert transaction_body.token_pause.token == token_id._to_proto()
-    assert transaction_body.transactionID == pause_tx.transaction_id._to_proto()
-    assert transaction_body.nodeAccountID == pause_tx.node_account_id._to_proto()
 
 
 def test_build_transaction_body_nft(mock_account_ids, nft_id):
@@ -54,8 +52,9 @@ def test_build_transaction_body_nft(mock_account_ids, nft_id):
     transaction_body = pause_tx.build_transaction_body()
 
     assert transaction_body.token_pause.token == base_token_id._to_proto()
-    assert transaction_body.transactionID == pause_tx.transaction_id._to_proto()
-    assert transaction_body.nodeAccountID == pause_tx.node_account_id._to_proto()
+
+
+# TODO: Test that freeze set the transactionId and the nodeId to transaction_proto_body
 
 
 # This test uses fixture (token_id, mock_client) as parameter

tests/unit/topic_create_transaction_test.py

@@ -220,29 +220,7 @@ def test_build_scheduled_body(mock_account_ids, custom_fixed_fee, key_type, use_
     )
 
 
-# This test uses fixture mock_account_ids as parameter
-def test_missing_operator_in_topic_create(mock_account_ids):
-    """
-    Test that building the body fails if no operator ID is set.
-    """
-    _, _, node_account_id, _, _ = mock_account_ids
-
-    tx = TopicCreateTransaction(memo="No Operator")
-    tx.node_account_id = node_account_id
-
-    with pytest.raises(ValueError, match="Operator account ID is not set."):
-        tx.build_transaction_body()
-
-
-def test_missing_node_in_topic_create():
-    """
-    Test that building the body fails if no node account ID is set.
-    """
-    tx = TopicCreateTransaction(memo="No Node")
-    tx.operator_account_id = AccountId(0, 0, 2)
-
-    with pytest.raises(ValueError, match="Node account ID is not set."):
-        tx.build_transaction_body()
+# TODO: Test for the freeze set the node/transaction id
 
 
 # This test uses fixtures (mock_account_ids, private_key) as parameters

tests/unit/transaction_freeze_and_bytes_test.py

@@ -663,7 +663,7 @@ def test_transaction_freeze_without_node_ids(mock_client):
     tx = TransferTransaction()
     tx.freeze_with(mock_client)
 
-    assert tx.node_account_ids == []
+    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)