htcli 1.1.0__py3-none-any.whl

src/htcli/client/rpc/overwatch.py

@@ -0,0 +1,680 @@
+"""
+RPC client for overwatch-related queries using scalecodec for decoding.
+"""
+
+from typing import Any, Optional
+
+from substrateinterface import SubstrateInterface
+
+from ...models.responses import OverwatchNodeInfo
+from ...utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class OverwatchRpcClient:
+    """RPC client for overwatch-related queries."""
+
+    def __init__(self, substrate: SubstrateInterface):
+        """Initialize the overwatch RPC client."""
+        self.substrate = substrate
+
+    def get_overwatch_commits_for_epoch_and_node(
+        self, epoch: int, overwatch_node_id: int
+    ) -> list[dict[str, Any]]:
+        """
+        Get overwatch commits for a specific epoch and node using custom RPC method.
+
+        Args:
+            epoch: The epoch number
+            overwatch_node_id: The overwatch node ID
+
+        Returns:
+            list of commit data (subnet_id, commit_hash pairs)
+        """
+        try:
+            # Use custom RPC method
+            result = self.substrate.rpc_request(
+                method="network_getOverwatchCommitsForEpochAndNode",
+                params=[epoch, overwatch_node_id],
+            )
+
+            if not result or not result.get("result"):
+                return []
+
+            # Decode the SCALE bytes using centralized type registry
+            scale_data = result["result"]
+            if isinstance(scale_data, str) and scale_data.startswith("0x"):
+                scale_data = bytes.fromhex(scale_data[2:])
+            elif isinstance(scale_data, (list, tuple)):
+                scale_data = bytes(scale_data)
+
+            # The result should be a Vec<(u32, Hash)> - (subnet_id, commit_hash) pairs
+            from scalecodec import ScaleBytes
+            from ...utils.blockchain.type_registry import get_rpc_runtime_config
+
+            # Use centralized type registry configuration
+            runtime_config = get_rpc_runtime_config()
+
+            # Decode the vector of tuples
+            obj = runtime_config.create_scale_object(
+                "Vec<(u32, Hash)>", ScaleBytes(scale_data)
+            )
+            decoded = obj.decode()
+
+            # Convert to list of dictionaries
+            commits = []
+            for item in decoded:
+                commit_hash = item[1].hex() if hasattr(item[1], "hex") else bytes(item[1]).hex()
+                commits.append({"subnet_id": item[0], "commit_hash": commit_hash})
+
+            return commits
+
+        except Exception as e:
+            logger.error(f"Error getting overwatch commits: {e}")
+            return []
+
+    def get_overwatch_reveals_for_epoch_and_node(
+        self, epoch: int, overwatch_node_id: int
+    ) -> list[dict[str, Any]]:
+        """
+        Get overwatch reveals for a specific epoch and node using custom RPC method.
+
+        Args:
+            epoch: The epoch number
+            overwatch_node_id: The overwatch node ID
+
+        Returns:
+            list of reveal data (subnet_id, weight pairs)
+        """
+        try:
+            # Use custom RPC method
+            result = self.substrate.rpc_request(
+                method="network_getOverwatchRevealsForEpochAndNode",
+                params=[epoch, overwatch_node_id],
+            )
+
+            if not result or not result.get("result"):
+                return []
+
+            # Decode the SCALE bytes using centralized type registry
+            scale_data = result["result"]
+            if isinstance(scale_data, str) and scale_data.startswith("0x"):
+                scale_data = bytes.fromhex(scale_data[2:])
+            elif isinstance(scale_data, (list, tuple)):
+                scale_data = bytes(scale_data)
+
+            # The result should be a Vec<(u32, u128)> - (subnet_id, weight) pairs
+            from scalecodec import ScaleBytes
+            from ...utils.blockchain.type_registry import get_rpc_runtime_config
+
+            # Use centralized type registry configuration
+            runtime_config = get_rpc_runtime_config()
+
+            # Decode the vector of tuples
+            obj = runtime_config.create_scale_object(
+                "Vec<(u32, u128)>", ScaleBytes(scale_data)
+            )
+            decoded = obj.decode()
+
+            # Convert to list of dictionaries
+            reveals = []
+            for item in decoded:
+                reveals.append({"subnet_id": item[0], "weight": item[1]})
+
+            return reveals
+
+        except Exception as e:
+            logger.error(f"Error getting overwatch reveals: {e}")
+            return []
+
+    def get_overwatch_node_info(
+        self, overwatch_node_id: int
+    ) -> Optional[OverwatchNodeInfo]:
+        """
+        Get overwatch node information using storage queries.
+        Note: This is not a custom RPC method, but uses storage queries.
+
+        Args:
+            overwatch_node_id: The overwatch node ID
+
+        Returns:
+            OverwatchNodeInfo if found, None otherwise
+        """
+        try:
+            # Query overwatch node data from storage
+            # Storage: OverwatchNodes<T: Config> = StorageMap<_, Identity, u32, OverwatchNode<T::AccountId>, OptionQuery>
+            node_data = self.substrate.query(
+                module="Network",
+                storage_function="OverwatchNodes",
+                params=[overwatch_node_id],
+            )
+
+            if not node_data or not node_data.value:
+                logger.debug(f"No overwatch node found with ID {overwatch_node_id}")
+                return None
+
+            # Extract hotkey from node data
+            # OverwatchNode struct has: id (u32), hotkey (AccountId)
+            hotkey = node_data.value.get("hotkey") if isinstance(node_data.value, dict) else None
+            if not hotkey:
+                logger.warning(f"No hotkey found in overwatch node {overwatch_node_id}")
+                return None
+            
+            # Get coldkey from HotkeyOwner storage
+            coldkey = self.substrate.query(
+                module="Network",
+                storage_function="HotkeyOwner",
+                params=[hotkey],
+            ).value
+
+            # Query peer IDs from OverwatchNodeIndex (maps node_id -> {subnet_id -> peer_id})
+            peer_ids_data = (
+                self.substrate.query(
+                    module="Network",
+                    storage_function="OverwatchNodeIndex",
+                    params=[overwatch_node_id],
+                ).value
+                or {}
+            )
+            
+            # Handle BTreeMap decoding (might be list of tuples or dict)
+            if isinstance(peer_ids_data, list):
+                # Handle [(subnet_id, peer_id), ...]
+                peer_ids = {int(k): v for k, v in peer_ids_data}
+            elif isinstance(peer_ids_data, dict):
+                # Handle {subnet_id: peer_id}
+                peer_ids = {int(k): v for k, v in peer_ids_data.items()}
+            else:
+                peer_ids = {}
+
+            # Query reputation from ColdkeyReputation (if we have coldkey)
+            reputation = None
+            if coldkey:
+                reputation = self.substrate.query(
+                    module="Network",
+                    storage_function="ColdkeyReputation",
+                    params=[coldkey],
+                ).value
+
+            # Query stake balance from AccountOverwatchStake (keyed by hotkey)
+            stake_balance = 0
+            if hotkey:
+                stake_result = self.substrate.query(
+                    module="Network",
+                    storage_function="AccountOverwatchStake",
+                    params=[hotkey],
+                )
+                stake_balance = stake_result.value if stake_result and stake_result.value else 0
+
+            return OverwatchNodeInfo(
+                overwatch_node_id=overwatch_node_id,
+                coldkey=coldkey,
+                hotkey=hotkey,
+                peer_ids=peer_ids,
+                penalties=0,  # Note: OverwatchNodePenalties may not exist
+                stake_balance=stake_balance,
+                reputation=reputation,
+            )
+
+        except Exception as e:
+            logger.error(f"Error getting overwatch node info: {e}")
+            return None
+
+
+    def list_overwatch_nodes(self) -> list[OverwatchNodeInfo]:
+        """
+        list all overwatch nodes using storage queries.
+        Note: This is not a custom RPC method, but uses storage queries.
+
+        Returns:
+            list of OverwatchNodeInfo objects
+        """
+        try:
+            nodes = []
+
+            # Get total overwatch node count
+            total_nodes = (
+                self.substrate.query(
+                    module="Network", storage_function="TotalOverwatchNodes"
+                ).value
+                or 0
+            )
+
+            # Query each node
+            for node_id in range(1, total_nodes + 1):
+                node_info = self.get_overwatch_node_info(node_id)
+                if node_info:
+                    nodes.append(node_info)
+
+            return nodes
+
+        except Exception as e:
+            logger.error(f"Error listing overwatch nodes: {e}")
+            return []
+
+    def check_overwatch_qualification(
+        self, coldkey: str, hotkey: Optional[str] = None
+    ) -> dict[str, Any]:
+        """
+        Check if a coldkey meets overwatch node registration requirements.
+        
+        This mirrors the logic in the EVM codebase:
+        - hypertensor-evm/pallets/network/src/overwatch_nodes/registering.rs
+          - do_register_overwatch_node() - lines 21-93: Registration checks
+          - is_overwatch_node_qualified() - lines 132-200: Qualification logic
+        
+        Requirements checked:
+        1. Overwatch epochs have started (epoch > 0)
+        2. Network not at max capacity (TotalOverwatchNodes < MaxOverwatchNodes)
+        3. Coldkey not blacklisted (OverwatchNodeBlacklist)
+        4. Hotkey != coldkey (if hotkey provided)
+        5. Hotkey has no existing owner (if hotkey provided)
+        6. Hotkey not already in coldkey's hotkeys (if hotkey provided)
+        7. Network age sufficient (current_epoch > min_age)
+        8. Coldkey age >= OverwatchMinAge epochs
+        9. Reputation score >= OverwatchMinRepScore
+        10. Diversification ratio >= OverwatchMinDiversificationRatio
+        11. Average attestation >= OverwatchMinAvgAttestationRatio
+        12. Balance >= OverwatchMinStakeBalance
+        
+        Args:
+            coldkey: Coldkey address (hex string starting with 0x)
+            hotkey: Optional hotkey address to validate (hex string starting with 0x)
+            
+        Returns:
+            Dictionary with qualification status and detailed breakdown
+        """
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+            
+            # Normalize coldkey address
+            if coldkey.startswith("0x"):
+                coldkey = coldkey.lower()
+            
+            # Normalize hotkey address if provided
+            if hotkey and hotkey.startswith("0x"):
+                hotkey = hotkey.lower()
+            
+            requirements_met = []
+            requirements_failed = []
+            
+            # ========================================
+            # 1. Check overwatch epoch > 0
+            # Source: era.rs line 51-56: get_current_overwatch_epoch_as_u32()
+            # Overwatch epoch = current_block / (epoch_length * multiplier)
+            # ========================================
+            # Get current block number (requires block hash)
+            latest_hash = self.substrate.get_block_hash()
+            current_block = self.substrate.get_block_number(block_hash=latest_hash) if latest_hash else 0
+            if not current_block:
+                current_block = 0
+
+            
+            # Get EpochLength constant
+            epoch_length_result = self.substrate.get_constant("Network", "EpochLength")
+            epoch_length = epoch_length_result.value if epoch_length_result else 100
+            
+            # Get OverwatchEpochLengthMultiplier storage
+            multiplier_result = self.substrate.query(
+                module="Network", storage_function="OverwatchEpochLengthMultiplier"
+            )
+            multiplier = multiplier_result.value if multiplier_result and multiplier_result.value else 1
+            
+            # Calculate overwatch epoch: current_block / (epoch_length * multiplier)
+            overwatch_epoch_length = epoch_length * multiplier
+            current_overwatch_epoch = current_block // overwatch_epoch_length if overwatch_epoch_length > 0 else 0
+            
+            # Calculate current epoch: current_block / epoch_length
+            current_epoch = current_block // epoch_length if epoch_length > 0 else 0
+            
+            if current_overwatch_epoch > 0:
+                requirements_met.append(
+                    f"Overwatch epochs started (current epoch: {current_overwatch_epoch})"
+                )
+            else:
+                requirements_failed.append(
+                    "Overwatch epochs have not started yet (epoch is 0)"
+                )
+            
+            # ========================================
+            # 2. Check network capacity
+            # Source: registering.rs line 38-43
+            # ========================================
+            total_overwatch_nodes = self.substrate.query(
+                module="Network", storage_function="TotalOverwatchNodes"
+            ).value or 0
+            
+            max_overwatch_nodes = self.substrate.query(
+                module="Network", storage_function="MaxOverwatchNodes"
+            ).value or 0
+            
+            if total_overwatch_nodes < max_overwatch_nodes:
+                requirements_met.append(
+                    f"Network capacity available ({total_overwatch_nodes}/{max_overwatch_nodes} nodes registered)"
+                )
+            else:
+                requirements_failed.append(
+                    f"Network at max capacity ({total_overwatch_nodes}/{max_overwatch_nodes} nodes)"
+                )
+            
+            # ========================================
+            # 3. Check blacklist
+            # Source: registering.rs line 28-31
+            # ========================================
+            is_blacklisted = self.substrate.query(
+                module="Network",
+                storage_function="OverwatchNodeBlacklist",
+                params=[coldkey],
+            ).value or False
+            
+            if not is_blacklisted:
+                requirements_met.append("Coldkey not blacklisted")
+            else:
+                requirements_failed.append("Coldkey is blacklisted from overwatch registration")
+            
+            # ========================================
+            # 3a. Hotkey-specific checks (if hotkey provided)
+            # Source: registering.rs lines 45, 48-58
+            # ========================================
+            if hotkey:
+                # Check hotkey != coldkey (line 45)
+                if hotkey.lower() == coldkey.lower():
+                    requirements_failed.append(
+                        "Hotkey cannot be the same as coldkey"
+                    )
+                else:
+                    requirements_met.append("Hotkey is different from coldkey")
+                
+                # Check hotkey doesn't already have an owner (line 48-51)
+                try:
+                    hotkey_owner_result = self.substrate.query(
+                        module="Network",
+                        storage_function="HotkeyOwner",
+                        params=[hotkey],
+                    )
+                    hotkey_owner = hotkey_owner_result.value if hotkey_owner_result else None
+                    
+                    # Check if owner is a zero/null address (treat as no owner)
+                    is_zero_address = False
+                    if hotkey_owner:
+                        owner_str = str(hotkey_owner).lower()
+                        # Check for zero address patterns
+                        is_zero_address = (
+                            owner_str == "0x0000000000000000000000000000000000000000" or
+                            owner_str.replace("0x", "").replace("0", "") == "" or
+                            owner_str.startswith("0x00000000")
+                        )
+                    
+                    if hotkey_owner and not is_zero_address:
+                        # Format the address properly with color markup
+                        from ...utils.wallet.crypto import format_address_display
+                        formatted_owner = format_address_display(str(hotkey_owner))
+                        requirements_failed.append(
+                            f"Hotkey already has an owner (owned by [htcli.address]{formatted_owner}[/htcli.address])"
+                        )
+                    else:
+                        requirements_met.append("Hotkey is fresh (no existing owner)")
+                except Exception as e:
+                    logger.warning(f"Could not check HotkeyOwner: {e}")
+                    requirements_met.append("Hotkey owner check skipped (storage query failed)")
+                
+                # Check hotkey not already in coldkey's hotkeys (line 53-58)
+                try:
+                    coldkey_hotkeys_result = self.substrate.query(
+                        module="Network",
+                        storage_function="ColdkeyHotkeys",
+                        params=[coldkey],
+                    )
+                    coldkey_hotkeys = coldkey_hotkeys_result.value if coldkey_hotkeys_result else None
+                    
+                    # Handle different return formats (set, list, etc.)
+                    if coldkey_hotkeys:
+                        if isinstance(coldkey_hotkeys, (set, list)):
+                            hotkey_in_set = hotkey in coldkey_hotkeys or hotkey.lower() in [h.lower() if isinstance(h, str) else str(h).lower() for h in coldkey_hotkeys]
+                        else:
+                            hotkey_in_set = False
+                        
+                        if hotkey_in_set:
+                            requirements_failed.append(
+                                "Hotkey already registered to this coldkey"
+                            )
+                        else:
+                            requirements_met.append("Hotkey not already registered to coldkey")
+                    else:
+                        requirements_met.append("Hotkey not already registered to coldkey")
+                except Exception as e:
+                    logger.warning(f"Could not check ColdkeyHotkeys: {e}")
+                    requirements_met.append("Coldkey hotkeys check skipped (storage query failed)")
+            
+            # ========================================
+            # 4. Get coldkey reputation for age, score, attestation checks
+            # Source: registering.rs line 64-70, 132-200
+            # ========================================
+            reputation_data = self.substrate.query(
+                module="Network",
+                storage_function="ColdkeyReputation",
+                params=[coldkey],
+            ).value
+            
+            # Get minimum requirements
+            min_age = self.substrate.query(
+                module="Network", storage_function="OverwatchMinAge"
+            ).value or 0
+            
+            min_rep_score = self.substrate.query(
+                module="Network", storage_function="OverwatchMinRepScore"
+            ).value or 0
+            
+            min_diversification = self.substrate.query(
+                module="Network", storage_function="OverwatchMinDiversificationRatio"
+            ).value or 0
+            
+            min_avg_attestation = self.substrate.query(
+                module="Network", storage_function="OverwatchMinAvgAttestationRatio"
+            ).value or 0
+            
+            min_stake_balance = self.substrate.query(
+                module="Network", storage_function="OverwatchMinStakeBalance"
+            ).value or 0
+
+            
+            # Process reputation data
+            if reputation_data:
+                start_epoch = reputation_data.get("start_epoch", 0)
+                rep_score = reputation_data.get("score", 0)
+                avg_attestation = reputation_data.get("average_attestation", 0)
+                
+                # ========================================
+                # 4a. Check network age (no one can qualify if network too young)
+                # Source: registering.rs line 145-147
+                # ========================================
+                if current_epoch <= min_age:
+                    requirements_failed.append(
+                        f"Network too young: no one can qualify until epoch {min_age + 1} "
+                        f"(current epoch: {current_epoch})"
+                    )
+                else:
+                    requirements_met.append(
+                        f"Network age sufficient (epoch {current_epoch} > min_age {min_age})"
+                    )
+                
+                # ========================================
+                # 4b. Check coldkey age
+                # Source: registering.rs line 149-153
+                # ========================================
+                age = current_epoch - start_epoch if current_epoch >= start_epoch else 0
+                
+                if age >= min_age:
+                    requirements_met.append(
+                        f"Coldkey age requirement met ({age}/{min_age} epochs)"
+                    )
+                else:
+                    requirements_failed.append(
+                        f"Coldkey age not met ({age}/{min_age} epochs, need {min_age - age} more)"
+                    )
+                
+                # ========================================
+                # 4b. Check reputation score
+                # Source: registering.rs line 155-157
+                # ========================================
+                if rep_score >= min_rep_score:
+                    requirements_met.append(
+                        f"Reputation score met ({rep_score}/{min_rep_score})"
+                    )
+                else:
+                    requirements_failed.append(
+                        f"Reputation score not met ({rep_score}/{min_rep_score})"
+                    )
+                
+                # ========================================
+                # 4c. Check average attestation
+                # Source: registering.rs line 195-197
+                # ========================================
+                # Convert to percentage for display (values are in 1e18 format)
+                avg_attestation_pct = avg_attestation / 1e16 if avg_attestation else 0
+                min_attestation_pct = min_avg_attestation / 1e16 if min_avg_attestation else 0
+                
+                if avg_attestation >= min_avg_attestation:
+                    requirements_met.append(
+                        f"Average attestation met ({avg_attestation_pct:.2f}% >= {min_attestation_pct:.2f}%)"
+                    )
+                else:
+                    requirements_failed.append(
+                        f"Average attestation not met ({avg_attestation_pct:.2f}% < {min_attestation_pct:.2f}%)"
+                    )
+            else:
+                # No reputation history
+                requirements_failed.append(
+                    f"No reputation history found for coldkey (need {min_age} epochs of activity)"
+                )
+                requirements_failed.append(
+                    f"Reputation score not available (need {min_rep_score})"
+                )
+                requirements_failed.append(
+                    f"Average attestation not available"
+                )
+            
+            # ========================================
+            # 5. Check diversification ratio
+            # Source: registering.rs line 159-193
+            # ========================================
+            coldkey_subnet_nodes = self.substrate.query(
+                module="Network",
+                storage_function="ColdkeySubnetNodes",
+                params=[coldkey],
+            ).value or {}
+            
+            total_active_subnets = self.substrate.query(
+                module="Network", storage_function="TotalActiveSubnets"
+            ).value or 0
+            
+            # Count unique subnets with active nodes
+            active_unique_subnets = len(coldkey_subnet_nodes) if coldkey_subnet_nodes else 0
+            
+            # Calculate diversification (simplified - actual calculation is more complex)
+            # Source: registering.rs line 183-189
+            if total_active_subnets > 0:
+                diversification = (active_unique_subnets * 100 * 1e16) / total_active_subnets
+            else:
+                diversification = 100 * 1e16 if active_unique_subnets > 0 else 0
+            
+            diversification_pct = diversification / 1e16 if diversification else 0
+            min_diversification_pct = min_diversification / 1e16 if min_diversification else 0
+            
+            if diversification >= min_diversification:
+                requirements_met.append(
+                    f"Diversification met ({active_unique_subnets} subnets, {diversification_pct:.2f}% >= {min_diversification_pct:.2f}%)"
+                )
+            else:
+                requirements_failed.append(
+                    f"Diversification not met ({active_unique_subnets} subnets, {diversification_pct:.2f}% < {min_diversification_pct:.2f}%)"
+                )
+            
+            # ========================================
+            # 6. Check balance for minimum stake
+            # Source: registering.rs line 72-74 (calls do_add_overwatch_stake)
+            # ========================================
+            try:
+                balance_result = self.substrate.query(
+                    module="System",
+                    storage_function="Account",
+                    params=[coldkey],
+                )
+                free_balance = balance_result.value.get("data", {}).get("free", 0) if balance_result.value else 0
+            except Exception:
+                free_balance = 0
+            
+            # Debug logging to diagnose potential value mismatches
+            logger.debug(f"Balance check - coldkey: {coldkey}")
+            logger.debug(f"Balance check - min_stake_balance (raw): {min_stake_balance} (type: {type(min_stake_balance)})")
+            logger.debug(f"Balance check - free_balance (raw): {free_balance} (type: {type(free_balance)})")
+            
+            min_stake_tensor = min_stake_balance / 1e18 if isinstance(min_stake_balance, (int, float)) else 0
+            balance_tensor = free_balance / 1e18 if isinstance(free_balance, (int, float)) else 0
+            
+            logger.debug(f"Balance check - min_stake_tensor: {min_stake_tensor}, balance_tensor: {balance_tensor}")
+            
+            # Ensure both values are numeric for comparison
+            try:
+                min_stake_numeric = int(min_stake_balance) if min_stake_balance else 0
+                free_balance_numeric = int(free_balance) if free_balance else 0
+            except (ValueError, TypeError):
+                min_stake_numeric = 0
+                free_balance_numeric = 0
+            
+            if free_balance_numeric >= min_stake_numeric:
+                requirements_met.append(
+                    f"Sufficient balance for min stake ({balance_tensor:.2f} TENSOR >= {min_stake_tensor:.2f} TENSOR)"
+                )
+            else:
+                requirements_failed.append(
+                    f"Insufficient balance ({balance_tensor:.2f} TENSOR < {min_stake_tensor:.2f} TENSOR required)"
+                )
+            
+            # ========================================
+            # Determine overall qualification
+            # ========================================
+            can_register = len(requirements_failed) == 0
+            
+            return {
+                "success": True,
+                "data": {
+                    "coldkey": coldkey,
+                    "hotkey": hotkey,
+                    "can_register": can_register,
+                    "requirements_met": requirements_met,
+                    "requirements_failed": requirements_failed,
+                    "details": {
+                        "current_overwatch_epoch": current_overwatch_epoch,
+                        "current_epoch": current_epoch,
+                        "total_overwatch_nodes": total_overwatch_nodes,
+                        "max_overwatch_nodes": max_overwatch_nodes,
+                        "is_blacklisted": is_blacklisted,
+                        "min_age_epochs": min_age,
+                        "min_rep_score": min_rep_score,
+                        "min_diversification_pct": min_diversification_pct,
+                        "min_avg_attestation_pct": min_avg_attestation / 1e16 if min_avg_attestation else 0,
+                        "min_stake_tensor": min_stake_tensor,
+                        "coldkey_subnets": active_unique_subnets,
+                        "total_active_subnets": total_active_subnets,
+                        "balance_tensor": balance_tensor,
+                        "reputation": reputation_data,
+                    },
+                },
+            }
+            
+        except Exception as e:
+            logger.error(f"Error checking overwatch qualification: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "data": {
+                    "coldkey": coldkey,
+                    "can_register": False,
+                    "requirements_met": [],
+                    "requirements_failed": [f"Error checking qualification: {str(e)}"],
+                },
+            }
+