htcli 1.1.0__py3-none-any.whl

src/htcli/client/extrinsics/node.py

@@ -0,0 +1,1054 @@
+"""
+Subnet node management extrinsics for HTCLI.
+"""
+
+from typing import Any, Optional
+
+from substrateinterface import Keypair, SubstrateInterface
+
+from ...models.requests.node import (
+    SubnetNodeActivateRequest,
+    SubnetNodeBootnodePeerIdUpdateRequest,
+    SubnetNodeBootnodeUpdateRequest,
+    SubnetNodeClientPeerIdUpdateRequest,
+    SubnetNodePauseRequest,
+    SubnetNodePeerIdUpdateRequest,
+    SubnetNodeReactivateRequest,
+    SubnetNodeRegisterRequest,
+    SubnetNodeRemoveRequest,
+    SubnetNodeUpdateRequest,
+)
+from ...models.responses.subnet import SubnetNodeInfo
+from ...utils.blockchain import validate_ethereum_address
+from ...utils.logging import get_logger
+from .base import BaseExtrinsicClient
+from .subnet import _encode_multiaddr
+
+logger = get_logger(__name__)
+
+
+# Simple response wrapper for methods that don't have specific response models
+class SimpleExtrinsicResponse:
+    """Simple wrapper for extrinsic responses."""
+
+    def __init__(self, response_dict: dict):
+        self.success = response_dict.get("success", False)
+        self.error = response_dict.get("error")
+        self.transaction_hash = response_dict.get("extrinsic_hash")
+        self.block_number = response_dict.get("block_number")
+        self.block_hash = response_dict.get("block_hash")
+        self.message = response_dict.get("message")
+        self.subnet_id = response_dict.get("subnet_id")
+        self.validator_id = response_dict.get("validator_id")
+        self.subnet_node_id = response_dict.get("subnet_node_id")
+        self.hotkey = response_dict.get("hotkey")
+        self.stake_balance = response_dict.get("stake_balance")
+
+
+class NodeExtrinsics(BaseExtrinsicClient):
+    """Client for subnet node-related extrinsics."""
+
+    def __init__(self, substrate: Optional[SubstrateInterface] = None):
+        """Initialize the subnet node client."""
+        super().__init__(substrate)
+
+    # ============================================================================
+    # SUBNET NODE REGISTRATION
+    # ============================================================================
+
+    def register_subnet_node(
+        self, request: SubnetNodeRegisterRequest, keypair: Keypair
+    ) -> SimpleExtrinsicResponse:
+        """
+        Register a new subnet node.
+
+        Args:
+            request: Subnet node registration request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            SimpleExtrinsicResponse with operation result
+        """
+        try:
+            logger.info(f"Registering subnet node for subnet {request.subnet_id}")
+
+            # Validate inputs
+            self._validate_node_registration_request(request)
+
+            def peer_info(peer_id: str, multiaddr: Optional[str]) -> dict[str, Any]:
+                encoded_multiaddr = None
+                if multiaddr:
+                    encoded_multiaddr = _encode_multiaddr(
+                        f"{multiaddr.rstrip('/')}/p2p/{peer_id}"
+                    )
+                return {
+                    "peer_id": peer_id,
+                    "multiaddr": encoded_multiaddr,
+                }
+
+            # Prepare call parameters using the live validator-runtime metadata names.
+            call_params = {
+                "validator_id": request.validator_id,
+                "subnet_id": request.subnet_id,
+                "hotkey": request.hotkey,
+                "peer_info": peer_info(request.peer_id, request.bootnode),
+                "bootnode_peer_info": peer_info(
+                    request.bootnode_peer_id, request.bootnode
+                ),
+                "client_peer_info": peer_info(request.client_peer_id, None),
+                "stake_to_be_added": request.stake_to_be_added,
+                "unique": request.unique,
+                "non_unique": request.non_unique,
+                "max_burn_amount": request.max_burn_amount,
+            }
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="register_subnet_node",
+                call_params=call_params,
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                # Extract node ID from events
+                for event in result.get("events", []):
+                    if hasattr(event, "value"):
+                        module_id = event.value.get("module_id", "")
+                        event_id = event.value.get("event_id", "")
+
+                        # Node registration with stake triggers SubnetNodeActivated event
+                        if module_id == "Network" and event_id in [
+                            "SubnetNodeRegistered",
+                            "SubnetNodeActivated",
+                        ]:
+                            attributes = event.value.get("attributes", {})
+
+                            # Handle both dict and list formats
+                            if isinstance(attributes, dict):
+                                result["subnet_node_id"] = attributes.get(
+                                    "subnet_node_id"
+                                )
+                                result["subnet_id"] = attributes.get(
+                                    "subnet_id", request.subnet_id
+                                )
+                                result["validator_id"] = attributes.get(
+                                    "validator_id", request.validator_id
+                                )
+                                result["hotkey"] = attributes.get("hotkey")
+                            elif (
+                                isinstance(attributes, (list, tuple))
+                                and len(attributes) >= 2
+                            ):
+                                result["subnet_id"] = attributes[0]
+                                result["subnet_node_id"] = attributes[1]
+                                if len(attributes) > 2:
+                                    result["hotkey"] = attributes[2]
+                            break
+
+                # Add stake balance and hotkey from request if not found in events
+                if "validator_id" not in result:
+                    result["validator_id"] = request.validator_id
+                if "stake_balance" not in result:
+                    result["stake_balance"] = request.stake_to_be_added
+                if "hotkey" not in result or not result["hotkey"]:
+                    result["hotkey"] = request.hotkey
+
+                result["message"] = (
+                    f"Subnet node registered successfully for subnet {request.subnet_id}"
+                )
+
+            return SimpleExtrinsicResponse(result)
+
+        except Exception as e:
+            logger.error(f"Error registering subnet node: {e}")
+            return SimpleExtrinsicResponse({"success": False, "error": str(e)})
+
+    # ============================================================================
+    # SUBNET NODE ACTIVATION
+    # ============================================================================
+
+    def activate_subnet_node(
+        self, request: SubnetNodeActivateRequest, keypair: Keypair
+    ) -> SimpleExtrinsicResponse:
+        """
+        Activate a subnet node.
+
+        Args:
+            request: Subnet node activation request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Activating subnet {request.subnet_id} node {request.subnet_node_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="activate_subnet_node",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                result["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} activated successfully"
+                )
+                result["subnet_id"] = request.subnet_id
+                result["subnet_node_id"] = request.subnet_node_id
+
+            return SimpleExtrinsicResponse(result)
+
+        except Exception as e:
+            logger.error(f"Error activating subnet node: {e}")
+            return SimpleExtrinsicResponse({"success": False, "error": str(e)})
+
+    # ============================================================================
+    # SUBNET NODE PAUSE/REACTIVATE
+    # ============================================================================
+
+    def pause_subnet_node(
+        self, request: SubnetNodePauseRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Pause a subnet node.
+
+        Args:
+            request: Subnet node pause request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Pausing subnet {request.subnet_id} node {request.subnet_node_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="pause_subnet_node",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} paused successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error pausing subnet node: {e}")
+            return {"success": False, "error": str(e)}
+
+    def reactivate_subnet_node(
+        self, request: SubnetNodeReactivateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Reactivate a subnet node.
+
+        Args:
+            request: Subnet node reactivation request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Reactivating subnet {request.subnet_id} node {request.subnet_node_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="reactivate_subnet_node",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} reactivated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error reactivating subnet node: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # SUBNET NODE REMOVAL
+    # ============================================================================
+
+    def remove_subnet_node(
+        self, request: SubnetNodeRemoveRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove a subnet node.
+
+        Args:
+            request: Subnet node removal request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Removing subnet {request.subnet_id} node {request.subnet_node_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="remove_subnet_node",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} removed successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error removing subnet node: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # SUBNET NODE PARAMETER UPDATES
+    # ============================================================================
+
+    def update_subnet_node_parameters(
+        self,
+        subnet_id: int,
+        subnet_node_id: int,
+        *,
+        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,
+        keypair: Keypair,
+    ) -> list[dict[str, Any]]:
+        """
+        Perform one or more subnet node parameter updates in sequence.
+
+        Returns a list of result dicts, each tagged with the logical field name.
+        """
+        results: list[dict[str, Any]] = []
+
+        # Main peer ID
+        if peer_id is not None:
+            try:
+                logger.info(
+                    f"Updating peer ID for subnet {subnet_id} node {subnet_node_id}"
+                )
+                request = SubnetNodePeerIdUpdateRequest(
+                    subnet_id=subnet_id,
+                    subnet_node_id=subnet_node_id,
+                    new_peer_id=peer_id,
+                )
+                result = self.update_subnet_node_peer_id(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating subnet node peer ID: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append({"field": "peer_id", "result": result})
+
+        # Bootnode multiaddress
+        if bootnode is not None:
+            try:
+                logger.info(
+                    f"Updating bootnode for subnet {subnet_id} node {subnet_node_id}"
+                )
+                request = SubnetNodeBootnodeUpdateRequest(
+                    subnet_id=subnet_id,
+                    subnet_node_id=subnet_node_id,
+                    new_bootnode=bootnode,
+                )
+                result = self.update_subnet_node_bootnode(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating subnet node bootnode: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append({"field": "bootnode", "result": result})
+
+        # Bootnode peer ID
+        if bootnode_peer_id is not None:
+            try:
+                logger.info(
+                    f"Updating bootnode peer ID for subnet {subnet_id} node {subnet_node_id}"
+                )
+                request = SubnetNodeBootnodePeerIdUpdateRequest(
+                    subnet_id=subnet_id,
+                    subnet_node_id=subnet_node_id,
+                    new_bootnode_peer_id=bootnode_peer_id,
+                )
+                result = self.update_subnet_node_bootnode_peer_id(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating subnet node bootnode peer ID: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append({"field": "bootnode_peer_id", "result": result})
+
+        # Client peer ID
+        if client_peer_id is not None:
+            try:
+                logger.info(
+                    f"Updating client peer ID for subnet {subnet_id} node {subnet_node_id}"
+                )
+                request = SubnetNodeClientPeerIdUpdateRequest(
+                    subnet_id=subnet_id,
+                    subnet_node_id=subnet_node_id,
+                    new_client_peer_id=client_peer_id,
+                )
+                result = self.update_subnet_node_client_peer_id(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating subnet node client peer ID: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append({"field": "client_peer_id", "result": result})
+
+        # Delegate reward rate
+        if delegate_reward_rate is not None:
+            try:
+                logger.info(
+                    f"Updating delegate reward rate for subnet {subnet_id} node {subnet_node_id}"
+                )
+                request = SubnetNodeUpdateRequest(
+                    subnet_id=subnet_id,
+                    subnet_node_id=subnet_node_id,
+                    value=str(delegate_reward_rate),
+                )
+                result = self.update_subnet_node_delegate_reward_rate(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating subnet node delegate reward rate: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append({"field": "delegate_reward_rate", "result": result})
+
+        # Unique metadata
+        if unique is not None:
+            try:
+                logger.info(
+                    f"Updating unique metadata for subnet {subnet_id} node {subnet_node_id}"
+                )
+                request = SubnetNodeUpdateRequest(
+                    subnet_id=subnet_id,
+                    subnet_node_id=subnet_node_id,
+                    value=unique,
+                )
+                result = self.update_subnet_node_unique(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating subnet node unique metadata: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append({"field": "unique", "result": result})
+
+        # Non-unique metadata
+        if non_unique is not None:
+            try:
+                logger.info(
+                    f"Updating non-unique metadata for subnet {subnet_id} node {subnet_node_id}"
+                )
+                request = SubnetNodeUpdateRequest(
+                    subnet_id=subnet_id,
+                    subnet_node_id=subnet_node_id,
+                    value=non_unique,
+                )
+                result = self.update_subnet_node_non_unique(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating subnet node non-unique metadata: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append({"field": "non_unique", "result": result})
+
+        return results
+
+    def update_subnet_node_unique(
+        self, request: SubnetNodeUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet node unique parameter.
+
+        Args:
+            request: Subnet node update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} node {request.subnet_node_id} unique parameter"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_subnet_node_unique",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "value": request.value.encode("utf-8") if request.value else None,
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} unique parameter updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet node unique parameter: {e}")
+            return {"success": False, "error": str(e)}
+
+    def update_subnet_node_non_unique(
+        self, request: SubnetNodeUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet node non-unique parameter.
+
+        Args:
+            request: Subnet node update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} node {request.subnet_node_id} non-unique parameter"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_subnet_node_non_unique",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "value": request.value.encode("utf-8") if request.value else None,
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} non-unique parameter updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet node non-unique parameter: {e}")
+            return {"success": False, "error": str(e)}
+
+    def update_subnet_node_peer_id(
+        self, request: SubnetNodePeerIdUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet node peer ID.
+
+        Args:
+            request: Subnet node peer ID update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} node {request.subnet_node_id} peer ID"
+            )
+
+            # peer_id passed as string, substrate-interface handles encoding
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_subnet_node_peer_id",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "new_peer_id": request.new_peer_id,  # String, not encoded
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} peer ID updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet node peer ID: {e}")
+            return {"success": False, "error": str(e)}
+
+    def update_subnet_node_bootnode(
+        self, request: SubnetNodeBootnodeUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet node bootnode.
+
+        Args:
+            request: Subnet node bootnode update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} node {request.subnet_node_id} bootnode"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_subnet_node_bootnode",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "new_bootnode": (
+                        request.new_bootnode.encode("utf-8")
+                        if request.new_bootnode
+                        else None
+                    ),
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} bootnode updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet node bootnode: {e}")
+            return {"success": False, "error": str(e)}
+
+    def update_subnet_node_bootnode_peer_id(
+        self, request: SubnetNodeBootnodePeerIdUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet node bootnode peer ID.
+
+        Args:
+            request: Subnet node bootnode peer ID update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} node {request.subnet_node_id} bootnode peer ID"
+            )
+
+            # peer_id passed as string, substrate-interface handles encoding
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_bootnode_peer_id",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "new_bootnode_peer_id": request.new_bootnode_peer_id,  # String, not encoded
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} bootnode peer ID updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet node bootnode peer ID: {e}")
+            return {"success": False, "error": str(e)}
+
+    def update_subnet_node_client_peer_id(
+        self, request: SubnetNodeClientPeerIdUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet node client peer ID.
+
+        Args:
+            request: Subnet node client peer ID update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} node {request.subnet_node_id} client peer ID"
+            )
+
+            # peer_id passed as string, substrate-interface handles encoding
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_client_peer_id",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "new_client_peer_id": request.new_client_peer_id,  # String, not encoded
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} client peer ID updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet node client peer ID: {e}")
+            return {"success": False, "error": str(e)}
+
+    def update_subnet_node_delegate_reward_rate(
+        self, request: SubnetNodeUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet node delegate reward rate.
+
+        Args:
+            request: Subnet node update request (value should be the new reward rate)
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            Dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} node {request.subnet_node_id} delegate reward rate"
+            )
+
+            # Convert string value to int for reward rate
+            reward_rate = int(request.value) if request.value else 0
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_subnet_node_delegate_reward_rate",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "value": reward_rate,
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} node {request.subnet_node_id} delegate reward rate updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet node delegate reward rate: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # QUERY METHODS
+    # ============================================================================
+
+    def get_subnet_node_info(
+        self, subnet_id: int, subnet_node_id: int
+    ) -> Optional[SubnetNodeInfo]:
+        """
+        Get information about a specific subnet node.
+
+        Args:
+            subnet_id: The subnet ID
+            subnet_node_id: The subnet node ID
+
+        Returns:
+            SubnetNodeInfo if found, None otherwise
+        """
+        try:
+            # Query subnet node data
+            node_data = self.substrate.query(
+                module="Network",
+                storage_function="SubnetNodesData",
+                params=[subnet_id, subnet_node_id],
+            )
+
+            if not node_data.value:
+                return None
+
+            # Query additional information
+            stake_balance = (
+                self.substrate.query(
+                    module="Network",
+                    storage_function="SubnetNodeStake",
+                    params=[subnet_id, subnet_node_id],
+                ).value
+                or 0
+            )
+
+            node_delegate_stake_balance = (
+                self.substrate.query(
+                    module="Network",
+                    storage_function="SubnetNodeDelegateStake",
+                    params=[subnet_id, subnet_node_id],
+                ).value
+                or 0
+            )
+
+            penalties = (
+                self.substrate.query(
+                    module="Network",
+                    storage_function="SubnetNodePenalties",
+                    params=[subnet_id, subnet_node_id],
+                ).value
+                or 0
+            )
+
+            # Query coldkey
+            coldkey = self.substrate.query(
+                module="Network",
+                storage_function="SubnetNodeColdkey",
+                params=[subnet_id, subnet_node_id],
+            ).value
+
+            # Query identity data
+            identity = self.substrate.query(
+                module="Network", storage_function="Identity", params=[coldkey]
+            ).value
+
+            # Query reputation
+            reputation = self.substrate.query(
+                module="Network", storage_function="Reputation", params=[coldkey]
+            ).value
+
+            return SubnetNodeInfo(
+                subnet_id=subnet_id,
+                subnet_node_id=subnet_node_id,
+                coldkey=coldkey,
+                hotkey=node_data.value["hotkey"],
+                peer_id=node_data.value["peer_id"].decode("utf-8"),
+                bootnode_peer_id=node_data.value["bootnode_peer_id"].decode("utf-8"),
+                client_peer_id=node_data.value["client_peer_id"].decode("utf-8"),
+                bootnode=(
+                    node_data.value.get("bootnode", {}).decode("utf-8")
+                    if node_data.value.get("bootnode")
+                    else None
+                ),
+                identity=identity,
+                classification=node_data.value["classification"].name,
+                delegate_reward_rate=node_data.value.get("delegate_reward_rate", 0),
+                last_delegate_reward_rate_update=node_data.value.get(
+                    "last_delegate_reward_rate_update", 0
+                ),
+                unique=(
+                    node_data.value.get("unique", {}).decode("utf-8")
+                    if node_data.value.get("unique")
+                    else None
+                ),
+                non_unique=(
+                    node_data.value.get("non_unique", {}).decode("utf-8")
+                    if node_data.value.get("non_unique")
+                    else None
+                ),
+                stake_balance=stake_balance,
+                node_delegate_stake_balance=node_delegate_stake_balance,
+                penalties=penalties,
+                reputation=reputation,
+            )
+
+        except Exception as e:
+            logger.error(f"Error getting subnet node info: {e}")
+            return None
+
+    def list_subnet_nodes(self, subnet_id: int) -> list[SubnetNodeInfo]:
+        """
+        List all nodes for a specific subnet.
+
+        Args:
+            subnet_id: The subnet ID
+
+        Returns:
+            List of SubnetNodeInfo objects
+        """
+        try:
+            nodes = []
+
+            # Get total node count for this subnet
+            total_nodes = (
+                self.substrate.query(
+                    module="Network",
+                    storage_function="TotalSubnetNodes",
+                    params=[subnet_id],
+                ).value
+                or 0
+            )
+
+            # Query each node
+            for node_id in range(1, total_nodes + 1):
+                node_info = self.get_subnet_node_info(subnet_id, node_id)
+                if node_info:
+                    nodes.append(node_info)
+
+            return nodes
+
+        except Exception as e:
+            logger.error(f"Error listing subnet nodes: {e}")
+            return []
+
+    # ============================================================================
+    # PRIVATE HELPER METHODS
+    # ============================================================================
+
+    def _validate_node_registration_request(self, request: SubnetNodeRegisterRequest):
+        """Validate the node registration request."""
+        if request.validator_id < 0:
+            raise ValueError("Validator ID must be non-negative")
+
+        # Validate account IDs
+        validate_ethereum_address(request.hotkey)
+
+        # Validate peer IDs
+        if not request.peer_id or not request.peer_id.strip():
+            raise ValueError("Peer ID cannot be empty")
+        if not request.bootnode_peer_id or not request.bootnode_peer_id.strip():
+            raise ValueError("Bootnode peer ID cannot be empty")
+        if not request.client_peer_id or not request.client_peer_id.strip():
+            raise ValueError("Client peer ID cannot be empty")
+
+        # Validate stake amount
+        if request.stake_to_be_added <= 0:
+            raise ValueError("Stake amount must be positive")
+
+    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:
+                # Extract extrinsic_hash with defensive handling
+                try:
+                    extrinsic_hash = response.extrinsic_hash
+                    if isinstance(extrinsic_hash, bytes):
+                        extrinsic_hash = "0x" + extrinsic_hash.hex()
+                    elif extrinsic_hash and not isinstance(extrinsic_hash, str):
+                        extrinsic_hash = str(extrinsic_hash)
+                except (AttributeError, Exception):
+                    extrinsic_hash = getattr(response, "extrinsic_hash", None)
+                    if extrinsic_hash and isinstance(extrinsic_hash, bytes):
+                        extrinsic_hash = "0x" + extrinsic_hash.hex()
+
+                # Extract block_hash with defensive handling
+                try:
+                    block_hash = response.block_hash
+                    if isinstance(block_hash, bytes):
+                        block_hash = "0x" + block_hash.hex()
+                    elif block_hash and not isinstance(block_hash, str):
+                        block_hash = str(block_hash)
+                except (AttributeError, Exception):
+                    block_hash = getattr(response, "block_hash", None)
+                    if block_hash and isinstance(block_hash, bytes):
+                        block_hash = "0x" + block_hash.hex()
+
+                # Extract block_number with defensive handling
+                try:
+                    block_number = response.block_number
+                except (AttributeError, Exception):
+                    block_number = getattr(response, "block_number", None)
+
+                # If block_number is not available but we have block_hash, query it
+                if block_number is None and block_hash:
+                    try:
+                        block_number = self.substrate.get_block_number(
+                            block_hash=block_hash
+                        )
+                    except Exception as e:
+                        logger.debug(f"Could not get block number from block hash: {e}")
+                        block_number = None
+
+                # Extract events
+                try:
+                    events = response.triggered_events
+                except (AttributeError, Exception):
+                    events = getattr(response, "triggered_events", []) or getattr(
+                        response, "events", []
+                    )
+
+                return {
+                    "success": True,
+                    "extrinsic_hash": extrinsic_hash,
+                    "transaction_hash": extrinsic_hash,  # Alias for compatibility
+                    "block_hash": block_hash,
+                    "block_number": block_number,
+                    "events": events,
+                }
+            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:
+            if response.error_message:
+                error_msg = response.error_message
+                if isinstance(error_msg, dict):
+                    return error_msg.get("name", str(error_msg))
+                return str(error_msg)
+
+            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 error.name
+                    return str(error)
+        except Exception as e:
+            logger.warning(f"Could not extract error message: {e}")
+
+        return "Unknown error occurred"