htcli 1.1.0__py3-none-any.whl

src/htcli/client/extrinsics/governance.py

@@ -0,0 +1,714 @@
+"""
+Governance extrinsics for HTCLI.
+"""
+
+from typing import Any, Optional
+
+from substrateinterface import Keypair, SubstrateInterface
+
+from ...models.requests import (
+    GovernanceCollectiveRemoveOverwatchNodeRequest,
+    GovernanceCollectiveRemoveSubnetNodeRequest,
+    GovernanceCollectiveRemoveSubnetRequest,
+    GovernanceParameterUpdateRequest,
+    GovernancePauseRequest,
+    GovernanceUnpauseRequest,
+)
+from ...utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class GovernanceExtrinsics:
+    """Client for governance-related extrinsics."""
+
+    def __init__(self, substrate: Optional[SubstrateInterface] = None):
+        """Initialize the governance client."""
+        self.substrate = substrate
+
+    # ============================================================================
+    # NETWORK PAUSE/UNPAUSE
+    # ============================================================================
+
+    def pause_network(
+        self, request: GovernancePauseRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Pause the network (governance only).
+
+        Args:
+            request: Network pause request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info("Pausing network")
+
+            call = self.substrate.compose_call(
+                call_module="Network", call_function="pause_network", call_params={}
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = "Network paused successfully"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error pausing network: {e}")
+            return {"success": False, "error": str(e)}
+
+    def unpause_network(
+        self, request: GovernanceUnpauseRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Unpause the network (governance only).
+
+        Args:
+            request: Network unpause request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info("Unpausing network")
+
+            call = self.substrate.compose_call(
+                call_module="Network", call_function="unpause_network", call_params={}
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = "Network unpaused successfully"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error unpausing network: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # COLLECTIVE REMOVAL OPERATIONS
+    # ============================================================================
+
+    def collective_remove_subnet(
+        self, request: GovernanceCollectiveRemoveSubnetRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove a subnet collectively (governance only).
+
+        Args:
+            request: Collective subnet removal request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Collectively removing subnet {request.subnet_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="collective_remove_subnet",
+                call_params={"subnet_id": request.subnet_id},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = f"Subnet {request.subnet_id} removed collectively"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error collectively removing subnet: {e}")
+            return {"success": False, "error": str(e)}
+
+    def collective_remove_subnet_node(
+        self, request: GovernanceCollectiveRemoveSubnetNodeRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove a subnet node collectively (governance only).
+
+        Args:
+            request: Collective subnet node removal request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Collectively removing subnet {request.subnet_id} node {request.subnet_node_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="collective_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 collectively"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error collectively removing subnet node: {e}")
+            return {"success": False, "error": str(e)}
+
+    def collective_remove_overwatch_node(
+        self, request: GovernanceCollectiveRemoveOverwatchNodeRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove an overwatch node collectively (governance only).
+
+        Args:
+            request: Collective overwatch node removal request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Collectively removing overwatch node {request.overwatch_node_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="collective_remove_overwatch_node",
+                call_params={"overwatch_node_id": request.overwatch_node_id},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Overwatch node {request.overwatch_node_id} removed collectively"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error collectively removing overwatch node: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # PARAMETER UPDATES
+    # ============================================================================
+
+    def set_min_delegate_stake_percentage(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Set minimum delegate stake percentage (governance only).
+
+        Args:
+            request: Parameter update request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Setting min delegate stake percentage to {request.value}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_min_delegate_stake_percentage",
+                call_params={"value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Min delegate stake percentage set to {request.value}"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error setting min delegate stake percentage: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_max_delegate_stake_percentage(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Set maximum delegate stake percentage (governance only).
+
+        Args:
+            request: Parameter update request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Setting max delegate stake percentage to {request.value}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_max_delegate_stake_percentage",
+                call_params={"value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Max delegate stake percentage set to {request.value}"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error setting max delegate stake percentage: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_min_max_registered_nodes(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Set minimum max registered nodes (governance only).
+
+        Args:
+            request: Parameter update request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Setting min max registered nodes to {request.value}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_min_max_registered_nodes",
+                call_params={"value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = f"Min max registered nodes set to {request.value}"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error setting min max registered nodes: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_max_max_registered_nodes(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Set maximum max registered nodes (governance only).
+
+        Args:
+            request: Parameter update request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Setting max max registered nodes to {request.value}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_max_max_registered_nodes",
+                call_params={"value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = f"Max max registered nodes set to {request.value}"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error setting max max registered nodes: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_network_min_stake_balance(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Set network minimum stake balance (governance only).
+
+        Args:
+            request: Parameter update request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Setting network min stake balance to {request.value}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_network_min_stake_balance",
+                call_params={"value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Network min stake balance set to {request.value}"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error setting network min stake balance: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_network_max_stake_balance(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Set network maximum stake balance (governance only).
+
+        Args:
+            request: Parameter update request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Setting network max stake balance to {request.value}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_network_max_stake_balance",
+                call_params={"value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Network max stake balance set to {request.value}"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error setting network max stake balance: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_tx_rate_limit(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Set transaction rate limit (governance only).
+
+        Args:
+            request: Parameter update request
+            keypair: Keypair for signing the transaction (must be governance)
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Setting transaction rate limit to {request.value}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_tx_rate_limit",
+                call_params={"value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = f"Transaction rate limit set to {request.value}"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error setting transaction rate limit: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_min_registration_cost(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """Set min registration cost."""
+        try:
+            logger.info(f"Setting min registration cost to {request.value}")
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_min_registration_cost",
+                call_params={"value": request.value},
+            )
+            return self._submit_extrinsic(call, keypair)
+        except Exception as e:
+            logger.error(f"Error setting min registration cost: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_target_registrations_per_interval(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """Set target registrations per interval."""
+        try:
+            logger.info(f"Setting target regs per interval to {request.value}")
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_target_registrations_per_interval",
+                call_params={"value": request.value},
+            )
+            return self._submit_extrinsic(call, keypair)
+        except Exception as e:
+            logger.error(f"Error setting target regs per interval: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_max_registrations_per_interval(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """Set max registrations per interval."""
+        try:
+            logger.info(f"Setting max regs per interval to {request.value}")
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_max_registrations_per_interval",
+                call_params={"value": request.value},
+            )
+            return self._submit_extrinsic(call, keypair)
+        except Exception as e:
+            logger.error(f"Error setting max regs per interval: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_adjustment_alpha(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """Set adjustment alpha."""
+        try:
+            logger.info(f"Setting adjustment alpha to {request.value}")
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_adjustment_alpha",
+                call_params={"value": request.value},
+            )
+            return self._submit_extrinsic(call, keypair)
+        except Exception as e:
+            logger.error(f"Error setting adjustment alpha: {e}")
+            return {"success": False, "error": str(e)}
+
+    def set_target_max_subnet_nodes(
+        self, request: GovernanceParameterUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """Set target max subnet nodes."""
+        try:
+            logger.info(f"Setting target max subnet nodes to {request.value}")
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="set_target_max_subnet_nodes",
+                call_params={"value": request.value},
+            )
+            return self._submit_extrinsic(call, keypair)
+        except Exception as e:
+            logger.error(f"Error setting target max subnet nodes: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # QUERY METHODS
+    # ============================================================================
+
+    def get_network_state(self) -> str:
+        """
+        Get the current network state.
+
+        Returns:
+            Network state (Active/Paused)
+        """
+        try:
+            is_paused = self.substrate.query(
+                module="Network", storage_function="IsPaused"
+            ).value
+
+            return "Paused" if is_paused else "Active"
+
+        except Exception as e:
+            logger.error(f"Error getting network state: {e}")
+            return "Unknown"
+
+    def get_governance_parameters(self) -> dict[str, Any]:
+        """
+        Get current governance parameters.
+
+        Returns:
+            dictionary with governance parameters
+        """
+        try:
+            parameters = {}
+
+            # Query various governance parameters
+            parameter_queries = [
+                ("min_delegate_stake_percentage", "MinDelegateStakePercentage"),
+                ("max_delegate_stake_percentage", "MaxDelegateStakePercentage"),
+                ("min_max_registered_nodes", "MinMaxRegisteredNodes"),
+                ("max_max_registered_nodes", "MaxMaxRegisteredNodes"),
+                ("network_min_stake_balance", "NetworkMinStakeBalance"),
+                ("network_max_stake_balance", "NetworkMaxStakeBalance"),
+                ("tx_rate_limit", "TxRateLimit"),
+                ("epoch_length", "EpochLength"),
+                ("min_stake_balance", "MinStakeBalance"),
+                ("max_stake_balance", "MaxStakeBalance"),
+            ]
+
+            for param_name, storage_key in parameter_queries:
+                try:
+                    value = self.substrate.query(
+                        module="Network", storage_function=storage_key
+                    ).value
+                    parameters[param_name] = value
+                except Exception as e:
+                    logger.warning(f"Could not query {param_name}: {e}")
+                    parameters[param_name] = None
+
+            return parameters
+
+        except Exception as e:
+            logger.error(f"Error getting governance parameters: {e}")
+            return {}
+
+    def get_network_info(self) -> dict[str, Any]:
+        """
+        Get general network information.
+
+        Returns:
+            dictionary with network information
+        """
+        try:
+            info = {}
+
+            # Get basic network stats
+            total_subnets = (
+                self.substrate.query(
+                    module="Network", storage_function="TotalSubnetUids"
+                ).value
+                or 0
+            )
+
+            total_nodes = (
+                self.substrate.query(
+                    module="Network", storage_function="TotalSubnetNodes"
+                ).value
+                or 0
+            )
+
+            total_overwatch_nodes = (
+                self.substrate.query(
+                    module="Network", storage_function="TotalOverwatchNodes"
+                ).value
+                or 0
+            )
+
+            current_epoch = self.get_current_epoch()
+            network_state = self.get_network_state()
+
+            info.update(
+                {
+                    "total_subnets": total_subnets,
+                    "total_nodes": total_nodes,
+                    "total_overwatch_nodes": total_overwatch_nodes,
+                    "current_epoch": current_epoch,
+                    "network_state": network_state,
+                }
+            )
+
+            return info
+
+        except Exception as e:
+            logger.error(f"Error getting network info: {e}")
+            return {}
+
+    def get_current_epoch(self) -> int:
+        """
+        Get the current epoch number.
+
+        Returns:
+            Current epoch number
+        """
+        try:
+            current_block = self.substrate.get_block_number()
+            epoch_length = (
+                self.substrate.query(
+                    module="Network", storage_function="EpochLength"
+                ).value
+                or 300
+            )
+
+            return current_block // epoch_length
+
+        except Exception as e:
+            logger.error(f"Error getting current epoch: {e}")
+            return 0
+
+    # ============================================================================
+    # PRIVATE HELPER METHODS
+    # ============================================================================
+
+    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"