htcli 1.1.0__py3-none-any.whl

src/htcli/commands/node/handlers.py

@@ -0,0 +1,844 @@
+"""
+Node command handlers for RPC-based operations and extrinsic operations.
+"""
+
+from typing import Any, Optional
+
+from ...dependencies import get_client
+from ...errors.handlers import handle_and_display_error, handle_and_display_node_error
+from ...ui.components import HTCLILoadingContext
+from ...utils import retrieve_wallet_with_validation
+from .display import (
+    display_all_nodes_rpc,
+    display_node_info_rpc,
+    display_node_lifecycle_result,
+    display_node_register_result,
+    display_node_remove_result,
+    display_node_update_summary,
+    display_overwatch_commits_rpc,
+    display_overwatch_reveals_rpc,
+)
+from .error_handling import handle_node_error
+from .prompts import (
+    normalize_delegate_reward_rate,
+    prompt_node_peer_id_update,
+    prompt_node_register,
+    prompt_node_remove,
+)
+
+
+def get_all_nodes_handler():
+    """Handle getting all nodes using RPC."""
+    try:
+        client = get_client()
+
+        # Check if client is connected
+        if not client.substrate:
+            from ...ui.display import print_error
+            print_error("Not connected to blockchain. Please check your network configuration.")
+            return
+
+        with HTCLILoadingContext("Fetching all nodes across all subnets..."):
+            result = client.rpc.node.get_all_subnet_nodes_info()
+
+        # Result can be an empty list (legitimate - no nodes) or None (error)
+        # The RPC method returns [] on error or when no nodes exist
+        if result is not None:
+            if len(result) == 0:
+                from ...ui.display import print_info
+                print_info("No nodes found across all subnets")
+            else:
+                display_all_nodes_rpc(result)
+        else:
+            from ...ui.display import print_error
+            print_error("Failed to retrieve node information from the blockchain")
+
+    except RuntimeError as e:
+        handle_and_display_error(e, operation="list")
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_node_error(error_msg, None, None, "list", client if 'client' in locals() else None):
+            handle_and_display_node_error(e, operation="list")
+
+
+def get_node_info_handler(subnet_id: Optional[int], node_id: Optional[int]):
+    """Handle getting specific node information using RPC."""
+    try:
+        if subnet_id is None:
+            from ...utils.prompts import integer_prompt
+
+            subnet_id = integer_prompt("Enter subnet ID")
+
+        if node_id is None:
+            from ...utils.prompts import integer_prompt
+
+            node_id = integer_prompt("Enter node ID")
+
+        client = get_client()
+
+        with HTCLILoadingContext(f"Fetching node {node_id} in subnet {subnet_id}..."):
+            result = client.rpc.node.get_subnet_node_info(subnet_id, node_id)
+
+        if result:
+            display_node_info_rpc(result, subnet_id, node_id)
+        else:
+            from ...ui.display import print_info
+
+            print_info(f"Node {node_id} not found in subnet {subnet_id}")
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_node_error(error_msg, subnet_id, node_id, "info", client if 'client' in locals() else None):
+            handle_and_display_node_error(e, operation="info")
+
+
+def get_overwatch_commits_handler(
+    epoch: Optional[int], overwatch_node_id: Optional[int]
+):
+    """Handle getting overwatch commits using RPC."""
+    try:
+        if epoch is None:
+            from ...utils.prompts import integer_prompt
+
+            epoch = integer_prompt("Enter epoch number")
+
+        if overwatch_node_id is None:
+            from ...utils.prompts import integer_prompt
+
+            overwatch_node_id = integer_prompt("Enter overwatch node ID")
+
+        client = get_client()
+
+        with HTCLILoadingContext(
+            f"Fetching overwatch commits for epoch {epoch}, node {overwatch_node_id}..."
+        ):
+            result = client.rpc.overwatch.get_overwatch_commits_for_epoch_and_node(
+                epoch, overwatch_node_id
+            )
+
+        if result:
+            display_overwatch_commits_rpc(result, epoch, overwatch_node_id)
+        else:
+            from ...ui.display import print_error
+
+            print_error(f"Failed to get overwatch commits for epoch {epoch}, node {overwatch_node_id}")
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_node_error(error_msg, None, overwatch_node_id, "overwatch-commits", client if 'client' in locals() else None):
+            handle_and_display_node_error(e, operation="overwatch-commits")
+
+
+def get_overwatch_reveals_handler(
+    epoch: Optional[int], overwatch_node_id: Optional[int]
+):
+    """Handle getting overwatch reveals using RPC."""
+    try:
+        if epoch is None:
+            from ...utils.prompts import integer_prompt
+
+            epoch = integer_prompt("Enter epoch number")
+
+        if overwatch_node_id is None:
+            from ...utils.prompts import integer_prompt
+
+            overwatch_node_id = integer_prompt("Enter overwatch node ID")
+
+        client = get_client()
+
+        with HTCLILoadingContext(
+            f"Fetching overwatch reveals for epoch {epoch}, node {overwatch_node_id}..."
+        ):
+            result = client.rpc.overwatch.get_overwatch_reveals_for_epoch_and_node(
+                epoch, overwatch_node_id
+            )
+
+        if result:
+            display_overwatch_reveals_rpc(result, epoch, overwatch_node_id)
+        else:
+            from ...ui.display import print_error
+
+            print_error(f"Failed to get overwatch reveals for epoch {epoch}, node {overwatch_node_id}")
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_node_error(error_msg, None, overwatch_node_id, "overwatch-reveals", client if 'client' in locals() else None):
+            handle_and_display_node_error(e, operation="overwatch-reveals")
+
+
+# ============================================================================
+# EXTRINSIC HANDLERS - Write Operations
+# ============================================================================
+
+
+def register_node_handler(
+    subnet_id: Optional[int] = None,
+    validator_id: Optional[int] = None,
+    hotkey: Optional[str] = None,
+    stake_amount: Optional[float] = None,
+    peer_id: Optional[str] = None,
+    bootnode_peer_id: Optional[str] = None,
+    client_peer_id: Optional[str] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle node registration on a subnet."""
+    try:
+        from ...ui.display import print_error
+        from ...utils.validation import validate_stake_amount_prompt
+
+        def validate_cli_peer_id(label: str, value: Optional[str]) -> None:
+            if value is None:
+                return
+            if not value or not value.isalnum():
+                raise ValueError(f"Invalid {label}: must contain only letters and numbers")
+
+        if stake_amount is not None:
+            is_valid, error_msg = validate_stake_amount_prompt(stake_amount)
+            if not is_valid:
+                print_error(f"Invalid stake amount: {error_msg}")
+                raise ValueError(f"Invalid stake amount: {error_msg}")
+
+        try:
+            validate_cli_peer_id("peer_id", peer_id)
+            validate_cli_peer_id("bootnode_peer_id", bootnode_peer_id)
+            validate_cli_peer_id("client_peer_id", client_peer_id)
+        except ValueError as e:
+            print_error(str(e))
+            raise
+
+        # STEP 1: Get signing wallet (coldkey) FIRST so we can use it for hotkey disambiguation
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey", purpose="sign the node registration transaction"
+            )
+
+        # STEP 2: Collect parameters via prompts (now with coldkey context for hotkey disambiguation)
+        request = prompt_node_register(
+            subnet_id=subnet_id,
+            validator_id=validator_id,
+            hotkey=hotkey,
+            stake_amount=stake_amount,
+            peer_id=peer_id,
+            bootnode_peer_id=bootnode_peer_id,
+            client_peer_id=client_peer_id,
+            coldkey_name=wallet_name,  # Pass coldkey name for hotkey disambiguation
+        )
+
+        # STEP 3: Execute via client
+        client = get_client()
+
+        # Ensure connection is established
+        if not client.connect():
+            from ...ui.display import print_error
+            print_error("Failed to connect to blockchain")
+            return
+
+        # Check if substrate connection is available
+        if not client.substrate:
+            from ...ui.display import print_error
+            print_error("Blockchain connection failed!")
+            raise RuntimeError("Not connected to blockchain")
+
+        # Check if extrinsics layer is initialized
+        if not client.extrinsics:
+            from ...ui.display import print_error
+            print_error("Extrinsics layer not initialized. Connection may have failed.")
+            raise RuntimeError("Extrinsics layer not available")
+
+        # Get the actual EVM address from wallet info (not from keypair.ss58_address which returns public key)
+        from ...utils.logging import get_logger
+        from ...utils.wallet.crypto import get_wallet_info_by_name
+
+        logger = get_logger(__name__)
+        wallet_info = get_wallet_info_by_name(wallet_name, is_hotkey=False)
+        resolved_coldkey_address = wallet_info.get("evm_address") or wallet_info.get("ss58_address") or wallet_info.get("address")
+
+        logger.debug(f"Wallet '{wallet_name}' info: {wallet_info}")
+        logger.debug(f"keypair.ss58_address: {keypair.ss58_address}")
+        logger.debug(f"Resolved coldkey address (from wallet info): {resolved_coldkey_address}")
+        logger.debug(f"Using coldkey wallet '{wallet_name}' ({resolved_coldkey_address}) to sign node registration")
+
+        with HTCLILoadingContext(f"Registering node on subnet {request.subnet_id}..."):
+            response = client.extrinsics.node.register_subnet_node(request, keypair)
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Registration failed")
+            if handle_node_error(error_msg, request.subnet_id, None, "register", client):
+                return
+
+        # STEP 4: Display result
+        display_node_register_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        # Extract subnet_id and client if available
+        subnet_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if 'request' in locals() else None
+            client_for_error = client if 'client' in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_node_error(error_msg, subnet_id_for_error, None, "register", client_for_error):
+            handle_and_display_node_error(e, operation="register")
+
+
+def update_node_handler(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    peer_id: Optional[str] = None,
+    bootnode: Optional[str] = None,
+    bootnode_peer_id: Optional[str] = None,
+    client_peer_id: Optional[str] = None,
+    delegate_reward_rate: Optional[int] = None,
+    unique: Optional[str] = None,
+    non_unique: Optional[str] = None,
+    coldkey: Optional[str] = None,
+):
+    """
+    Unified handler for updating a subnet node.
+
+    All updatable fields are optional. Any field provided will be updated
+    sequentially, and a consolidated summary will be displayed.
+    """
+    try:
+        from ...ui.display import print_error
+        from ...utils.blockchain.peer_id import validate_peer_id_format
+
+        # Ensure we know which node to update
+        if subnet_id is None or node_id is None:
+            from ...utils.prompts import integer_prompt
+
+            if subnet_id is None:
+                subnet_id = integer_prompt("Enter the Subnet ID", min_value=0)
+            if node_id is None:
+                node_id = integer_prompt("Enter the Node ID", min_value=0)
+
+        # Validate that at least one field is provided
+        if (
+            peer_id is None
+            and bootnode is None
+            and bootnode_peer_id is None
+            and client_peer_id is None
+            and delegate_reward_rate is None
+            and unique is None
+            and non_unique is None
+        ):
+            print_error(
+                "Error: At least one update parameter must be provided "
+                "(e.g. --peer-id, --bootnode, --bootnode-peer-id, --client-peer-id, "
+                "--delegate-rate, --unique, --non-unique)."
+            )
+            raise ValueError("No update fields provided")
+
+        # Basic validation for peer IDs if provided
+        def _validate_peer(label: str, value: Optional[str]) -> None:
+            if value is None:
+                return
+            if not isinstance(value, str) or not value:
+                raise ValueError(f"{label} must be a non-empty string")
+            if not validate_peer_id_format(value):
+                raise ValueError(
+                    f"Invalid {label} format: must be a valid base58-encoded multihash "
+                    "(e.g., starting with 'Qm', '12D3KooW', or '1')"
+                )
+
+        try:
+            _validate_peer("peer_id", peer_id)
+            _validate_peer("bootnode_peer_id", bootnode_peer_id)
+            _validate_peer("client_peer_id", client_peer_id)
+        except ValueError as ve:
+            print_error(str(ve))
+            raise
+
+        # Normalize delegate reward rate: accept 0-100 as %, otherwise treat as 1e18 format
+        delegate_rate_value: Optional[int] = None
+        if delegate_reward_rate is not None:
+            try:
+                delegate_rate_value = normalize_delegate_reward_rate(
+                    delegate_reward_rate
+                )
+            except ValueError as ve:
+                print_error(f"Invalid delegate reward rate: {ve}")
+                raise
+
+        # Get signing wallet (coldkey)
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the node update transaction",
+            )
+
+        client = get_client()
+
+        # Ensure connection is established
+        if not client.connect():
+            print_error("Failed to connect to blockchain")
+            return
+
+        if not client.substrate:
+            print_error("Blockchain connection failed!")
+            raise RuntimeError("Not connected to blockchain")
+
+        if not client.extrinsics:
+            print_error(
+                "Extrinsics layer not initialized. Connection may have failed."
+            )
+            raise RuntimeError("Extrinsics layer not available")
+
+        # Fetch current node info once for old-value display (best-effort)
+        current_node_info = None
+        try:
+            current_node_info = client.rpc.node.get_subnet_node_info(
+                subnet_id, node_id
+            )
+        except Exception:
+            current_node_info = None
+
+        def _safe_decode_bytes(value: Any) -> Optional[str]:
+            if value is None:
+                return None
+            if isinstance(value, bytes):
+                try:
+                    return value.decode("utf-8", errors="ignore")
+                except Exception:
+                    return str(value)
+            return str(value)
+
+        updates: list[dict[str, Any]] = []
+
+        # Compute old values (best-effort) for summary
+        if peer_id is not None:
+            old_peer = (
+                _safe_decode_bytes(current_node_info.peer_id)
+                if current_node_info is not None
+                else None
+            )
+        else:
+            old_peer = None
+
+        if bootnode is not None:
+            old_bootnode = (
+                _safe_decode_bytes(current_node_info.bootnode)
+                if current_node_info is not None
+                else None
+            )
+        else:
+            old_bootnode = None
+
+        if bootnode_peer_id is not None:
+            old_bootnode_peer = (
+                _safe_decode_bytes(current_node_info.bootnode_peer_id)
+                if current_node_info is not None
+                else None
+            )
+        else:
+            old_bootnode_peer = None
+
+        if client_peer_id is not None:
+            old_client_peer = (
+                _safe_decode_bytes(current_node_info.client_peer_id)
+                if current_node_info is not None
+                else None
+            )
+        else:
+            old_client_peer = None
+
+        if delegate_rate_value is not None:
+            old_rate = (
+                getattr(current_node_info, "delegate_reward_rate", None)
+                if current_node_info is not None
+                else None
+            )
+        else:
+            old_rate = None
+
+        if unique is not None:
+            old_unique = (
+                _safe_decode_bytes(current_node_info.unique)
+                if current_node_info is not None
+                else None
+            )
+        else:
+            old_unique = None
+
+        if non_unique is not None:
+            old_non_unique = (
+                _safe_decode_bytes(current_node_info.non_unique)
+                if current_node_info is not None
+                else None
+            )
+        else:
+            old_non_unique = None
+
+        # Delegate all extrinsic calls to the client layer
+        with HTCLILoadingContext(
+            f"Updating node {node_id} on subnet {subnet_id}..."
+        ):
+            raw_results = client.extrinsics.node.update_subnet_node_parameters(
+                subnet_id=subnet_id,
+                subnet_node_id=node_id,
+                peer_id=peer_id,
+                bootnode=bootnode,
+                bootnode_peer_id=bootnode_peer_id,
+                client_peer_id=client_peer_id,
+                delegate_reward_rate=delegate_rate_value,
+                unique=unique,
+                non_unique=non_unique,
+                keypair=keypair,
+            )
+
+        # Attach old/new values for summary display
+        for entry in raw_results:
+            field = entry.get("field")
+            result = entry.get("result")
+            if field == "peer_id":
+                updates.append(
+                    {
+                        "field": field,
+                        "old": old_peer,
+                        "new": peer_id,
+                        "result": result,
+                    }
+                )
+            elif field == "bootnode":
+                updates.append(
+                    {
+                        "field": field,
+                        "old": old_bootnode,
+                        "new": bootnode,
+                        "result": result,
+                    }
+                )
+            elif field == "bootnode_peer_id":
+                updates.append(
+                    {
+                        "field": field,
+                        "old": old_bootnode_peer,
+                        "new": bootnode_peer_id,
+                        "result": result,
+                    }
+                )
+            elif field == "client_peer_id":
+                updates.append(
+                    {
+                        "field": field,
+                        "old": old_client_peer,
+                        "new": client_peer_id,
+                        "result": result,
+                    }
+                )
+            elif field == "delegate_reward_rate":
+                updates.append(
+                    {
+                        "field": field,
+                        "old": old_rate,
+                        "new": delegate_rate_value,
+                        "result": result,
+                    }
+                )
+            elif field == "unique":
+                updates.append(
+                    {
+                        "field": field,
+                        "old": old_unique,
+                        "new": unique,
+                        "result": result,
+                    }
+                )
+            elif field == "non_unique":
+                updates.append(
+                    {
+                        "field": field,
+                        "old": old_non_unique,
+                        "new": non_unique,
+                        "result": result,
+                    }
+                )
+
+        # Check for errors in results
+        for entry in updates:
+            result = entry.get("result")
+            if isinstance(result, dict) and not result.get("success", False):
+                error_msg = result.get("error", "Update failed")
+                field = entry.get("field", "update")
+                if handle_node_error(error_msg, subnet_id, node_id, f"update {field}", client):
+                    return
+
+        # Display consolidated summary
+        if updates:
+            display_node_update_summary(
+                subnet_id=subnet_id,
+                node_id=node_id,
+                updates=updates,
+                client=client,
+            )
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_node_error(error_msg, subnet_id, node_id, "update", client if 'client' in locals() else None):
+            handle_and_display_node_error(e, operation="update")
+
+
+def update_node_bootnode_peer_id_handler(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    bootnode_peer_id: Optional[str] = None,
+    coldkey: Optional[str] = None,
+):
+    """
+    Backwards-compatible wrapper to update only the bootnode peer ID.
+    """
+    # Collect parameters via prompts if needed, then delegate to unified handler
+    if subnet_id is None or node_id is None or bootnode_peer_id is None:
+        subnet_id, node_id, peer = prompt_node_peer_id_update(
+            subnet_id=subnet_id,
+            node_id=node_id,
+            peer_id=bootnode_peer_id,
+            peer_id_type="bootnode_peer_id",
+        )
+        bootnode_peer_id = peer
+
+    update_node_handler(
+        subnet_id=subnet_id,
+        node_id=node_id,
+        bootnode_peer_id=bootnode_peer_id,
+        coldkey=coldkey,
+    )
+
+
+def update_node_client_peer_id_handler(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    client_peer_id: Optional[str] = None,
+    coldkey: Optional[str] = None,
+):
+    """
+    Backwards-compatible wrapper to update only the client peer ID.
+    """
+    # Collect parameters via prompts if needed, then delegate to unified handler
+    if subnet_id is None or node_id is None or client_peer_id is None:
+        subnet_id, node_id, peer = prompt_node_peer_id_update(
+            subnet_id=subnet_id,
+            node_id=node_id,
+            peer_id=client_peer_id,
+            peer_id_type="client_peer_id",
+        )
+        client_peer_id = peer
+
+    update_node_handler(
+        subnet_id=subnet_id,
+        node_id=node_id,
+        client_peer_id=client_peer_id,
+        coldkey=coldkey,
+    )
+
+
+def remove_node_handler(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle removing a node from a subnet."""
+    try:
+        from ...models.requests.node import SubnetNodeRemoveRequest
+
+        # Collect IDs if missing
+        if subnet_id is None or node_id is None:
+            subnet_id, node_id = prompt_node_remove(subnet_id=subnet_id, node_id=node_id)
+
+        # Get signing wallet (coldkey)
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the node removal transaction",
+            )
+
+        client = get_client()
+
+        # Ensure connection
+        if not client.connect():
+            from ...ui.display import print_error
+
+            print_error("Failed to connect to blockchain")
+            return
+
+        if not client.substrate:
+            from ...ui.display import print_error
+
+            print_error("Blockchain connection failed!")
+            raise RuntimeError("Not connected to blockchain")
+
+        if not client.extrinsics:
+            from ...ui.display import print_error
+
+            print_error(
+                "Extrinsics layer not initialized. Connection may have failed."
+            )
+            raise RuntimeError("Extrinsics layer not available")
+
+        request = SubnetNodeRemoveRequest(
+            subnet_id=subnet_id,
+            subnet_node_id=node_id,
+        )
+
+        with HTCLILoadingContext(
+            f"Removing node {node_id} from subnet {subnet_id}..."
+        ):
+            result = client.extrinsics.node.remove_subnet_node(request, keypair)
+
+        # Check for errors in result
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Removal failed")
+            if handle_node_error(error_msg, subnet_id, node_id, "remove", client):
+                return
+
+        display_node_remove_result(result, subnet_id, node_id)
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_node_error(error_msg, subnet_id, node_id, "remove", client if 'client' in locals() else None):
+            handle_and_display_node_error(e, operation="remove")
+
+
+def _resolve_node_lifecycle_ids(
+    subnet_id: Optional[int],
+    node_id: Optional[int],
+    action: str,
+) -> tuple[int, int]:
+    """Prompt for lifecycle command IDs when CLI options are omitted."""
+    if subnet_id is None or node_id is None:
+        from ...utils.prompts import integer_prompt
+
+        if subnet_id is None:
+            subnet_id = integer_prompt(f"Enter subnet ID to {action} node", min_value=0)
+        if node_id is None:
+            node_id = integer_prompt(f"Enter node ID to {action}", min_value=0)
+
+    return subnet_id, node_id
+
+
+def _node_lifecycle_handler(
+    *,
+    subnet_id: Optional[int],
+    node_id: Optional[int],
+    coldkey: Optional[str],
+    action: str,
+):
+    """Submit a node activation/deactivation extrinsic."""
+    try:
+        from ...models.requests.node import (
+            SubnetNodeActivateRequest,
+            SubnetNodePauseRequest,
+        )
+
+        subnet_id, node_id = _resolve_node_lifecycle_ids(subnet_id, node_id, action)
+
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            _, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            _, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose=f"sign the node {action} transaction",
+            )
+
+        client = get_client()
+
+        if not client.connect():
+            from ...ui.display import print_error
+
+            print_error("Failed to connect to blockchain")
+            return
+
+        if not client.substrate:
+            from ...ui.display import print_error
+
+            print_error("Blockchain connection failed!")
+            raise RuntimeError("Not connected to blockchain")
+
+        if not client.extrinsics:
+            from ...ui.display import print_error
+
+            print_error(
+                "Extrinsics layer not initialized. Connection may have failed."
+            )
+            raise RuntimeError("Extrinsics layer not available")
+
+        if action == "activate":
+            request = SubnetNodeActivateRequest(
+                subnet_id=subnet_id,
+                subnet_node_id=node_id,
+            )
+            submit = client.extrinsics.node.activate_subnet_node
+            loading_message = f"Activating node {node_id} on subnet {subnet_id}..."
+        elif action == "deactivate":
+            request = SubnetNodePauseRequest(
+                subnet_id=subnet_id,
+                subnet_node_id=node_id,
+            )
+            submit = client.extrinsics.node.pause_subnet_node
+            loading_message = f"Deactivating node {node_id} on subnet {subnet_id}..."
+        else:
+            raise ValueError(f"Unsupported node lifecycle action: {action}")
+
+        with HTCLILoadingContext(loading_message):
+            result = submit(request, keypair)
+
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", f"Node {action} failed")
+            if handle_node_error(error_msg, subnet_id, node_id, action, client):
+                return
+
+        display_node_lifecycle_result(result, subnet_id, node_id, action)
+
+    except Exception as e:
+        error_msg = str(e)
+        client_for_error = client if "client" in locals() else None
+        if not handle_node_error(
+            error_msg, subnet_id, node_id, action, client_for_error
+        ):
+            handle_and_display_node_error(e, operation=action)
+
+
+def activate_node_handler(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle activating a node on a subnet."""
+    _node_lifecycle_handler(
+        subnet_id=subnet_id,
+        node_id=node_id,
+        coldkey=coldkey,
+        action="activate",
+    )
+
+
+def deactivate_node_handler(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle deactivating a node on a subnet."""
+    _node_lifecycle_handler(
+        subnet_id=subnet_id,
+        node_id=node_id,
+        coldkey=coldkey,
+        action="deactivate",
+    )