htcli 1.1.0__py3-none-any.whl

src/htcli/commands/subnet/display.py

@@ -0,0 +1,801 @@
+from collections import Counter
+from typing import Any, Optional
+
+from ...ui.colors import error, info, success
+from ...ui.components import HTCLIPanel, create_subnet_details_tree, create_subnet_table
+from ...ui.display import HTCLIConsole
+
+console = HTCLIConsole()
+
+
+def display_subnet_list(subnets: list[dict[str, Any]]):
+    """Displays a list of subnets in a table with bright colors and comprehensive information."""
+    if not subnets:
+        console.print(info("ℹ️  No subnets found."))
+        return
+
+    # Use the specialized subnet table function from HTCLI components
+    table = create_subnet_table(subnets)
+    console.print()  # Empty line before table
+    table.render()
+    console.print()  # Empty line after table
+
+
+def display_subnets_overview(subnets: list[Any]):
+    """Display a network-wide overview of all subnets in a comprehensive table layout."""
+    if not subnets:
+        console.print(info("ℹ️  No subnets found on the network."))
+        return
+
+    def _decode_bytes(value: Any, fallback: str) -> str:
+        if isinstance(value, bytes):
+            try:
+                decoded = value.decode("utf-8").strip()
+                return decoded or fallback
+            except UnicodeDecodeError:
+                return fallback
+        if isinstance(value, str):
+            return value or fallback
+        return fallback
+
+    table_data: list[dict[str, Any]] = []
+    state_counter: Counter[str] = Counter()
+    total_nodes = 0
+    total_active_nodes = 0
+
+    for subnet in subnets:
+        if hasattr(subnet, "model_dump"):
+            raw = subnet.model_dump()
+        elif isinstance(subnet, dict):
+            raw = dict(subnet)
+        else:
+            continue
+
+        name = _decode_bytes(raw.get("name"), "Unnamed")
+        owner = raw.get("owner") or "Unknown"
+        state_value = raw.get("state")
+        if hasattr(state_value, "value"):
+            state_text = state_value.value
+        elif hasattr(state_value, "name"):
+            state_text = state_value.name
+        else:
+            state_text = str(state_value or "unknown")
+        normalized_state = state_text.lower()
+        state_counter[normalized_state] += 1
+
+        total_nodes += raw.get("total_nodes") or 0
+        total_active_nodes += raw.get("total_active_nodes") or 0
+
+        # Prefer new field names from updated SubnetInfo, fall back to legacy keys if present
+        total_stake_raw = (
+            raw.get("total_subnet_stake")
+            or raw.get("total_stake")
+            or raw.get("total_stake_balance")
+        )
+        if isinstance(total_stake_raw, (int, float)):
+            # Convert from wei if the value looks like a wei amount
+            stake_display = (
+                int(total_stake_raw / 1e18) if total_stake_raw > 1e12 else int(total_stake_raw)
+            )
+        else:
+            stake_display = 0
+
+        table_data.append(
+            {
+                "id": raw.get("id", "N/A"),
+                "name": name,
+                "owner": owner,
+                "total_nodes": raw.get("total_nodes", 0),
+                "total_stake": stake_display,
+                "state": state_text.title(),
+            }
+        )
+
+    overview_lines = [
+        f"[htcli.value]Total Subnets:[/] {len(table_data)}",
+        f"[htcli.success]Active:[/] {state_counter.get('active', 0)}",
+        f"[htcli.warning]Registered:[/] {state_counter.get('registered', 0)}",
+        f"[htcli.error]Paused:[/] {state_counter.get('paused', 0)}",
+        "",
+        f"[htcli.value]Total Nodes:[/] {total_nodes}",
+        f"[htcli.value]Active Nodes:[/] {total_active_nodes}",
+    ]
+    overview_panel = HTCLIPanel(
+        "\n".join(overview_lines),
+        title="🌐 Network Overview",
+        border_style="htcli.accent",
+        highlight=True,
+    )
+    overview_panel.render()
+
+    table = create_subnet_table(table_data)
+    table.render()
+
+
+def display_subnet_info(subnet: dict[str, Any]):
+    """Displays detailed information for a single subnet."""
+    if not subnet:
+        console.print(error("Subnet data could not be retrieved."))
+        return
+
+    # Use the specialized subnet details tree function from HTCLI components
+    tree = create_subnet_details_tree(subnet)
+    tree.render()
+
+
+def display_subnet_nodes(nodes: list[dict[str, Any]]):
+    """Displays a list of nodes in a table."""
+    if not nodes:
+        console.print(info("No nodes found in this subnet."))
+        return
+
+    # Use HTCLITable for consistent styling
+    from ...ui.components import HTCLITable
+
+    table = HTCLITable(title="Subnet Nodes")
+    table.add_column("Node ID", style="htcli.value", justify="center")
+    table.add_column("Owner", style="htcli.address")
+    table.add_column("Hotkey", style="htcli.address")
+    table.add_column("Status", style="htcli.status.active")
+
+    # Add nodes with proper formatting
+    from ...utils.wallet.crypto import format_address_display
+    for i, node in enumerate(nodes):
+        node_id = str(node.get("id", i))
+        owner = node.get("owner", "N/A")
+        hotkey = node.get("hotkey", "N/A")
+        status = node.get("status", "Unknown")
+
+        # Format addresses properly with checksum
+        owner_formatted = f"[htcli.address]{format_address_display(owner)}[/]" if owner != "N/A" else owner
+        hotkey_formatted = f"[htcli.address]{format_address_display(hotkey)}[/]" if hotkey != "N/A" else hotkey
+
+        table.add_row(node_id, owner_formatted, hotkey_formatted, status)
+
+    # Panel header for consistent framing
+    panel = HTCLIPanel(
+        f"[htcli.accent]Subnet Nodes[/htcli.accent]\n\n[htcli.value]Total:[/htcli.value] {len(nodes)}",
+        title="🧩 Subnet Nodes",
+        border_style="htcli.info",
+        highlight=True,
+    )
+    panel.render()
+    table.render()
+
+
+def display_activation_requirements(requirements: dict[str, Any]):
+    """Displays subnet activation requirements check with comprehensive timeline."""
+    subnet_id = requirements.get("subnet_id", "Unknown")
+
+    # Build epoch information section
+    epoch_info_lines = []
+    current_epoch = requirements.get("current_epoch")
+    current_block = requirements.get("current_block")
+    registration_epoch = requirements.get("registration_epoch")
+    min_registration_epochs = requirements.get("min_registration_epochs")
+    epochs_elapsed = requirements.get("epochs_elapsed")
+    epochs_remaining = requirements.get("epochs_remaining")
+
+    if current_epoch is not None:
+        epoch_info_lines.append(f"Current Epoch: {current_epoch}")
+    if current_block is not None:
+        epoch_info_lines.append(f"Current Block: {current_block:,}")
+    if registration_epoch is not None:
+        epoch_info_lines.append(f"Registration Epoch: {registration_epoch}")
+    if min_registration_epochs is not None:
+        epoch_info_lines.append(f"Minimum Registration Epochs: {min_registration_epochs}")
+    if epochs_elapsed is not None:
+        epoch_info_lines.append(f"Epochs Elapsed: {epochs_elapsed}")
+    if epochs_remaining is not None and epochs_remaining > 0:
+        epoch_info_lines.append(f"Epochs Remaining: {epochs_remaining}")
+
+    # Build timeline section from new timeline data
+    timeline_lines = []
+    timeline = requirements.get("timeline")
+    if timeline:
+        # Current phase - most important info
+        current_phase = timeline.get("current_phase")
+        if current_phase:
+            timeline_lines.append(f"🎯 Current Phase: {current_phase}")
+        
+        # Registration datetime (when subnet was registered)
+        registration_datetime = timeline.get("registration_datetime")
+        if registration_datetime:
+            timeline_lines.append(f"📋 Registered: {registration_datetime}")
+        
+        # Key milestones with datetime estimates
+        min_activation_epoch = timeline.get("min_activation_epoch")
+        registration_deadline_epoch = timeline.get("registration_deadline_epoch")
+        enactment_deadline_epoch = timeline.get("enactment_deadline_epoch")
+        
+        if min_activation_epoch is not None:
+            time_info = timeline.get("time_until_min_activation", {})
+            time_str = time_info.get("human_readable", "")
+            datetime_str = time_info.get("datetime_short", "")
+            if datetime_str and time_str != "Now eligible":
+                timeline_lines.append(f"⏱️  Earliest Activation: Epoch {min_activation_epoch} ({time_str} - {datetime_str})")
+            else:
+                timeline_lines.append(f"⏱️  Earliest Activation: Epoch {min_activation_epoch} ({time_str})")
+        
+        if registration_deadline_epoch is not None:
+            time_info = timeline.get("time_until_registration_deadline", {})
+            time_str = time_info.get("human_readable", "")
+            datetime_str = time_info.get("datetime_short", "")
+            if datetime_str and time_str != "Passed":
+                timeline_lines.append(f"📅 Registration Deadline: Epoch {registration_deadline_epoch} ({time_str} - {datetime_str})")
+            else:
+                timeline_lines.append(f"📅 Registration Deadline: Epoch {registration_deadline_epoch} ({time_str})")
+        
+        if enactment_deadline_epoch is not None:
+            time_info = timeline.get("time_until_enactment_deadline", {})
+            time_str = time_info.get("human_readable", "")
+            datetime_str = time_info.get("datetime_short", "")
+            if datetime_str and "Passed" not in time_str:
+                timeline_lines.append(f"⚠️  Final Deadline: Epoch {enactment_deadline_epoch} ({time_str} - {datetime_str})")
+            else:
+                timeline_lines.append(f"⚠️  Final Deadline: Epoch {enactment_deadline_epoch} ({time_str})")
+        
+        # Epoch length info
+        epoch_length = timeline.get("epoch_length")
+        block_time_ms = timeline.get("block_time_ms")
+        if epoch_length and block_time_ms:
+            epoch_duration_sec = (epoch_length * block_time_ms) / 1000
+            epoch_duration_min = epoch_duration_sec / 60
+            timeline_lines.append(f"📊 Epoch Duration: ~{epoch_duration_min:.0f} minutes ({epoch_length} blocks @ {block_time_ms/1000:.0f}s/block)")
+        
+        # Registration block (approximate)
+        registration_block = timeline.get("registration_block_approx")
+        if registration_block is not None:
+            timeline_lines.append(f"🔗 Registration Block (approx): {registration_block:,}")
+
+    if requirements.get("can_activate", False):
+        # Success case - use HTCLI panel with success styling
+        content_lines = [f"✅ Subnet {subnet_id} can be activated!"]
+        content_lines.append("")  # Empty line
+        
+        # Add timeline section (most important for success case)
+        if timeline_lines:
+            content_lines.append("⏰ Timeline:")
+            content_lines.extend(f"  {line}" for line in timeline_lines)
+            content_lines.append("")  # Empty line
+        
+        # Add epoch information
+        if epoch_info_lines:
+            content_lines.append("📊 Epoch Information:")
+            content_lines.extend(f"  • {line}" for line in epoch_info_lines)
+            content_lines.append("")  # Empty line
+        
+        content_lines.extend(
+            f"✅ {req}" for req in requirements.get("requirements_met", [])
+        )
+
+        panel = HTCLIPanel(
+            "\n".join(content_lines),
+            title="✅ Activation Check Passed",
+            border_style="htcli.success",
+            highlight=True,
+        )
+    else:
+        # Failure case - show both met and failed requirements
+        content_lines = [f"❌ Subnet {subnet_id} cannot be activated yet."]
+        content_lines.append("")  # Empty line
+
+        # Add timeline section (critical for understanding deadlines)
+        if timeline_lines:
+            content_lines.append("⏰ Timeline:")
+            content_lines.extend(f"  {line}" for line in timeline_lines)
+            content_lines.append("")  # Empty line
+
+        # Add epoch information
+        if epoch_info_lines:
+            content_lines.append("📊 Epoch Information:")
+            content_lines.extend(f"  • {line}" for line in epoch_info_lines)
+            content_lines.append("")  # Empty line
+
+        met_reqs = requirements.get("requirements_met", [])
+        failed_reqs = requirements.get("requirements_failed", [])
+
+        if met_reqs:
+            content_lines.append("✅ Requirements Met:")
+            content_lines.extend(f"  ✅ {req}" for req in met_reqs)
+            content_lines.append("")  # Empty line
+
+        if failed_reqs:
+            content_lines.append("❌ Requirements Failed:")
+            content_lines.extend(f"  ❌ {req}" for req in failed_reqs)
+
+        panel = HTCLIPanel(
+            "\n".join(content_lines),
+            title="❌ Activation Check Failed",
+            border_style="htcli.error",
+            highlight=True,
+        )
+
+    panel.render()
+
+
+def display_generic_success(response: dict[str, Any]):
+    """Displays a generic success message with a transaction hash."""
+    message = response.get("message", "Operation completed successfully.")
+    # Handle both 'transaction_hash' and 'extrinsic_hash' keys
+    tx_hash = response.get("transaction_hash") or response.get("extrinsic_hash")
+    block_number = response.get("block_number")
+    block_hash = response.get("block_hash")
+    
+    # Debug: Log what we received
+    from ...utils.logging import get_logger
+    logger = get_logger(__name__)
+    logger.debug(f"display_generic_success received: message={message}, tx_hash={tx_hash}, block_number={block_number}, response_keys={list(response.keys())}")
+    
+    if tx_hash:
+        # Use HTCLI panel for transaction success with hash
+        content = f"{message}\n\n[htcli.subtitle]Transaction Hash:[/] [htcli.hash]{tx_hash}[/]"
+        # Only show block number if it's not None
+        if block_number is not None:
+            content += f"\n[htcli.subtitle]Block Number:[/] [htcli.value]{block_number}[/]"
+        if block_hash:
+            content += f"\n[htcli.subtitle]Block Hash:[/] [htcli.hash]{block_hash}[/]"
+        panel = HTCLIPanel(
+            content,
+            title="✅ Operation Successful",
+            border_style="htcli.success",
+            highlight=True,
+        )
+        panel.render()
+    else:
+        # If no transaction hash, still show the message but warn about missing hash
+        content = f"{message}"
+        if response.get("success") is True:
+            content += "\n\n[htcli.warning]⚠️  Note: Transaction hash not available in response[/]"
+            content += f"\n[htcli.info]Response keys: {', '.join(response.keys())}[/]"
+        panel = HTCLIPanel(
+            content,
+            title="✅ Operation Successful",
+            border_style="htcli.success",
+            highlight=True,
+        )
+        panel.render()
+
+
+def display_subnet_updates_summary(
+    subnet_id: int,
+    updates: list[tuple[str, dict[str, Any]]],
+    client: Optional[Any] = None,
+):
+    """
+    Display a consolidated summary of multiple subnet updates in a single panel.
+
+    Args:
+        subnet_id: The subnet ID that was updated
+        updates: List of tuples (field_name, result_dict) for each update
+        client: Optional client instance to fetch block numbers from block hashes
+    """
+    if not updates:
+        return
+
+    def format_field_name(field: str) -> str:
+        """Convert snake_case field name to Title Case display name."""
+        return field.replace("_", " ").title()
+
+    def get_transaction_hash(result: Any) -> Optional[str]:
+        """Extract transaction hash from result dict or object."""
+        if isinstance(result, dict):
+            return result.get("transaction_hash") or result.get("extrinsic_hash")
+        return (
+            getattr(result, "transaction_hash", None)
+            or getattr(result, "extrinsic_hash", None)
+        )
+
+    def get_block_hash(result: Any) -> Optional[str]:
+        """Extract block hash from result dict or object."""
+        if isinstance(result, dict):
+            return result.get("block_hash")
+        return getattr(result, "block_hash", None)
+
+    def get_block_number(result: Any) -> Optional[int]:
+        """Extract block number from result dict or object."""
+        if isinstance(result, dict):
+            return result.get("block_number")
+        return getattr(result, "block_number", None)
+
+    # Build content lines
+    content_lines = [f"[htcli.success]✅ Subnet {subnet_id} updated successfully![/htcli.success]\n"]
+
+    # Process each update
+    for field, result in updates:
+        field_display = format_field_name(field)
+        tx_hash = get_transaction_hash(result)
+        block_hash = get_block_hash(result)
+        block_number = get_block_number(result)
+
+        # Try to fetch block number from block hash if missing
+        if not block_number and block_hash and client and client.rpc and client.rpc.chain:
+            try:
+                block_number = client.rpc.chain.get_block_number(block_hash=block_hash)
+            except Exception:
+                pass
+
+        content_lines.append(f"[htcli.value]{field_display}:[/]")
+        if tx_hash:
+            content_lines.append(f"  [htcli.subtitle]Transaction Hash:[/] [htcli.hash]{tx_hash}[/]")
+        if block_number:
+            content_lines.append(f"  [htcli.subtitle]Block Number:[/] [htcli.value]{block_number}[/]")
+        if block_hash:
+            content_lines.append(f"  [htcli.subtitle]Block Hash:[/] [htcli.hash]{block_hash}[/]")
+        content_lines.append("")  # Empty line between updates
+
+    # Remove trailing empty line
+    if content_lines and content_lines[-1] == "":
+        content_lines.pop()
+
+    content = "\n".join(content_lines)
+
+    panel = HTCLIPanel(
+        content,
+        title="✅ Subnet Updates Complete",
+        border_style="htcli.success",
+        highlight=True,
+    )
+    panel.render(console.console)
+
+
+def display_subnet_list_with_coldkey(data: Any, coldkey: str):
+    """Display subnets filtered by coldkey."""
+    if not data:
+        console.print(info(f"No subnets found for coldkey: {coldkey}"))
+        return
+
+    from ...models.responses import SubnetNodeInfo
+    from ...ui.components import create_subnet_table
+
+    # Handle different data types
+    if isinstance(data, list):
+        if data and isinstance(data[0], dict):
+            # Convert dict to SubnetNodeInfo models if needed
+            try:
+                subnet_nodes = [SubnetNodeInfo(**item) for item in data]
+                # Create and display table
+                table = create_subnet_table(subnet_nodes)
+                console.print(table)
+            except Exception:
+                # If conversion fails, display raw data
+                console.print(
+                    info(f"Coldkey {coldkey} subnet nodes info (raw): {data}")
+                )
+        else:
+            # Handle case where data is not a list of dicts (e.g., [0])
+            console.print(
+                info(f"Coldkey {coldkey} has {len(data)} subnet nodes: {data}")
+            )
+    else:
+        console.print(info(f"Coldkey {coldkey} subnet nodes info: {data}"))
+
+
+def display_subnet_info_rpc(subnet_info):
+    """Display subnet information from RPC response with bright, bold colors in a comprehensive table format."""
+    if not subnet_info:
+        console.print(info("No subnet information available"))
+        return
+
+    from ...ui.components import create_subnet_details_tree
+
+    # Create a detailed table view of subnet information (returns Table, not Tree)
+    table = create_subnet_details_tree(subnet_info, [])
+    
+    # If it's a Table, print it directly; if it's a Tree, render it
+    if hasattr(table, 'add_row'):
+        console.print("\n")
+        console.print(table)
+        console.print("\n")
+    else:
+        table.render()
+
+
+def display_subnet_nodes_rpc(nodes_data, subnet_id: Optional[int] = None):
+    """Display subnet nodes from RPC response."""
+    if not nodes_data:
+        if subnet_id is not None:
+            console.print(info(f"No nodes found for subnet {subnet_id}"))
+        else:
+            console.print(info("No nodes found"))
+        return
+
+    from ...ui.components import HTCLITable
+
+    # Sort nodes by node ID in ascending order
+    nodes_data = sorted(nodes_data, key=lambda x: x.get("id", 0))
+
+    # Create table for subnet nodes with footer enabled
+    table = HTCLITable(title="Nodes", show_lines=False, show_footer=True)
+    table.add_column("Node ID", justify="center", style="htcli.value")
+    table.add_column("Coldkey", style="htcli.address")
+    table.add_column("Hotkey", style="htcli.address")
+    table.add_column("Status", justify="center")
+    table.add_column("Own Stake", justify="right", style="htcli.amount")
+    table.add_column("Delegate Stake", justify="right", style="htcli.amount")
+    table.add_column("Total Stake", justify="right", style="bold green")
+
+    # Calculate totals for footer
+    total_nodes = len(nodes_data)
+    total_own_stake = sum(node.get('stake_balance', 0) / 1e18 for node in nodes_data)
+    total_delegate_stake = sum(node.get('node_delegate_stake_balance', 0) / 1e18 for node in nodes_data)
+    total_stake_all = total_own_stake + total_delegate_stake
+
+    for node in nodes_data:
+        own_stake = node.get('stake_balance', 0) / 1e18
+        delegate_stake = node.get('node_delegate_stake_balance', 0) / 1e18
+        total_stake = own_stake + delegate_stake
+
+        # Format addresses with checksum using centralized utility
+        from ...utils.wallet.crypto import format_address_display
+
+        table.add_row(
+            str(node.get("id", "N/A")),
+            format_address_display(node.get("coldkey", "Unknown")),
+            format_address_display(node.get("hotkey", "Unknown")),
+            node.get("status", "Unknown"),
+            f"{own_stake:,.2f} TENSOR",
+            f"{delegate_stake:,.2f} TENSOR",
+            f"{total_stake:,.2f} TENSOR",
+        )
+
+    # Set footer with statistics (similar to subnet list table)
+    footer_values = [
+        f"[bold]{total_nodes}[/bold]",  # Total nodes count
+        "",  # Coldkey column
+        "",  # Hotkey column
+        "",  # Status column
+        f"[bold]{total_own_stake:,.2f} TENSOR[/bold]",  # Total own stake
+        f"[bold]{total_delegate_stake:,.2f} TENSOR[/bold]",  # Total delegate stake
+        f"[bold]{total_stake_all:,.2f} TENSOR[/bold]",  # Total stake
+    ]
+    table.set_column_footers(footer_values)
+
+    table.render()
+
+
+def display_bootnodes_rpc(bootnodes_data, subnet_id: int):
+    """Display bootnodes from RPC response."""
+    if not bootnodes_data:
+        console.print(info(f"No bootnodes found for subnet {subnet_id}"))
+        return
+
+    from ...ui.components import HTCLIPanel
+
+    # Display bootnodes information
+    bootnodes_info = f"""
+[htcli.accent]Subnet {subnet_id} Bootnodes[/htcli.accent]
+
+[htcli.value]Official Bootnodes:[/htcli.value] {len(bootnodes_data.bootnodes)}
+[htcli.value]Node Bootnodes:[/htcli.value] {len(bootnodes_data.node_bootnodes)}
+
+[htcli.accent]Official Bootnodes:[/htcli.accent]
+{chr(10).join(f"• {bootnode}" for bootnode in bootnodes_data.bootnodes) if bootnodes_data.bootnodes else "None"}
+
+[htcli.accent]Node Bootnodes:[/htcli.accent]
+{chr(10).join(f"• {bootnode}" for bootnode in bootnodes_data.node_bootnodes) if bootnodes_data.node_bootnodes else "None"}
+"""
+
+    panel = HTCLIPanel(
+        bootnodes_info,
+        title="🔗 Subnet Bootnodes",
+        border_style="htcli.info",
+        highlight=True,
+    )
+    panel.render()
+
+
+def display_subnet_list_live(data: Any, coldkey: Optional[str] = None):
+    """Display subnets with live updates using Rich Live component."""
+    import time
+
+    from rich.layout import Layout
+    from rich.live import Live
+    from rich.panel import Panel
+    from rich.table import Table
+
+    # Create layout
+    layout = Layout()
+    layout.split_column(Layout(name="header"), Layout(name="content"))
+
+    # Header with coldkey info if provided
+    if coldkey:
+        header_content = f"[bold blue]🔍 Live Subnet Monitor[/bold blue]\n[yellow]Coldkey:[/yellow] {coldkey}"
+    else:
+        header_content = "[bold blue]🔍 Live Subnet Monitor[/bold blue]\n[yellow]All Subnets[/yellow]"
+
+    layout["header"].update(Panel(header_content, border_style="blue"))
+
+    # Create table for subnet data
+    table = Table(title="Subnets", show_header=True, header_style="bold magenta")
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Name", style="green")
+    table.add_column("Owner", style="yellow")
+    table.add_column("Status", style="red")
+    table.add_column("Nodes", style="blue")
+
+    # Add sample data (you can replace this with actual data processing)
+    if isinstance(data, list):
+        for i, subnet in enumerate(data[:10]):  # Limit to 10 for demo
+            if isinstance(subnet, dict):
+                table.add_row(
+                    str(i),
+                    subnet.get("name", "Unknown"),
+                    subnet.get("owner", "Unknown")[:20] + "..."
+                    if len(str(subnet.get("owner", ""))) > 20
+                    else str(subnet.get("owner", "Unknown")),
+                    "Active" if subnet.get("total_active_nodes", 0) > 0 else "Inactive",
+                    str(subnet.get("total_nodes", 0)),
+                )
+            else:
+                # Handle non-dict items (like integers)
+                table.add_row(str(i), str(subnet), "N/A", "Unknown", "N/A")
+    else:
+        table.add_row("N/A", "No data", "N/A", "N/A", "N/A")
+
+    layout["content"].update(table)
+
+    # Use Live display
+    with Live(layout, refresh_per_second=2, screen=True) as live:
+        try:
+            # Simulate live updates
+            for i in range(10):
+                time.sleep(1)
+                # Update table with new data (you can replace this with real data fetching)
+                table.add_row(
+                    str(i + 10),
+                    f"Subnet {i + 10}",
+                    "Owner...",
+                    "Active" if i % 2 == 0 else "Inactive",
+                    str(i + 5),
+                )
+                live.update(layout)
+        except KeyboardInterrupt:
+            pass
+
+
+def display_registration_cost_comparison(cost_tensor: float, wallet_data: list[dict]):
+    """Display subnet registration cost compared with all wallet balances."""
+    import sys
+
+    from ...ui.components import HTCLIPanel, HTCLITable
+
+    # Display registration cost prominently
+    cost_panel_content = f"""[htcli.accent]Current Subnet Registration Cost[/htcli.accent]
+
+[htcli.value]Cost:[/htcli.value] {cost_tensor:,.2f} TENSOR
+[htcli.info]({cost_tensor * 1e18:,.0f} wei)[/htcli.info]
+
+[htcli.info]💡 This cost is dynamic and changes based on network activity.[/htcli.info]
+"""
+
+    cost_panel = HTCLIPanel(
+        cost_panel_content,
+        title="💰 Registration Cost",
+        border_style="htcli.accent",
+        highlight=True,
+    )
+
+    console.print()
+    cost_panel.render()
+    console.print()
+
+    # Create comparison table
+    table = HTCLITable(title="📊 Wallet Balance Comparison")
+    table.add_column("Wallet Name", style="htcli.value", justify="left", width=20)
+    table.add_column("Address", style="htcli.info", justify="left", width=25)
+    table.add_column("Balance (TENSOR)", style="htcli.value", justify="right", width=20)
+    table.add_column("Status", style="htcli.value", justify="center", width=15)
+    table.add_column("Shortfall", style="htcli.error", justify="right", width=20)
+
+    sufficient_count = 0
+    insufficient_count = 0
+
+    for wallet in wallet_data:
+        name = wallet["name"]
+        address = wallet["address"]
+        # Truncate address for display
+        truncated_addr = (
+            f"{address[:8]}...{address[-8:]}" if len(address) > 20 else address
+        )
+        balance = wallet["balance"]
+        sufficient = wallet["sufficient"]
+        shortfall = wallet.get("shortfall", 0)
+        error = wallet.get("error")
+
+        if error:
+            status = "[htcli.error]❌ Error[/htcli.error]"
+            shortfall_str = error
+        elif sufficient:
+            status = "[htcli.success]✅ Sufficient[/htcli.success]"
+            shortfall_str = "-"
+            sufficient_count += 1
+        else:
+            status = "[htcli.error]❌ Insufficient[/htcli.error]"
+            shortfall_str = f"-{shortfall:,.2f}"
+            insufficient_count += 1
+
+        table.add_row(
+            name,
+            truncated_addr,
+            f"{balance:,.4f}",
+            status,
+            shortfall_str,
+        )
+
+    table.render()
+    console.print()
+
+    # Summary panel
+    summary_content = f"""[htcli.accent]Summary[/htcli.accent]
+
+[htcli.value]Total Wallets:[/htcli.value] {len(wallet_data)}
+[htcli.success]✅ Sufficient Balance:[/htcli.success] {sufficient_count}
+[htcli.error]❌ Insufficient Balance:[/htcli.error] {insufficient_count}
+
+"""
+
+    if sufficient_count > 0:
+        summary_content += f"[htcli.success]✅ You can register a subnet with {sufficient_count} wallet(s)![/htcli.success]\n"
+        summary_content += "[htcli.info]Use: htcli subnet register[/htcli.info]"
+    else:
+        summary_content += "[htcli.error]❌ None of your wallets have sufficient balance.[/htcli.error]\n"
+        summary_content += f"[htcli.info]💡 Transfer at least {cost_tensor:,.2f} TENSOR to a wallet[/htcli.info]\n"
+        summary_content += "[htcli.info]Use: htcli wallet transfer[/htcli.info]"
+
+    summary_panel = HTCLIPanel(
+        summary_content,
+        title="📋 Summary",
+        border_style="htcli.info",
+        highlight=True,
+    )
+
+    summary_panel.render()
+    console.print()
+
+    # Ensure output is flushed
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+
+def display_emergency_validator_set_result(
+    result: dict[str, Any], subnet_id: int, node_ids: list[int], action: str = "set"
+):
+    """Display result of emergency validator set operation."""
+    if result.get("success"):
+        action_label = "set" if action == "set" else "cleared"
+        if node_ids:
+            console.print(
+                success(
+                    f"✅ Emergency validator set {action_label} successfully for subnet {subnet_id}!"
+                )
+            )
+            console.print(info(f"Node IDs: {', '.join(map(str, node_ids))}"))
+        else:
+            console.print(
+                success(
+                    f"✅ Emergency validator set cleared successfully for subnet {subnet_id}!"
+                )
+            )
+        display_generic_success(result)
+    else:
+        error_msg = result.get("error", "Operation failed")
+        console.print(error(f"❌ Failed to {action} emergency validator set: {error_msg}"))
+
+
+def display_bootnode_access_result(
+    result: dict[str, Any], subnet_id: int, account: str, action: str = "add"
+):
+    """Display result of bootnode access operation."""
+    if result.get("success"):
+        action_label = "granted" if action == "add" else "revoked"
+        console.print(
+            success(
+                f"✅ Bootnode access {action_label} successfully for subnet {subnet_id}!"
+            )
+        )
+        console.print(info(f"Account: {account}"))
+        display_generic_success(result)
+    else:
+        error_msg = result.get("error", "Operation failed")
+        console.print(error(f"❌ Failed to {action} bootnode access: {error_msg}"))