htcli 1.1.0__py3-none-any.whl

src/htcli/commands/overwatch/handlers.py

@@ -0,0 +1,443 @@
+"""
+Overwatch command handlers for RPC-based operations and extrinsic operations.
+"""
+
+from typing import Optional
+
+from ...dependencies import get_client
+from ...errors.handlers import handle_and_display_error
+from ...ui.components import HTCLILoadingContext
+from ...utils import retrieve_wallet_with_validation
+from .display import (
+    display_overwatch_list,
+    display_overwatch_node_info,
+    display_overwatch_qualification,
+    display_overwatch_register_result,
+    display_overwatch_remove_result,
+    display_overwatch_peer_id_result,
+    display_overwatch_stake_add_result,
+    display_overwatch_stake_remove_result,
+)
+from .error_handling import handle_overwatch_error
+from .prompts import (
+    prompt_overwatch_register,
+    prompt_overwatch_remove,
+    prompt_overwatch_peer_id,
+    prompt_overwatch_add_stake,
+    prompt_overwatch_remove_stake,
+    prompt_overwatch_node_id,
+)
+
+
+# ============================================================================
+# RPC HANDLERS - Read Operations
+# ============================================================================
+
+
+def check_overwatch_qualification_handler(
+    coldkey: Optional[str] = None,
+    hotkey: Optional[str] = None,
+):
+    """Handle checking if a coldkey can register an overwatch node.
+    
+    This queries all qualification requirements and displays a detailed breakdown
+    of which requirements are met and which are not. Similar to check-activation
+    for subnets, but for overwatch node registration.
+    
+    Args:
+        coldkey: Optional coldkey address or wallet name
+        hotkey: Optional hotkey address or wallet name to validate
+    """
+    from ...utils.wallet.crypto import format_address_display
+    try:
+        # Resolve coldkey address
+        if coldkey is None:
+            from ...ui.prompts import HTCLIPrompt
+            prompt = HTCLIPrompt()
+            coldkey = prompt.text_prompt("Enter coldkey address or wallet name to check")
+        
+        coldkey_display = coldkey  # Save for display before resolution
+        
+        # Resolve wallet name to address if needed
+        if coldkey and not coldkey.startswith("0x"):
+            try:
+                from ...utils.wallet.crypto import get_wallet_info_by_name
+                wallet_info = get_wallet_info_by_name(coldkey, is_hotkey=False)
+                coldkey = wallet_info.get("address") or wallet_info.get("ss58_address")
+                if not coldkey:
+                    from ...ui.display import print_error
+                    print_error(f"Could not get address from wallet")
+                    return
+            except FileNotFoundError:
+                from ...ui.display import print_error
+                print_error(f"Wallet '{coldkey}' not found")
+                return
+        
+        # Resolve hotkey address if provided
+        hotkey_address = None
+        if hotkey:
+            if hotkey.startswith("0x"):
+                hotkey_address = hotkey
+            else:
+                try:
+                    from ...utils.wallet.crypto import get_wallet_info_by_name
+                    hotkey_info = get_wallet_info_by_name(
+                        hotkey, is_hotkey=True, owner_coldkey_name=coldkey_display
+                    )
+                    hotkey_address = (
+                        hotkey_info.get("evm_address") 
+                        or hotkey_info.get("address") 
+                        or hotkey_info.get("ss58_address")
+                    )
+                except FileNotFoundError:
+                    from ...ui.display import print_error
+                    print_error(f"Hotkey wallet '{hotkey}' not found")
+                    return
+        
+        client = get_client()
+
+        if not client.substrate:
+            from ...ui.display import print_error
+            print_error("Not connected to blockchain. Please check your network configuration.")
+            return
+
+        loading_msg = f"Checking overwatch qualification for {format_address_display(coldkey)}"
+        if hotkey_address:
+            loading_msg += f" with hotkey {format_address_display(hotkey_address)}"
+        
+        with HTCLILoadingContext(loading_msg):
+            result = client.rpc.overwatch.check_overwatch_qualification(coldkey, hotkey_address)
+
+        if result.get("success"):
+            display_overwatch_qualification(result["data"])
+        else:
+            from ...ui.display import print_error
+            print_error(f"Failed to check qualification: {result.get('error', 'Unknown error')}")
+
+    except RuntimeError as e:
+        from ...ui.display import print_error
+        print_error(f"Connection Error: {str(e)}")
+        print_error("Please ensure you are connected to the blockchain network")
+    except Exception as e:
+        handle_and_display_error(e, operation="check overwatch qualification")
+
+def list_overwatch_nodes_handler():
+    """Handle listing all overwatch nodes using RPC."""
+    try:
+        client = get_client()
+
+        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 overwatch nodes..."):
+            result = client.rpc.overwatch.list_overwatch_nodes()
+
+        if result is not None:
+            if len(result) == 0:
+                from ...ui.display import print_info
+                print_info("No overwatch nodes found on the network")
+            else:
+                display_overwatch_list(result)
+        else:
+            from ...ui.display import print_error
+            print_error("Failed to retrieve overwatch node information from the blockchain")
+
+    except RuntimeError as e:
+        from ...ui.display import print_error
+        print_error(f"Connection Error: {str(e)}")
+        print_error("Please ensure you are connected to the blockchain network")
+    except Exception as e:
+        handle_and_display_error(e, operation="list overwatch nodes")
+
+
+def get_overwatch_node_info_handler(overwatch_node_id: Optional[int] = None):
+    """Handle getting specific overwatch node information using RPC."""
+    try:
+        if overwatch_node_id is None:
+            overwatch_node_id = prompt_overwatch_node_id()
+
+        client = get_client()
+
+        with HTCLILoadingContext(f"Fetching overwatch node {overwatch_node_id}..."):
+            result = client.rpc.overwatch.get_overwatch_node_info(overwatch_node_id)
+
+        if result:
+            display_overwatch_node_info(result)
+        else:
+            from ...ui.display import print_info
+            print_info(f"Overwatch node {overwatch_node_id} not found")
+
+    except Exception as e:
+        handle_and_display_error(e, operation="get overwatch node info")
+
+
+# ============================================================================
+# EXTRINSIC HANDLERS - Write Operations
+# ============================================================================
+
+
+def register_overwatch_node_handler(
+    hotkey: Optional[str] = None,
+    stake_amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle overwatch node registration."""
+    try:
+        # STEP 1: Get signing wallet (coldkey) first
+        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 overwatch node registration"
+            )
+
+        # STEP 2: Collect parameters via prompts
+        hotkey_address, stake_wei = prompt_overwatch_register(
+            hotkey=hotkey,
+            stake_amount=stake_amount,
+            coldkey_name=wallet_name,
+        )
+
+        # STEP 3: Execute via client
+        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")
+
+        with HTCLILoadingContext("Registering overwatch node..."):
+            response = client.extrinsics.overwatch.register_overwatch_node(
+                hotkey=hotkey_address,
+                stake_to_be_added=stake_wei,
+                keypair=keypair,
+            )
+
+        # STEP 4: Display result
+        display_overwatch_register_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_overwatch_error(error_msg, operation="register overwatch node"):
+            handle_and_display_error(e, operation="register overwatch node")
+
+
+
+def remove_overwatch_node_handler(
+    overwatch_node_id: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle removing an overwatch node."""
+    try:
+        # 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 overwatch node removal"
+            )
+
+        # Collect parameters via prompts
+        if overwatch_node_id is None:
+            overwatch_node_id = prompt_overwatch_remove()
+
+        # Execute via client
+        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")
+
+        with HTCLILoadingContext(f"Removing overwatch node {overwatch_node_id}..."):
+            response = client.extrinsics.overwatch.remove_overwatch_node(
+                overwatch_node_id=overwatch_node_id,
+                keypair=keypair,
+            )
+
+        # Display result
+        display_overwatch_remove_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_overwatch_error(error_msg, overwatch_node_id=overwatch_node_id, operation="remove overwatch node"):
+            handle_and_display_error(e, operation="remove overwatch node")
+
+
+
+def set_overwatch_peer_id_handler(
+    subnet_id: Optional[int] = None,
+    overwatch_node_id: Optional[int] = None,
+    peer_id: Optional[str] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle setting peer ID for an overwatch node."""
+    try:
+        # 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 peer ID update"
+            )
+
+        # Collect parameters via prompts
+        subnet_id, overwatch_node_id, peer_id = prompt_overwatch_peer_id(
+            subnet_id=subnet_id,
+            overwatch_node_id=overwatch_node_id,
+            peer_id=peer_id,
+        )
+
+        # Execute via client
+        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")
+
+        with HTCLILoadingContext(f"Setting peer ID for overwatch node {overwatch_node_id} on subnet {subnet_id}..."):
+            response = client.extrinsics.overwatch.set_overwatch_node_peer_id(
+                subnet_id=subnet_id,
+                overwatch_node_id=overwatch_node_id,
+                peer_id=peer_id,
+                keypair=keypair,
+            )
+
+        # Display result
+        display_overwatch_peer_id_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_overwatch_error(error_msg, overwatch_node_id=overwatch_node_id, operation="set overwatch peer ID"):
+            handle_and_display_error(e, operation="set overwatch peer ID")
+
+
+
+def add_overwatch_stake_handler(
+    overwatch_node_id: Optional[int] = None,
+    hotkey: Optional[str] = None,
+    stake_amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle adding stake to an overwatch node."""
+    try:
+        # 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 overwatch stake addition"
+            )
+
+        # Collect parameters via prompts
+        overwatch_node_id, hotkey_address, stake_wei = prompt_overwatch_add_stake(
+            overwatch_node_id=overwatch_node_id,
+            hotkey=hotkey,
+            stake_amount=stake_amount,
+            coldkey_name=wallet_name,
+        )
+
+        # Execute via client
+        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")
+
+        with HTCLILoadingContext(f"Adding stake to overwatch node {overwatch_node_id}..."):
+            response = client.extrinsics.overwatch.add_to_overwatch_stake(
+                overwatch_node_id=overwatch_node_id,
+                hotkey=hotkey_address,
+                stake_to_be_added=stake_wei,
+                keypair=keypair,
+            )
+
+        # Display result
+        display_overwatch_stake_add_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_overwatch_error(error_msg, overwatch_node_id=overwatch_node_id, operation="add overwatch stake"):
+            handle_and_display_error(e, operation="add overwatch stake")
+
+
+
+def remove_overwatch_stake_handler(
+    hotkey: Optional[str] = None,
+    stake_amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle removing stake from an overwatch node."""
+    try:
+        # 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 overwatch stake removal"
+            )
+
+        # Collect parameters via prompts
+        hotkey_address, stake_wei = prompt_overwatch_remove_stake(
+            hotkey=hotkey,
+            stake_amount=stake_amount,
+            coldkey_name=wallet_name,
+        )
+
+        # Execute via client
+        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")
+
+        with HTCLILoadingContext("Removing stake from overwatch node..."):
+            response = client.extrinsics.overwatch.remove_overwatch_stake(
+                hotkey=hotkey_address,
+                stake_to_be_removed=stake_wei,
+                keypair=keypair,
+            )
+
+        # Display result
+        display_overwatch_stake_remove_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_overwatch_error(error_msg, operation="remove overwatch stake"):
+            handle_and_display_error(e, operation="remove overwatch stake")
+