chore: updated the mirrorstub to update on mirronode address change

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

Author: manishdait

src/hiero_sdk_python/client/client.py

@@ -57,9 +57,6 @@ def __init__(self, network: Network = None) -> None:
 
         self.network: Network = network
 
-        self.mirror_channel: grpc.Channel = None
-        self.mirror_stub: mirror_consensus_grpc.ConsensusServiceStub = None
-
         self.max_attempts: int = 10
         self.default_max_query_payment: Hbar = DEFAULT_MAX_QUERY_PAYMENT
 
@@ -69,10 +66,17 @@ def __init__(self, network: Network = None) -> None:
         self._grpc_deadline: float = DEFAULT_GRPC_DEADLINE
         self._request_timeout: float = DEFAULT_REQUEST_TIMEOUT
 
-        self._init_mirror_stub()
-
         self.logger: Logger = Logger(LogLevel.from_env(), "hiero_sdk_python")
 
+    @property
+    def mirror_stub(self) -> mirror_consensus_grpc.ConsensusServiceStub | None:
+        return self.network.get_mirror_stub()
+
+    @property
+    def mirror_channel(self) -> grpc.Channel | None:
+        self.network.get_mirror_stub()
+        return self.network._mirror_channel
+
     @classmethod
     def from_env(cls, network: NetworkName | None = None) -> Client:
         """
@@ -180,19 +184,6 @@ def for_network(cls, network_map: dict[str, AccountId], network_name: str | None
         nodes = [_Node(account_id, address, None) for address, account_id in network_map.items()]
         return cls(Network(network=network_name, nodes=nodes))
 
-    def _init_mirror_stub(self) -> None:
-        """
-        Connect to a mirror node for topic message subscriptions.
-        Mirror nodes always use TLS (mandatory). We use self.network.get_mirror_address()
-        for a configurable mirror address, which should use port 443 for HTTPS connections.
-        """
-        mirror_address = self.network.get_mirror_address()
-        if mirror_address.endswith(":50212") or mirror_address.endswith(":443"):
-            self.mirror_channel = grpc.secure_channel(mirror_address, grpc.ssl_channel_credentials())
-        else:
-            self.mirror_channel = grpc.insecure_channel(mirror_address)
-        self.mirror_stub = mirror_consensus_grpc.ConsensusServiceStub(self.mirror_channel)
-
     def set_operator(self, account_id: AccountId, private_key: PrivateKey) -> None:
         """Sets the operator credentials (account ID and private key)."""
         self.operator_account_id = account_id
@@ -228,11 +219,7 @@ def close(self) -> None:
         Closes any open gRPC channels and frees resources.
         Call this when you are done using the Client to ensure a clean shutdown.
         """
-        if self.mirror_channel is not None:
-            self.mirror_channel.close()
-            self.mirror_channel = None
-
-        self.mirror_stub = None
+        self.network.close_mirror_connection()
 
     def set_transport_security(self, enabled: bool) -> Client:
         """

src/hiero_sdk_python/client/network.py

@@ -6,10 +6,12 @@
 import time
 from typing import Any
 
+import grpc
 import requests
 
 from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.address_book.node_address import NodeAddress
+from hiero_sdk_python.hapi.mirror import consensus_service_pb2_grpc as mirror_consensus_grpc
 from hiero_sdk_python.node import _Node
 
 
@@ -97,7 +99,9 @@ def __init__(
             Use Client.set_transport_security() and Client.set_verify_certificates() to customize.
         """
         self.network: str = network or "localhost"
-        self.mirror_address: str = mirror_address or self.MIRROR_ADDRESS_DEFAULT.get(network, "localhost:5600")
+        self._mirror_address: str = mirror_address or self.MIRROR_ADDRESS_DEFAULT.get(network, "localhost:5600")
+        self._mirror_channel = None
+        self._mirror_stub: mirror_consensus_grpc.ConsensusServiceStub = None
 
         self.ledger_id = ledger_id or self.LEDGER_ID.get(network, bytes.fromhex("03"))
 
@@ -122,6 +126,17 @@ def __init__(
         self._node_index: int = secrets.randbelow(len(self._healthy_nodes))
         self.current_node: _Node = self._healthy_nodes[self._node_index]
 
+    @property
+    def mirror_address(self) -> str:
+        return self._mirror_address
+
+    @mirror_address.setter
+    def mirror_address(self, value: str):
+        """Reset the connection when the address changes."""
+        if self._mirror_address != value:
+            self._mirror_address = value
+            self.close_mirror_connection()
+
     def _set_network_nodes(self, nodes: list[_Node] | None = None):
         """Configure the consensus nodes used by this network."""
         final_nodes = self._resolve_nodes(nodes)
@@ -406,3 +421,25 @@ def _mark_node_healthy(self, node: _Node) -> None:
 
         if node not in self._healthy_nodes:
             self._healthy_nodes.append(node)
+
+    def close_mirror_connection(self):
+        """Safely closes the mirror gRPC channel."""
+        if self._mirror_channel is not None:
+            self._mirror_channel.close()
+
+        self._mirror_channel = None
+        self._mirror_stub = None
+
+    def get_mirror_stub(self) -> mirror_consensus_grpc.ConsensusServiceStub:
+        """Returns the mirror stub."""
+        if self._mirror_stub is None:
+            addr = self._mirror_address
+
+            if addr.endswith(":50212") or addr.endswith(":443"):
+                self._mirror_channel = grpc.secure_channel(addr, grpc.ssl_channel_credentials())
+            else:
+                self._mirror_channel = grpc.insecure_channel(addr)
+
+            self._mirror_stub = mirror_consensus_grpc.ConsensusServiceStub(self._mirror_channel)
+
+        return self._mirror_stub

tests/unit/network_test.py

@@ -3,6 +3,7 @@
 import time
 from unittest.mock import Mock, patch
 
+import grpc
 import pytest
 
 from hiero_sdk_python.account.account_id import AccountId
@@ -487,7 +488,7 @@ def test_non_hosted_network_respects_port_50211(network):
     """Test that on non-hosted network, port 50211 stays 50211 and remains non-tls."""
     node_50211 = _Node(AccountId(0, 0, 3), "127.0.0.1:50211", None)
 
-    network = Network(network=None, nodes=[node_50211])
+    network = Network(network=network, nodes=[node_50211])
 
     assert ":50211" in str(network.nodes[0]._address)
     assert network.nodes[0]._address._is_transport_security() is False
@@ -504,3 +505,70 @@ def test_non_hosted_network_respect_port_50212(network):
     assert ":50212" in str(network.nodes[0]._address)
     assert network.nodes[0]._address._is_transport_security() is True
     assert network._transport_security is False
+
+
+def test_mirror_address_setter_resets_connection(monkeypatch):
+    """Test  updating the mirror_address automatically closes the existing connection and the stub."""
+    network = Network("testnet", mirror_address="old.mirror:5600")
+
+    mock_channel = Mock(spec=grpc.Channel)
+    network._mirror_channel = mock_channel
+    network._mirror_stub = Mock()
+
+    network.mirror_address = "new.mirror:5600"
+
+    mock_channel.close.assert_called_once()
+    assert network._mirror_channel is None
+    assert network._mirror_stub is None
+    assert network.mirror_address == "new.mirror:5600"
+
+
+def test_mirror_address_setter_no_op_on_same_value():
+    """Test that setting the mirror_address to the current value does not reset the connection."""
+    network = Network("testnet", mirror_address="same.mirror:5600")
+
+    mock_channel = Mock(spec=grpc.Channel)
+    network._mirror_channel = mock_channel
+    network._mirror_stub = Mock()
+
+    network.mirror_address = "same.mirror:5600"
+
+    mock_channel.close.assert_not_called()
+    assert network._mirror_stub is not None
+
+
+def test_get_mirror_stub_initializes_secure_channel():
+    """Test that get_mirror_stub creates a secure channel for ports 50212 or 443."""
+    network = Network("testnet", mirror_address="hiero.mirror:50212")
+
+    with (
+        patch("grpc.secure_channel") as mock_secure,
+        patch("hiero_sdk_python.client.network.mirror_consensus_grpc.ConsensusServiceStub"),
+    ):
+        network.get_mirror_stub()
+
+    mock_secure.assert_called_once()
+    args, kwargs = mock_secure.call_args
+    assert any(isinstance(arg, grpc.ChannelCredentials) for arg in args) or "credentials" in kwargs
+
+
+def test_get_mirror_stub_initializes_insecure_channel():
+    """Test get_mirror_stub creates an insecure channel for standard ports."""
+    network = Network("testnet", mirror_address="localhost:5600")
+
+    with (
+        patch("grpc.insecure_channel") as mock_insecure,
+        patch("hiero_sdk_python.client.network.mirror_consensus_grpc.ConsensusServiceStub"),
+    ):
+        network.get_mirror_stub()
+
+    mock_insecure.assert_called_once_with("localhost:5600")
+
+
+def test_close_mirror_connection_is_safe_when_none():
+    """Test close_mirror_connection if no connection exists."""
+    network = Network("testnet")
+    network._mirror_channel = None
+
+    network.close_mirror_connection()
+    assert network._mirror_stub is None