htcli 1.1.0__py3-none-any.whl

src/htcli/client/extrinsics/identity.py

@@ -0,0 +1,490 @@
+"""
+Identity management extrinsics for HTCLI.
+"""
+
+from typing import Any, Optional
+
+from substrateinterface import Keypair, SubstrateInterface
+
+from ...models.requests.identity import (
+    IdentityAcceptRequest,
+    IdentityRegisterRequest,
+    IdentityRemoveRequest,
+    IdentityUpdateColdkeyRequest,
+    IdentityUpdateHotkeyRequest,
+)
+from ...models.responses.identity import IdentityInfo
+from ...utils.blockchain import validate_address
+from ...utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class IdentityExtrinsics:
+    """Client for identity-related extrinsics."""
+
+    def __init__(self, substrate: Optional[SubstrateInterface] = None):
+        """Initialize the identity client."""
+        self.substrate = substrate
+
+    # ============================================================================
+    # IDENTITY REGISTRATION
+    # ============================================================================
+
+    def register_or_update_identity(
+        self, request: IdentityRegisterRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Register or update an identity.
+
+        Args:
+            request: Identity registration request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Registering/updating identity for hotkey {request.hotkey}")
+
+            # Validate inputs
+            self._validate_identity_request(request)
+
+            # Prepare identity data
+            identity_data = {
+                "name": request.name.encode("utf-8"),
+                "url": request.url.encode("utf-8"),
+                "image": request.image.encode("utf-8"),
+                "discord": request.discord.encode("utf-8"),
+                "x": request.x.encode("utf-8"),
+                "telegram": request.telegram.encode("utf-8"),
+                "github": request.github.encode("utf-8"),
+                "hugging_face": request.hugging_face.encode("utf-8"),
+                "description": request.description.encode("utf-8"),
+                "misc": request.misc.encode("utf-8"),
+            }
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="register_or_update_identity",
+                call_params={
+                    "hotkey": request.hotkey,
+                    "name": identity_data["name"],
+                    "url": identity_data["url"],
+                    "image": identity_data["image"],
+                    "discord": identity_data["discord"],
+                    "x": identity_data["x"],
+                    "telegram": identity_data["telegram"],
+                    "github": identity_data["github"],
+                    "hugging_face": identity_data["hugging_face"],
+                    "description": identity_data["description"],
+                    "misc": identity_data["misc"],
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Identity registered/updated successfully for hotkey {request.hotkey}"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error registering/updating identity: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # IDENTITY REMOVAL
+    # ============================================================================
+
+    def remove_identity(
+        self, request: IdentityRemoveRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove an identity.
+
+        Args:
+            request: Identity removal request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info("Removing identity")
+
+            call = self.substrate.compose_call(
+                call_module="Network", call_function="remove_identity", call_params={}
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = "Identity removed successfully"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error removing identity: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # IDENTITY ACCEPTANCE
+    # ============================================================================
+
+    def accept_identity(
+        self, request: IdentityAcceptRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Accept an identity.
+
+        Args:
+            request: Identity accept request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info("Accepting identity")
+
+            # Validate inputs
+            self._validate_identity_accept_request(request)
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="accept_identity",
+                call_params={"identity": request.identity.encode("utf-8")},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = "Identity accepted successfully"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error accepting identity: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # KEY ROTATION
+    # ============================================================================
+
+    def update_coldkey(
+        self, request: IdentityUpdateColdkeyRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update coldkey.
+
+        Args:
+            request: Coldkey update request
+            keypair: Keypair for signing the transaction (current coldkey)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating coldkey to {request.new_coldkey}")
+
+            # Validate input
+            validate_address(request.new_coldkey)
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_coldkey",
+                call_params={"new_coldkey": request.new_coldkey},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Coldkey updated successfully to {request.new_coldkey}"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating coldkey: {e}")
+            return {"success": False, "error": str(e)}
+
+    def update_hotkey(
+        self, request: IdentityUpdateHotkeyRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update hotkey.
+
+        Args:
+            request: Hotkey update request
+            keypair: Keypair for signing the transaction (coldkey)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating hotkey to {request.new_hotkey}")
+
+            # Validate input
+            validate_address(request.new_hotkey)
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_hotkey",
+                call_params={"new_hotkey": request.new_hotkey},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Hotkey updated successfully to {request.new_hotkey}"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating hotkey: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # QUERY METHODS
+    # ============================================================================
+
+    def get_identity_info(self, coldkey: str) -> Optional[IdentityInfo]:
+        """
+        Get identity information for a coldkey.
+
+        Args:
+            coldkey: The coldkey account ID
+
+        Returns:
+            IdentityInfo if found, None otherwise
+        """
+        try:
+            # Query identity data
+            identity_data = self.substrate.query(
+                module="Network", storage_function="Identity", params=[coldkey]
+            )
+
+            if not identity_data.value:
+                return None
+
+            # Query hotkey associated with this coldkey
+            hotkey = self.substrate.query(
+                module="Network", storage_function="ColdkeyToHotkey", params=[coldkey]
+            ).value
+
+            return IdentityInfo(
+                coldkey=coldkey,
+                hotkey=hotkey,
+                name=identity_data.value["name"].decode("utf-8"),
+                url=identity_data.value["url"].decode("utf-8"),
+                image=identity_data.value["image"].decode("utf-8"),
+                description=identity_data.value["description"].decode("utf-8"),
+            )
+
+        except Exception as e:
+            logger.error(f"Error getting identity info: {e}")
+            return None
+
+    def get_identity_by_hotkey(self, hotkey: str) -> Optional[IdentityInfo]:
+        """
+        Get identity information by hotkey.
+
+        Args:
+            hotkey: The hotkey account ID
+
+        Returns:
+            IdentityInfo if found, None otherwise
+        """
+        try:
+            # Query coldkey associated with this hotkey
+            coldkey = self.substrate.query(
+                module="Network", storage_function="HotkeyToColdkey", params=[hotkey]
+            ).value
+
+            if not coldkey:
+                return None
+
+            return self.get_identity_info(coldkey)
+
+        except Exception as e:
+            logger.error(f"Error getting identity by hotkey: {e}")
+            return None
+
+    def list_identities(self, limit: int = 100) -> list[IdentityInfo]:
+        """
+        list all registered identities.
+
+        Args:
+            limit: Maximum number of identities to return
+
+        Returns:
+            list of IdentityInfo objects
+        """
+        try:
+            identities = []
+
+            # Query all identity entries
+            # Note: This is a simplified approach. In practice, you might need
+            # to iterate through all possible account IDs or use a different method
+            # depending on how identities are stored in the chain
+
+            # For now, we'll return an empty list as this would require
+            # knowing the storage structure better
+            logger.warning(
+                "list identities not fully implemented - requires knowledge of storage iteration"
+            )
+
+            return identities
+
+        except Exception as e:
+            logger.error(f"Error listing identities: {e}")
+            return []
+
+    def search_identities_by_name(self, name_query: str) -> list[IdentityInfo]:
+        """
+        Search identities by name (partial match).
+
+        Args:
+            name_query: Name to search for
+
+        Returns:
+            list of matching IdentityInfo objects
+        """
+        try:
+            # This would require iterating through all identities and checking names
+            # For now, return empty list as this is not efficiently implementable
+            # without knowing the storage structure
+            logger.warning(
+                "Search identities by name not fully implemented - requires storage iteration"
+            )
+
+            return []
+
+        except Exception as e:
+            logger.error(f"Error searching identities by name: {e}")
+            return []
+
+    def get_identity_count(self) -> int:
+        """
+        Get the total number of registered identities.
+
+        Returns:
+            Total number of identities
+        """
+        try:
+            # Query total identity count
+            count = (
+                self.substrate.query(
+                    module="Network", storage_function="TotalIdentities"
+                ).value
+                or 0
+            )
+
+            return count
+
+        except Exception as e:
+            logger.error(f"Error getting identity count: {e}")
+            return 0
+
+    # ============================================================================
+    # PRIVATE HELPER METHODS
+    # ============================================================================
+
+    def _validate_identity_request(self, request: IdentityRegisterRequest):
+        """Validate the identity registration request."""
+        validate_address(request.hotkey)
+
+        # Validate name is not empty
+        if not request.name or not request.name.strip():
+            raise ValueError("Identity name cannot be empty")
+
+        # Validate URL format if provided
+        if request.url and request.url.strip():
+            if not self._is_valid_url(request.url):
+                raise ValueError("Invalid URL format")
+
+        # Validate image URL format if provided
+        if request.image and request.image.strip():
+            if not self._is_valid_url(request.image):
+                raise ValueError("Invalid image URL format")
+
+        # Validate GitHub URL format if provided
+        if request.github and request.github.strip():
+            if not self._is_valid_url(request.github):
+                raise ValueError("Invalid GitHub URL format")
+
+        # Validate Hugging Face URL format if provided
+        if request.hugging_face and request.hugging_face.strip():
+            if not self._is_valid_url(request.hugging_face):
+                raise ValueError("Invalid Hugging Face URL format")
+
+    def _validate_identity_accept_request(self, request: IdentityAcceptRequest):
+        """Validate the identity accept request."""
+        if not request.identity or not request.identity.strip():
+            raise ValueError("Identity data cannot be empty")
+
+    def _is_valid_url(self, url: str) -> bool:
+        """Basic URL validation."""
+        import re
+
+        url_pattern = re.compile(
+            r"^https?://"  # http:// or https://
+            r"(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|"  # domain...
+            r"localhost|"  # localhost...
+            r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})"  # ...or ip
+            r"(?::\d+)?"  # optional port
+            r"(?:/?|[/?]\S+)$",
+            re.IGNORECASE,
+        )
+        return url_pattern.match(url) is not None
+
+    def _submit_extrinsic(self, call, keypair: Keypair) -> dict[str, Any]:
+        """Submit an extrinsic and return the result."""
+        try:
+            extrinsic = self.substrate.create_signed_extrinsic(
+                call=call,
+                keypair=keypair,
+                era={"period": 64},  # 64 block era
+            )
+
+            response = self.substrate.submit_extrinsic(
+                extrinsic, wait_for_inclusion=True, wait_for_finalization=True
+            )
+
+            if response.is_success:
+                return {
+                    "success": True,
+                    "extrinsic_hash": response.extrinsic_hash,
+                    "block_hash": response.block_hash,
+                    "block_number": response.block_number,
+                }
+            else:
+                error_msg = self._extract_error_message(response)
+                return {"success": False, "error": error_msg}
+
+        except Exception as e:
+            logger.error(f"Error submitting extrinsic: {e}")
+            return {"success": False, "error": str(e)}
+
+    def _extract_error_message(self, response) -> str:
+        """Extract error message from failed response."""
+        try:
+            for event in response.triggered_events:
+                if (
+                    event.value["module_id"] == "System"
+                    and event.value["event_id"] == "ExtrinsicFailed"
+                ):
+                    error = event.value["attributes"][0]
+                    if hasattr(error, "name"):
+                        return f"Extrinsic failed: {error.name}"
+                    return f"Extrinsic failed: {str(error)}"
+        except Exception as e:
+            logger.warning(f"Could not extract error message: {e}")
+
+        return "Unknown error occurred"