htcli 1.1.0__py3-none-any.whl

src/htcli/client/extrinsics/overwatch.py

@@ -0,0 +1,401 @@
+"""
+Overwatch node extrinsics for HTCLI.
+
+Provides extrinsic operations for overwatch nodes including registration,
+removal, staking, and peer ID management.
+"""
+
+from typing import Any, Optional
+
+from substrateinterface import Keypair, SubstrateInterface
+
+from ...utils.logging import get_logger
+from .base import BaseExtrinsicClient, get_user_friendly_error
+
+logger = get_logger(__name__)
+
+
+class OverwatchExtrinsics(BaseExtrinsicClient):
+    """Client for overwatch node-related extrinsics."""
+
+    def __init__(self, substrate: Optional[SubstrateInterface] = None):
+        """Initialize the overwatch client."""
+        super().__init__(substrate)
+
+    # ============================================================================
+    # NODE REGISTRATION & REMOVAL
+    # ============================================================================
+
+    def register_overwatch_node(
+        self, hotkey: str, stake_to_be_added: int, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Register a new overwatch node.
+
+        Args:
+            hotkey: The hotkey account ID for the overwatch node
+            stake_to_be_added: Initial stake amount in wei
+            keypair: Coldkey keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Registering overwatch node with hotkey {hotkey[:16]}... "
+                f"and stake {stake_to_be_added / 1e18:.4f} TENSOR"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="register_overwatch_node",
+                call_params={
+                    "hotkey": hotkey,
+                    "stake_to_be_added": stake_to_be_added,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                # Query the latest TotalOverwatchNodeUids to get the newly assigned ID
+                # Note: The registration code doesn't emit an event with the ID,
+                # so we query storage directly. The new node got the latest UID.
+                overwatch_node_id = None
+                try:
+                    total_uids_result = self.substrate.query(
+                        module="Network",
+                        storage_function="TotalOverwatchNodeUids",
+                    )
+                    if total_uids_result and total_uids_result.value:
+                        overwatch_node_id = total_uids_result.value
+                except Exception as query_error:
+                    logger.warning(f"Could not query overwatch node ID: {query_error}")
+
+                return {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "overwatch_node_id": overwatch_node_id,
+                    "hotkey": hotkey,
+                    "stake_added": stake_to_be_added,
+                    "message": f"Successfully registered overwatch node with {stake_to_be_added / 1e18:.4f} TENSOR stake",
+                }
+
+            else:
+                error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+                return {
+                    "success": False,
+                    "error": error_msg,
+                    "message": f"Failed to register overwatch node: {error_msg}",
+                }
+
+        except Exception as e:
+            logger.error(f"Error registering overwatch node: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Error registering overwatch node: {str(e)}",
+            }
+
+    def remove_overwatch_node(
+        self, overwatch_node_id: int, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove an overwatch node (owner only).
+
+        Args:
+            overwatch_node_id: The overwatch node ID to remove
+            keypair: Coldkey keypair for signing (must be node owner)
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(f"Removing overwatch node {overwatch_node_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="remove_overwatch_node",
+                call_params={
+                    "overwatch_node_id": overwatch_node_id,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "overwatch_node_id": overwatch_node_id,
+                    "message": f"Successfully removed overwatch node {overwatch_node_id}",
+                }
+            else:
+                error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+                return {
+                    "success": False,
+                    "error": error_msg,
+                    "message": f"Failed to remove overwatch node: {error_msg}",
+                }
+
+        except Exception as e:
+            logger.error(f"Error removing overwatch node: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Error removing overwatch node: {str(e)}",
+            }
+
+    def anyone_remove_overwatch_node(
+        self, overwatch_node_id: int, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove an unqualified overwatch node (anyone can call).
+
+        This can only be called if the overwatch node is no longer qualified.
+
+        Args:
+            overwatch_node_id: The overwatch node ID to remove
+            keypair: Any keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(f"Attempting to remove unqualified overwatch node {overwatch_node_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="anyone_remove_overwatch_node",
+                call_params={
+                    "overwatch_node_id": overwatch_node_id,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "overwatch_node_id": overwatch_node_id,
+                    "message": f"Successfully removed unqualified overwatch node {overwatch_node_id}",
+                }
+            else:
+                error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+                return {
+                    "success": False,
+                    "error": error_msg,
+                    "message": f"Failed to remove overwatch node: {error_msg}",
+                }
+
+        except Exception as e:
+            logger.error(f"Error removing overwatch node: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Error removing overwatch node: {str(e)}",
+            }
+
+    # ============================================================================
+    # PEER ID MANAGEMENT
+    # ============================================================================
+
+    def set_overwatch_node_peer_id(
+        self,
+        subnet_id: int,
+        overwatch_node_id: int,
+        peer_id: str,
+        keypair: Keypair,
+    ) -> dict[str, Any]:
+        """
+        Set the peer ID for an overwatch node on a specific subnet.
+
+        Args:
+            subnet_id: The subnet ID
+            overwatch_node_id: The overwatch node ID
+            peer_id: The peer ID to set
+            keypair: Keypair for signing (must be node owner)
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Setting peer ID for overwatch node {overwatch_node_id} "
+                f"on subnet {subnet_id}"
+            )
+
+            # Pass peer_id as string - substrate-interface handles encoding
+            # (Same pattern as node.py for subnet node peer IDs)
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_overwatch_node_peer_id",
+                call_params={
+                    "subnet_id": subnet_id,
+                    "overwatch_node_id": overwatch_node_id,
+                    "peer_id": peer_id,  # String, not encoded bytes
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "subnet_id": subnet_id,
+                    "overwatch_node_id": overwatch_node_id,
+                    "peer_id": peer_id,
+                    "message": f"Successfully set peer ID for overwatch node {overwatch_node_id} on subnet {subnet_id}",
+                }
+            else:
+                error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+                return {
+                    "success": False,
+                    "error": error_msg,
+                    "message": f"Failed to set peer ID: {error_msg}",
+                }
+
+        except Exception as e:
+            logger.error(f"Error setting overwatch node peer ID: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Error setting peer ID: {str(e)}",
+            }
+
+    # ============================================================================
+    # STAKING
+    # ============================================================================
+
+    def add_to_overwatch_stake(
+        self,
+        overwatch_node_id: int,
+        hotkey: str,
+        stake_to_be_added: int,
+        keypair: Keypair,
+    ) -> dict[str, Any]:
+        """
+        Add stake to an overwatch node.
+
+        Args:
+            overwatch_node_id: The overwatch node ID
+            hotkey: The hotkey of the overwatch node
+            stake_to_be_added: Amount to stake in wei
+            keypair: Coldkey keypair for signing (must own the hotkey)
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Adding {stake_to_be_added / 1e18:.4f} TENSOR stake "
+                f"to overwatch node {overwatch_node_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="add_to_overwatch_stake",
+                call_params={
+                    "overwatch_node_id": overwatch_node_id,
+                    "hotkey": hotkey,
+                    "stake_to_be_added": stake_to_be_added,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "overwatch_node_id": overwatch_node_id,
+                    "hotkey": hotkey,
+                    "stake_added": stake_to_be_added,
+                    "message": f"Successfully added {stake_to_be_added / 1e18:.4f} TENSOR to overwatch stake",
+                }
+            else:
+                error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+                return {
+                    "success": False,
+                    "error": error_msg,
+                    "message": f"Failed to add overwatch stake: {error_msg}",
+                }
+
+        except Exception as e:
+            logger.error(f"Error adding overwatch stake: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Error adding overwatch stake: {str(e)}",
+            }
+
+    def remove_overwatch_stake(
+        self, hotkey: str, stake_to_be_removed: int, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove stake from an overwatch node.
+
+        Creates an unbonding entry that will be claimable after the unbonding period.
+
+        Args:
+            hotkey: The hotkey of the overwatch node
+            stake_to_be_removed: Amount to unstake in wei
+            keypair: Coldkey keypair for signing (must own the hotkey)
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Removing {stake_to_be_removed / 1e18:.4f} TENSOR stake "
+                f"from overwatch node with hotkey {hotkey[:16]}..."
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="remove_overwatch_stake",
+                call_params={
+                    "hotkey": hotkey,
+                    "stake_to_be_removed": stake_to_be_removed,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "hotkey": hotkey,
+                    "stake_removed": stake_to_be_removed,
+                    "message": f"Successfully removed {stake_to_be_removed / 1e18:.4f} TENSOR from overwatch stake (will unbond after waiting period)",
+                }
+            else:
+                error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+                return {
+                    "success": False,
+                    "error": error_msg,
+                    "message": f"Failed to remove overwatch stake: {error_msg}",
+                }
+
+        except Exception as e:
+            logger.error(f"Error removing overwatch stake: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Error removing overwatch stake: {str(e)}",
+            }