htcli 1.1.0__py3-none-any.whl

src/htcli/ui/components/trees.py

@@ -0,0 +1,721 @@
+"""
+HTCLI tree components.
+Provides enhanced trees for hierarchical data display.
+"""
+
+from typing import Any
+
+from rich.console import Console
+from rich.text import Text
+from rich.tree import Tree
+
+from ..colors import HTCLIColors
+from ..display import get_console
+
+
+class HTCLITree:
+    """Enhanced tree for displaying hierarchical HTCLI data."""
+
+    def __init__(
+        self,
+        label: str,
+        style: str = "htcli.tree",
+        guide_style: str = "htcli.tree.branch",
+        expanded: bool = True,
+        hide_root: bool = False,
+    ):
+        # Create the root label with proper styling
+        if isinstance(label, str):
+            root_label = Text(label, style="htcli.title")
+        else:
+            root_label = label
+
+        self.tree = Tree(
+            root_label,
+            style=style,
+            guide_style=guide_style,
+            expanded=expanded,
+            hide_root=hide_root,
+        )
+        self.style = style
+        self.guide_style = guide_style
+
+    def add_branch(
+        self,
+        label: str,
+        style: str = None,
+        expanded: bool = True,
+        data: dict[str, Any] = None,
+        parent=None,
+    ):
+        """Add a branch to the tree with optional data formatting."""
+        # Use parent branch or root tree
+        target = parent or self.tree
+
+        # Create formatted label
+        if isinstance(label, str):
+            branch_label = Text(label, style=style or "htcli.subtitle")
+        else:
+            branch_label = label
+
+        branch = target.add(branch_label, expanded=expanded)
+
+        # Add data as sub-items if provided
+        if data:
+            self._add_data_to_branch(branch, data)
+
+        return branch
+
+    def add_leaf(
+        self,
+        label: str,
+        value: Any = None,
+        style: str = None,
+        parent=None,
+    ):
+        """Add a leaf node (no children) to the tree."""
+        target = parent or self.tree
+
+        if value is not None:
+            # Format the key-value pair
+            formatted_value = self._format_value(str(value))
+            leaf_text = f"[{style or 'htcli.subtitle'}]{label}:[/] {formatted_value}"
+        else:
+            leaf_text = Text(label, style=style or "htcli.value")
+
+        return target.add(leaf_text)
+
+    def _add_data_to_branch(self, branch, data: dict[str, Any]):
+        """Add data dictionary as child nodes to a branch."""
+        for key, value in data.items():
+            if key.lower() == "name":
+                continue  # Skip name as it's usually in the branch label
+
+            formatted_value = self._format_value(str(value), key)
+            key_display = key.replace("_", " ").title()
+            branch.add(f"[htcli.subtitle]{key_display}:[/] {formatted_value}")
+
+    def _format_value(self, value: str, key: str = None) -> str:
+        """Format a value based on its type/context."""
+        if key:
+            key_lower = key.lower()
+            if key_lower in ["address", "account", "validator", "owner"]:
+                return f"[htcli.address]{value}[/]"
+            elif key_lower in ["amount", "balance", "stake", "total_stake"]:
+                return f"[htcli.amount]{value}[/]"
+            elif key_lower in ["status", "state"]:
+                color = HTCLIColors.get_status_color(value)
+                return f"[{color}]{value}[/]"
+            elif key_lower in ["hash", "tx_hash", "block_hash", "peer_id"]:
+                return f"[htcli.hash]{value}[/]"
+            elif key_lower in ["id", "node_count", "nodes"]:
+                return f"[htcli.value]{value}[/]"
+
+        # Default formatting
+        return f"[htcli.value]{value}[/]"
+
+    def add_subnet_branch(self, subnet_data: dict[str, Any]):
+        """Add a subnet branch with standardized formatting."""
+        subnet_id = subnet_data.get("id", "Unknown")
+        subnet_name = subnet_data.get("name", "Unknown Subnet")
+
+        # Create main branch with emoji and name
+        branch_label = f"🌐 Subnet {subnet_id} ({subnet_name})"
+        branch = self.add_branch(branch_label, style="htcli.subnet", data=subnet_data)
+
+        return branch
+
+    def add_node_branch(self, node_data: dict[str, Any], parent=None):
+        """Add a node branch with standardized formatting."""
+        node_id = node_data.get("id", "Unknown")
+        peer_id = node_data.get("peer_id", "Unknown")
+
+        # Truncate peer_id for display
+        if peer_id != "Unknown" and len(peer_id) > 20:
+            display_peer = f"{peer_id[:12]}...{peer_id[-6:]}"
+        else:
+            display_peer = peer_id
+
+        # Create node branch with emoji and identifier
+        branch_label = f"🔗 Node {node_id} ({display_peer})"
+        branch = self.add_branch(
+            branch_label, style="htcli.node", data=node_data, parent=parent
+        )
+
+        return branch
+
+    def add_wallet_branch(self, wallet_data: dict[str, Any], parent=None):
+        """Add a wallet branch with standardized formatting."""
+        wallet_name = wallet_data.get("name", "Unknown Wallet")
+        wallet_type = wallet_data.get("type", "unknown")
+
+        # Create wallet branch with emoji and name
+        branch_label = f"👛 {wallet_name} ({wallet_type})"
+        branch = self.add_branch(
+            branch_label, style="htcli.value", data=wallet_data, parent=parent
+        )
+
+        return branch
+
+    def render(self, console: Console = None):
+        """Render the tree to console."""
+        console = console or get_console().console
+        console.print(self.tree)
+
+    def get_renderable(self):
+        """Get the tree as a renderable object."""
+        return self.tree
+
+
+# Tree utility functions
+def create_network_tree(
+    subnets: list[dict[str, Any]],
+    nodes: dict[int, list[dict[str, Any]]] = None,
+    title: str = "🌐 Hypertensor Network",
+) -> HTCLITree:
+    """Create a standardized network hierarchy tree."""
+    tree = HTCLITree(title, expanded=True)
+
+    nodes = nodes or {}
+
+    for subnet in subnets:
+        # Add subnet branch
+        subnet_branch = tree.add_subnet_branch(subnet)
+
+        # Add nodes under this subnet if available
+        subnet_id = subnet.get("id")
+        if subnet_id and subnet_id in nodes:
+            for node in nodes[subnet_id]:
+                tree.add_node_branch(node, parent=subnet_branch)
+
+    return tree
+
+
+def create_wallet_tree(
+    wallets: list[dict[str, Any]],
+    transactions: dict[str, list[dict[str, Any]]] = None,
+    title: str = "👛 Wallet Overview",
+) -> HTCLITree:
+    """Create a standardized wallet tree with optional transaction history."""
+    tree = HTCLITree(title, expanded=True)
+
+    transactions = transactions or {}
+
+    for wallet in wallets:
+        # Add wallet branch
+        wallet_branch = tree.add_wallet_branch(wallet)
+
+        # Add recent transactions if available
+        wallet_name = wallet.get("name")
+        if wallet_name and wallet_name in transactions:
+            tx_branch = tree.add_branch(
+                "📋 Recent Transactions", style="htcli.subtitle", parent=wallet_branch
+            )
+
+            for tx in transactions[wallet_name][:5]:  # Show last 5 transactions
+                tx_hash = tx.get("hash", "Unknown")
+                tx_amount = tx.get("amount", "0")
+                tx_status = tx.get("status", "unknown")
+
+                # Truncate hash for display
+                display_hash = (
+                    f"{tx_hash[:8]}...{tx_hash[-8:]}" if len(tx_hash) > 16 else tx_hash
+                )
+
+                status_color = HTCLIColors.get_status_color(tx_status)
+                tx_label = f"[htcli.hash]{display_hash}[/] - [htcli.amount]{tx_amount}[/] - [{status_color}]{tx_status}[/]"
+                tree.add_leaf("", tx_label, parent=tx_branch)
+
+    return tree
+
+
+def create_subnet_details_tree(
+    subnet_data: dict[str, Any], nodes: list[dict[str, Any]] = None
+):
+    """Create a detailed table view for a single subnet with bright, bold colors.
+
+    Returns a Rich Table for displaying subnet information in a comprehensive format.
+    """
+    from rich.table import Table
+
+    subnet_name = subnet_data.get("name", "Unknown Subnet")
+    subnet_id = subnet_data.get("id", "Unknown")
+
+    # Decode bytes fields for display
+    if isinstance(subnet_name, bytes):
+        subnet_name = subnet_name.decode("utf-8", errors="ignore")
+
+    # Helper function to format values
+    def format_field_value(key: str, value: Any) -> str:
+        """Format a field value for display."""
+        if value is None:
+            return "[dim]None[/dim]"
+
+        # Handle bytes
+        if isinstance(value, bytes):
+            try:
+                decoded = value.decode("utf-8")
+                return f"[cyan]{decoded}[/cyan]" if decoded else "[dim](empty)[/dim]"
+            except (UnicodeDecodeError, AttributeError):
+                return f"[dim]{value.hex()[:20]}...[/dim]"
+
+        # Handle enum/state
+        if hasattr(value, "value"):
+            value = value.value
+        elif hasattr(value, "name"):
+            value = value.name
+
+        value_str = str(value)
+
+        # Format based on field type
+        key_lower = key.lower()
+
+        # Handle percentage fields first (they contain "stake" but should be formatted as percentages)
+        if (
+            key_lower == "delegate_stake_percentage"
+            or "delegate_stake_percentage" in key_lower
+        ):
+            # Percentage fields are stored as wei where 1e18 = 100%
+            # Show the value even if it's u32::MAX or very large
+            if isinstance(value, (int, float)) and value >= 0:
+                percentage_value = (value / 1e18) * 100
+                # Show percentage if reasonable, otherwise show raw value
+                if 0 <= percentage_value <= 100:
+                    return f"[#53B5A0]{percentage_value:.2f}%[/#53B5A0]"
+                else:
+                    # Show raw value for u32::MAX or out-of-range values
+                    return f"[yellow]{value}[/yellow]"
+            return f"[yellow]{value}[/yellow]" if value is not None else "[dim]Not set[/dim]"
+        elif "stake" in key_lower or "balance" in key_lower:
+            # Format as TENSOR (convert from wei) - always show value
+            if isinstance(value, (int, float)) and value >= 0:
+                tensor_value = value / 1e18
+                return f"[#53B5A0]{tensor_value:,.2f} TENSOR[/#53B5A0]"
+            elif isinstance(value, (int, float)):
+                # Show raw value if negative (shouldn't happen but show it anyway)
+                return f"[yellow]{value}[/yellow]"
+            return f"[yellow]{value}[/yellow]" if value is not None else "[dim]Not set[/dim]"
+        elif "address" in key_lower or "owner" in key_lower:
+            if value is None or value_str == "None" or not value_str:
+                return "[dim]Not set[/dim]"
+            # Always show full address, no truncation
+            return f"[steel_blue3]{value_str}[/steel_blue3]"
+        elif "state" in key_lower:
+            state_str = str(value).lower()
+            if "active" in state_str:
+                return "[bold green]Active[/bold green]"
+            elif "registered" in state_str:
+                return "[bold yellow]Registered[/bold yellow]"
+            elif "paused" in state_str:
+                return "[bold red]Paused[/bold red]"
+        elif key_lower == "start_epoch":
+            try:
+                numeric_value = int(value)
+            except Exception:
+                numeric_value = None
+            # u32::MAX (4294967295) indicates the subnet has not been activated yet
+            if numeric_value is not None and numeric_value == 4294967295:
+                return "[bold yellow]Not Active[/bold yellow] [dim](4294967295)[/dim]"
+            return f"[cyan]{value}[/cyan]"
+        elif key_lower == "registration_epoch":
+            try:
+                numeric_value = int(value)
+            except Exception:
+                numeric_value = None
+            # u32::MAX indicates the subnet has not been activated yet
+            if numeric_value is not None and numeric_value >= 0xFFFFFFFF:
+                return "[bold yellow]Subnet is not active yet[/bold yellow]"
+            return f"[cyan]{value}[/cyan]"
+        elif "epoch" in key_lower:
+            # Always show epoch value, even if it's u32::MAX
+            return f"[cyan]{value}[/cyan]"
+        elif isinstance(value, dict) and key_lower == "initial_coldkeys":
+            # Format initial_coldkeys as a nice list with addresses and max registrations
+            if not value or len(value) == 0:
+                return "[dim](empty)[/dim]"
+            items = []
+            for addr, max_regs in sorted(value.items()):
+                # Format address nicely and show max registrations
+                items.append(f"  • [steel_blue3]{addr}[/steel_blue3]: [cyan]{max_regs} nodes[/cyan]")
+            # Show all items, one per line for readability
+            if len(items) <= 5:
+                return f"[cyan]{chr(10).join(items)}[/cyan]"
+            else:
+                # Show first 5, then count
+                return f"[cyan]{chr(10).join(items[:5])}{chr(10)}  ... ({len(items)} total)[/cyan]"
+        elif isinstance(value, set):
+            if len(value) == 0:
+                return "[dim](empty)[/dim]"
+            # Format set contents nicely
+            if key_lower == "key_types":
+                # KeyType enum values - show name if available, otherwise value
+                items = []
+                for item in value:
+                    if hasattr(item, 'name'):
+                        items.append(item.name)
+                    elif hasattr(item, 'value'):
+                        items.append(str(item.value))
+                    else:
+                        items.append(str(item))
+                return f"[cyan]{', '.join(sorted(items))}[/cyan]"
+            elif key_lower == "bootnode_access":
+                # Address strings - show full addresses
+                items = list(value)
+                if len(items) > 3:
+                    # Show first 3 full addresses, then count
+                    return f"[cyan]{', '.join(list(items)[:3])}... ({len(items)} total)[/cyan]"
+                # Show all addresses in full
+                return f"[cyan]{', '.join(items)}[/cyan]"
+            elif key_lower == "bootnodes":
+                # Bytes - decode or show hex
+                items = []
+                for item in list(value)[:5]:  # Limit to first 5
+                    if isinstance(item, bytes):
+                        try:
+                            decoded = item.decode("utf-8")
+                            items.append(decoded)
+                        except (UnicodeDecodeError, AttributeError):
+                            items.append(f"0x{item.hex()[:16]}...")
+                    else:
+                        items.append(str(item))
+                if len(value) > 5:
+                    return f"[cyan]{', '.join(items)}... ({len(value)} total)[/cyan]"
+                return f"[cyan]{', '.join(items)}[/cyan]"
+            else:
+                # Generic set formatting
+                items = [str(item) for item in list(value)[:10]]
+                if len(value) > 10:
+                    return f"[cyan]{', '.join(items)}... ({len(value)} total)[/cyan]"
+                return f"[cyan]{', '.join(items)}[/cyan]"
+        elif isinstance(value, (int, float)) and value > 1000000000000:
+            # Very large numbers - might be incorrectly decoded
+            # Format in scientific notation for readability
+            return f"[yellow]{value:.2e}[/yellow]"
+
+        return f"[white]{value_str}[/white]"
+
+    # Create table for subnet details with bright, bold colors
+    table = Table(
+        title=f"[bold white]Subnet [bold cyan]{subnet_id}[/bold cyan]: [cyan]{subnet_name}[/cyan]\n",
+        show_header=True,
+        header_style="bold white",
+        border_style="bright_black",
+        style="bold",
+        show_edge=False,
+        show_lines=False,
+        pad_edge=True,
+        title_justify="left",
+    )
+
+    table.add_column(
+        "[bold white]Field[/bold white]", style="bold tan", no_wrap=True, width=40
+    )
+    table.add_column(
+        "[bold white]Value[/bold white]", style="white", overflow="fold", width=60
+    )
+
+    # Define field display order and grouping
+    field_groups = {
+        "Basic Information": [
+            "id",
+            "friendly_id",
+            "name",
+            "repo",
+            "description",
+            "misc",
+            "state",
+            "owner",
+            "pending_owner",
+        ],
+        "Node Configuration": [
+            "total_nodes",
+            "total_active_nodes",
+            "total_electable_nodes",
+            "max_registered_nodes",
+            "churn_limit",
+            "churn_limit_multiplier",
+            "node_registrations_this_epoch",
+        ],
+        "Staking Configuration": [
+            "min_stake",
+            "max_stake",
+            "current_min_delegate_stake",
+            "delegate_stake_percentage",
+            "last_delegate_stake_rewards_update",
+            "total_subnet_stake",
+            "total_subnet_delegate_stake_shares",
+            "total_subnet_delegate_stake_balance",
+        ],
+        "Epoch Settings": [
+            "start_epoch",
+            "registration_epoch",
+            "prev_pause_epoch",
+            "queue_immunity_epochs",
+            "target_node_registrations_per_epoch",
+            "subnet_node_queue_epochs",
+            "idle_classification_epochs",
+            "included_classification_epochs",
+        ],
+        "Reputation Settings": [
+            "reputation",
+            "min_subnet_node_reputation",
+            "subnet_node_min_weight_decrease_reputation_threshold",
+            "absent_decrease_reputation_factor",
+            "included_increase_reputation_factor",
+            "below_min_weight_decrease_reputation_factor",
+            "non_attestor_decrease_reputation_factor",
+            "non_consensus_attestor_decrease_reputation_factor",
+            "validator_absent_subnet_node_reputation_factor",
+            "validator_non_consensus_subnet_node_reputation_factor",
+        ],
+        "Other": [
+            "node_burn_rate_alpha",
+            "current_node_burn_rate",
+            "initial_coldkeys",
+            "initial_coldkey_data",
+            "key_types",
+            "slot_index",
+            "slot_assignment",
+            "bootnode_access",
+            "bootnodes",
+        ],
+    }
+
+    # Add fields grouped by category - SHOW ALL FIELDS
+    displayed_fields = set()
+    for group_name, fields in field_groups.items():
+        # Special handling: always show owner and pending_owner even if None
+        # Also show sets even if empty (they'll display as "(empty)")
+        group_fields = []
+        for f in fields:
+            if f in subnet_data:
+                # Always include ALL fields - show everything
+                group_fields.append(f)
+        if group_fields:
+            # Add group header
+            table.add_row(f"[bold cyan]{group_name}[/bold cyan]", "", style="dim")
+
+            for field in group_fields:
+                value = subnet_data[field]
+                formatted_value = format_field_value(field, value)
+                field_display = field.replace("_", " ").title()
+                table.add_row(f"  {field_display}", formatted_value)
+                displayed_fields.add(field)
+
+    # Add any remaining fields not in groups - SHOW ALL, even if None or 0
+    for key, value in subnet_data.items():
+        if key not in displayed_fields:
+            formatted_value = format_field_value(key, value)
+            key_display = key.replace("_", " ").title()
+            table.add_row(key_display, formatted_value)
+
+    return table
+
+
+def create_transaction_tree(
+    transactions: list[dict[str, Any]], title: str = "📋 Transactions"
+) -> HTCLITree:
+    """Create a tree view for transaction history."""
+    tree = HTCLITree(title, expanded=True)
+
+    # Group transactions by status
+    status_groups = {}
+    for tx in transactions:
+        status = tx.get("status", "unknown")
+        if status not in status_groups:
+            status_groups[status] = []
+        status_groups[status].append(tx)
+
+    # Add each status group as a branch
+    for status, tx_list in status_groups.items():
+        status_color = HTCLIColors.get_status_color(status)
+        status_branch = tree.add_branch(
+            f"[{status_color}]{status.title()} ({len(tx_list)})[/]",
+            style="htcli.subtitle",
+        )
+
+        for tx in tx_list:
+            tx_hash = tx.get("hash", "Unknown")
+            tx_amount = tx.get("amount", "0")
+            tx_from = tx.get("from", "Unknown")
+            tx_to = tx.get("to", "Unknown")
+
+            # Create transaction details
+            tx_details = {
+                "hash": tx_hash,
+                "amount": f"{tx_amount} TENSOR",
+                "from": tx_from,
+                "to": tx_to,
+                "timestamp": tx.get("timestamp", "Unknown"),
+            }
+
+            # Truncate hash for branch label
+            display_hash = (
+                f"{tx_hash[:8]}...{tx_hash[-8:]}" if len(tx_hash) > 16 else tx_hash
+            )
+            tree.add_branch(
+                f"📄 {display_hash}",
+                style="htcli.hash",
+                data=tx_details,
+                parent=status_branch,
+            )
+
+    return tree
+
+
+def create_wallet_hierarchy_tree(wallets: list[dict[str, Any]]) -> None:
+    """
+    Create a beautiful hierarchical tree display showing coldkeys and their associated hotkeys.
+    Enhanced version with Rich Tree, icons, encryption status, and better formatting.
+    """
+    from collections import defaultdict
+
+    from ..display import HTCLIConsole
+
+    console = HTCLIConsole()
+
+    # Separate coldkeys and hotkeys
+    coldkeys = [k for k in wallets if not k.get("is_hotkey", False)]
+    hotkeys = [k for k in wallets if k.get("is_hotkey", False)]
+
+    # If no wallets, return early (should be handled by display_wallet_list, but safety check)
+    if not coldkeys and not hotkeys:
+        return
+
+    # Create a set of coldkey addresses for quick lookup
+    coldkey_addresses = {coldkey.get("ss58_address") for coldkey in coldkeys}
+
+    # Group hotkeys by owner
+    hotkeys_by_owner = defaultdict(list)
+    orphaned_hotkeys = []
+
+    for hotkey in hotkeys:
+        owner_address = hotkey.get("owner_address")
+        owner_coldkey_name = hotkey.get("owner_coldkey_name")
+        # Check if owner exists (by address or by name)
+        owner_found = False
+
+        # First, try to find by address
+        if owner_address and owner_address in coldkey_addresses:
+            # Valid owner found by address - add to grouped hotkeys
+            hotkeys_by_owner[owner_address].append(hotkey)
+            owner_found = True
+        elif owner_coldkey_name:
+            # Try to find by coldkey name (even if owner_address doesn't match)
+            matching_coldkey = next(
+                (ck for ck in coldkeys if ck.get("name") == owner_coldkey_name),
+                None
+            )
+            if matching_coldkey:
+                # Found by name - add to grouped hotkeys
+                hotkeys_by_owner[matching_coldkey.get("ss58_address")].append(hotkey)
+                owner_found = True
+
+        # If owner_address exists but doesn't match any coldkey, it's orphaned
+        # (This handles the case where coldkey was deleted but hotkey file remains)
+        if not owner_found:
+            orphaned_hotkeys.append(hotkey)
+
+    # Create root tree
+    root = Tree("💼 Wallets", style="bold cyan", guide_style="dim cyan")
+
+    # Display coldkeys with their hotkeys
+    for coldkey in coldkeys:
+        coldkey_name = coldkey.get("name", "N/A")
+        coldkey_address = coldkey.get("ss58_address", "N/A")
+        is_encrypted = coldkey.get("is_encrypted", False)
+        key_type = coldkey.get("key_type", "ecdsa").upper()
+
+        # Format coldkey label with icon, name, address, and status
+        # Show lock icon only for encrypted wallets, no icon for unencrypted
+        coldkey_label = Text()
+        coldkey_label.append("Coldkey ", style="bold cyan")
+        coldkey_label.append(coldkey_name, style="bold green")
+        coldkey_label.append(f" {coldkey_address}", style="dim white")
+        coldkey_label.append(f" [{key_type}]", style="dim cyan")
+        # Only show lock icon for encrypted wallets
+        if is_encrypted:
+            coldkey_label.append(" 🔒", style="dim")
+
+        # Add coldkey branch
+        coldkey_branch = root.add(coldkey_label)
+
+        # Find and display hotkeys owned by this coldkey
+        owned_hotkeys = hotkeys_by_owner.get(coldkey_address, [])
+
+        if not owned_hotkeys:
+            # No hotkeys - show placeholder
+            coldkey_branch.add(Text("(no hotkeys)", style="dim italic"))
+
+        for hotkey in owned_hotkeys:
+            hotkey_name = hotkey.get("name", "N/A")
+            # Use EVM address if available (for ECDSA keys), otherwise fall back to ss58_address
+            hotkey_address = hotkey.get("evm_address") or hotkey.get("address") or hotkey.get("ss58_address", "N/A")
+            is_hotkey_encrypted = hotkey.get("is_encrypted", False)
+            hotkey_key_type = hotkey.get("key_type", "ecdsa").upper()
+
+            # Format hotkey label
+            # Show lock icon only for encrypted hotkeys, no icon for unencrypted
+            hotkey_label = Text()
+            hotkey_label.append("⚡ ", style="bold red")
+            hotkey_label.append("Hotkey ", style="bold yellow")
+            hotkey_label.append(hotkey_name, style="bold green")
+            hotkey_label.append(f" {hotkey_address}", style="dim white")
+            hotkey_label.append(f" [{hotkey_key_type}]", style="dim cyan")
+            # Only show lock icon for encrypted hotkeys
+            if is_hotkey_encrypted:
+                hotkey_label.append(" 🔒", style="dim")
+
+            coldkey_branch.add(hotkey_label)
+
+    # Display orphaned hotkeys (hotkeys without a valid coldkey owner)
+    if orphaned_hotkeys:
+        orphaned_branch = root.add(
+            Text("⚠️  Orphaned Hotkeys (no valid owner)", style="bold yellow")
+        )
+
+        for hotkey in orphaned_hotkeys:
+            hotkey_name = hotkey.get("name", "N/A")
+            # Use EVM address if available (for ECDSA keys), otherwise fall back to ss58_address
+            hotkey_address = hotkey.get("evm_address") or hotkey.get("address") or hotkey.get("ss58_address", "N/A")
+            owner_address = hotkey.get("owner_address", "Unknown")
+            owner_coldkey_name = hotkey.get("owner_coldkey_name", "Unknown")
+            is_hotkey_encrypted = hotkey.get("is_encrypted", False)
+            hotkey_key_type = hotkey.get("key_type", "ecdsa").upper()
+
+            # Format orphaned hotkey label
+            # Show lock icon only for encrypted hotkeys, no icon for unencrypted
+            orphaned_label = Text()
+            orphaned_label.append("⚡ ", style="bold red")
+            orphaned_label.append("Hotkey ", style="bold yellow")
+            orphaned_label.append(hotkey_name, style="bold green")
+            orphaned_label.append(f" {hotkey_address}", style="dim white")
+            orphaned_label.append(f" [{hotkey_key_type}]", style="dim cyan")
+            # Only show lock icon for encrypted hotkeys
+            if is_hotkey_encrypted:
+                orphaned_label.append(" 🔒", style="dim")
+            orphaned_label.append(f" (owner: {owner_coldkey_name or owner_address})", style="dim red")
+
+            orphaned_branch.add(orphaned_label)
+
+    # Display the tree
+    console.print(root)
+
+    # Show enhanced summary
+    total_coldkeys = len(coldkeys)
+    total_hotkeys = len(hotkeys)
+    total_orphaned = len(orphaned_hotkeys)
+
+    console.print()
+    summary_text = Text()
+    summary_text.append("📊 Summary: ", style="bold")
+    summary_text.append(f"{total_coldkeys} coldkey", style="cyan")
+    summary_text.append("s" if total_coldkeys != 1 else "", style="cyan")
+    summary_text.append(", ", style="dim")
+    summary_text.append(f"{total_hotkeys} hotkey", style="yellow")
+    summary_text.append("s" if total_hotkeys != 1 else "", style="yellow")
+    if total_orphaned > 0:
+        summary_text.append(" (", style="dim")
+        summary_text.append(f"{total_orphaned} orphaned", style="yellow")
+        summary_text.append(")", style="dim")
+    console.print(summary_text)