htcli 1.1.0__py3-none-any.whl

src/htcli/ui/components/tables.py

@@ -0,0 +1,809 @@
+"""
+HTCLI table components.
+Provides enhanced tables for data display.
+"""
+
+from typing import Any, Optional
+
+from rich import box
+from rich.console import Console
+from rich.table import Table
+from src.htcli.utils.wallet.crypto import format_address_display
+
+from ..colors import HTCLIColors
+from ..display import get_console
+
+
+class HTCLITable:
+    """Enhanced table for displaying HTCLI data."""
+
+    def __init__(
+        self,
+        title: str = None,
+        caption: str = None,
+        show_header: bool = True,
+        show_lines: bool = False,
+        show_edge: bool = True,
+        show_footer: bool = False,
+        border_style: str = "htcli.table.border",
+        header_style: str = "htcli.table.header",
+        footer_style: str = "table.footer",
+        row_styles: list[str] = None,
+        box_style=box.HORIZONTALS,
+        expand: bool = True,
+        padding: tuple = (0, 0),
+    ):
+        if row_styles is None:
+            row_styles = ["dim", ""]
+        self.table = Table(
+            title=title,
+            caption=caption,
+            show_header=show_header,
+            show_lines=show_lines,
+            show_edge=show_edge,
+            show_footer=show_footer,
+            border_style=border_style,
+            header_style=header_style,
+            footer_style=footer_style,
+            row_styles=row_styles or ["dim", ""],
+            box=box_style,
+            expand=expand,
+            padding=padding,
+        )
+
+    @classmethod
+    def minimal_header_table(
+        cls,
+        title: str = None,
+        caption: str = None,
+        header_style: str = "bold blue",
+    ):
+        """
+        Create a table with minimal styling - only header underlines and bottom border.
+        No side borders or column separators.
+        """
+        return cls(
+            title=title,
+            caption=caption,
+            show_header=True,
+            show_lines=False,
+            show_edge=False,
+            show_footer=False,
+            border_style="dim",
+            header_style=header_style,
+            box_style=box.HORIZONTALS,
+            expand=True,
+            padding=(1, 1),
+        )
+
+    def add_column(
+        self,
+        header: str,
+        footer: str = "",
+        style: str = None,
+        footer_style: str = None,
+        justify: str = "left",
+        min_width: int = None,
+        max_width: int = None,
+        width: int = None,
+        no_wrap: bool = False,
+    ):
+        """Add a column to the table."""
+        self.table.add_column(
+            header,
+            footer=footer,
+            style=style,
+            footer_style=footer_style,
+            justify=justify,
+            min_width=min_width,
+            max_width=max_width,
+            width=width,
+            no_wrap=no_wrap,
+        )
+
+    def add_row(self, *values):
+        """Add a row to the table."""
+        self.table.add_row(*[str(v) for v in values])
+
+    def add_blockchain_row(self, data: dict[str, Any]):
+        """Add a row with blockchain-specific formatting."""
+        formatted_values = []
+        for key, value in data.items():
+            if key.lower() in ["address", "account", "validator"]:
+                formatted_values.append(f"[htcli.address]{value}[/]")
+            elif key.lower() in ["amount", "balance", "stake"]:
+                formatted_values.append(f"[htcli.amount]{value}[/]")
+            elif key.lower() in ["status", "state"]:
+                color = HTCLIColors.get_status_color(str(value))
+                formatted_values.append(f"[{color}]{value}[/]")
+            elif key.lower() in ["hash", "tx_hash", "block_hash"]:
+                formatted_values.append(f"[htcli.hash]{value}[/]")
+            else:
+                formatted_values.append(str(value))
+        self.table.add_row(*formatted_values)
+
+    def set_column_footers(self, footers: list[str]):
+        """Set footers for all columns."""
+        if len(footers) != len(self.table.columns):
+            raise ValueError(
+                f"Number of footers ({len(footers)}) must match number of columns ({len(self.table.columns)})"
+            )
+
+        for i, footer in enumerate(footers):
+            self.table.columns[i].footer = footer
+
+    def render(self, console: Console = None, with_panel: bool = False):
+        """
+        Render the table wrapped inside a full Layout.
+
+        Args:
+            console (Console, optional): Rich console to print to.
+            with_panel (bool): If True, wraps the table in a Panel to fill vertical space.
+        """
+        console = console or get_console().console
+
+        renderable = self.table
+
+        console.print(renderable)
+
+    def get_renderable(self):
+        """Get the table as a renderable object."""
+        return self.table
+
+
+# Specialized table factory functions
+def create_subnet_table(subnets: list[dict]) -> HTCLITable:
+    """Create a standardized subnet table with bright, bold colors for displaying subnet information."""
+    # Table styling:
+    # - show_edge=False, header_style="bold white", border_style="bright_black"
+    # - style="bold", title_justify="center", show_lines=False, pad_edge=True
+    # Color palette values:
+    # HEADER = "#4196D6" (Light Blue)
+    # SUBHEADING = "#AFEFFF" (Pale Blue)
+    # SUBHEADING_EXTRA_1 = "#96A3C5" (Grayish Blue)
+    # STAKE_ALPHA = "#53B5A0" (Teal)
+    # POOLS.EMISSION = "#F8D384" (Light Orange)
+    
+    # Get network name if available for title display
+    try:
+        from ...dependencies import get_config
+        config = get_config()
+        network_name = getattr(config, 'network', {}).get('endpoint', 'Hypertensor') if config else 'Hypertensor'
+        # Extract network identifier from endpoint if it's a URL
+        if '://' in network_name:
+            network_name = network_name.split('://')[-1].split('.')[0] if '.' in network_name else 'Hypertensor'
+    except:
+        network_name = 'Hypertensor'
+    
+    table = HTCLITable(
+        title=f"\n[#4196D6]Subnets[/#4196D6]"
+              f"\nNetwork: [#AFEFFF]{network_name}[/#AFEFFF]\n\n",
+        header_style="bold white",
+        border_style="bright_black",
+        box_style=box.MINIMAL,
+        show_footer=True,  # Enable footer for totals
+        show_edge=False,
+        show_lines=False,
+        padding=(0, 1),  # Match Rich Table default spacing (vertical, horizontal)
+        row_styles=["", ""],  # No alternating dimness - all rows same brightness
+    )
+
+    # Set table style to bold
+    table.table.style = "bold"
+    # Set title justification to center
+    table.table.title_justify = "center"
+    # Enable pad_edge
+    table.table.pad_edge = True
+
+    # Column styles with bright colors:
+    # Subnetid: centered, grey89 style
+    table.add_column(
+        "[bold white]Subnetid[/bold white]",
+        style="grey89",
+        justify="center",
+    )
+    # Name: left, cyan style
+    table.add_column("[bold white]Name[/bold white]", style="cyan", justify="left")
+    # Owner: left, steel_blue3 style (full address)
+    table.add_column(
+        "[bold white]Coldkey[/bold white]",
+        style="htcli.address",
+        justify="left",
+        no_wrap=True,
+    )
+    # Status: center, using #96A3C5 (Grayish Blue)
+    table.add_column(
+        "[bold white]Status[/bold white]",
+        style="#96A3C5",
+        justify="center",
+    )
+    # Total Nodes: center, using dark_sea_green2
+    table.add_column(
+        "[bold white]Nodes[/bold white]",
+        style="dark_sea_green2",
+        justify="center",
+    )
+    # Active Nodes: center, using #F8D384 (Light Orange)
+    table.add_column(
+        "[bold white]Active[/bold white]",
+        style="#F8D384",
+        justify="center",
+    )
+    # Min Stake: right, using #53B5A0 (Teal)
+    table.add_column(
+        "[bold white]Min Stake[/bold white]",
+        style="#53B5A0",
+        justify="right",
+    )
+    # Max Stake: right, using steel_blue3
+    table.add_column(
+        "[bold white]Max Stake[/bold white]",
+        style="steel_blue3",
+        justify="right",
+    )
+    # Delegate Stake: right, using #F8D384 (Light Orange) - shows total delegated stake
+    table.add_column(
+        "[bold white]Del. Stake[/bold white]",
+        style="#F8D384",
+        justify="right",
+    )
+    # Stake: left, using #53B5A0 (Teal)
+    table.add_column(
+        "[bold white]Stake[/bold white]",
+        style="#53B5A0",
+        justify="left",
+    )
+
+    def get_subnet_field(subnet, field_name, default=None):
+        """Get field from subnet whether it's a dict or Pydantic model."""
+        if isinstance(subnet, dict):
+            return subnet.get(field_name, default)
+        elif hasattr(subnet, field_name):
+            return getattr(subnet, field_name, default)
+        elif hasattr(subnet, "model_dump"):
+            # Pydantic model - convert to dict first
+            subnet_dict = subnet.model_dump()
+            return subnet_dict.get(field_name, default)
+        return default
+
+    # Initialize totals for footer
+    total_subnets = len(subnets)
+    total_nodes = 0
+    total_active_nodes = 0
+    total_min_stake = 0
+    total_max_stake = 0
+    total_delegate_stake = 0
+    total_stake = 0
+
+    for subnet in subnets:
+        # Convert to dict if it's a Pydantic model
+        if hasattr(subnet, "model_dump") and not isinstance(subnet, dict):
+            subnet_dict = subnet.model_dump()
+        else:
+            subnet_dict = subnet if isinstance(subnet, dict) else {}
+
+        # Get the actual state from blockchain (Registered, Active, Paused)
+        state = get_subnet_field(subnet, "state", "Unknown")
+        if state is None:
+            state = "Unknown"
+        
+        # Format state with color based on actual state
+        if state == "Active" or state == "active":
+            status_display = "[bold green]Active[/]"
+        elif state == "Registered" or state == "registered":
+            status_display = "[bold yellow]Registered[/]"
+        elif state == "Paused" or state == "paused":
+            status_display = "[bold red]Paused[/]"
+        else:
+            # Handle lowercase or other variations
+            state_lower = str(state).lower()
+            if "active" in state_lower:
+                status_display = "[bold green]Active[/]"
+            elif "registered" in state_lower:
+                status_display = "[bold yellow]Registered[/]"
+            elif "paused" in state_lower:
+                status_display = "[bold red]Paused[/]"
+            else:
+                status_display = f"[dim]{state}[/]"
+
+        subnet_id = str(get_subnet_field(subnet, "id", "N/A"))
+
+        # Format friendly ID
+        friendly_id = get_subnet_field(subnet, "friendly_id")
+        friendly_id_display = str(friendly_id) if friendly_id is not None else "—"
+
+        # Format name - handle bytes/str
+        subnet_name = get_subnet_field(subnet, "name", "Unknown")
+        if isinstance(subnet_name, bytes):
+            try:
+                subnet_name = subnet_name.decode("utf-8")
+            except:
+                subnet_name = subnet_name.hex()[:20] + "..."
+        elif not isinstance(subnet_name, str):
+            subnet_name = str(subnet_name) if subnet_name else "Unknown"
+
+        # Format owner address - show full address
+        owner = get_subnet_field(subnet, "owner")
+        if owner and owner != "N/A" and owner is not None:
+            owner_str = str(owner)
+            owner_display = f"[htcli.address]{format_address_display(owner_str)}[/htcli.address]"
+        else:
+            owner_display = "[dim]N/A[/dim]"
+
+        # Format node counts
+        subnet_total_nodes = get_subnet_field(subnet, "total_nodes", 0) or 0
+        subnet_total_active = get_subnet_field(subnet, "total_active_nodes", 0) or 0
+        total_electable = get_subnet_field(subnet, "total_electable_nodes", 0) or 0
+
+        # Accumulate totals for footer
+        total_nodes += subnet_total_nodes
+        total_active_nodes += subnet_total_active
+
+        # Format stake values (convert from raw to TENSOR for display)
+        def format_stake(value, default=0):
+            """Format stake value in TENSOR units."""
+            if value is None:
+                return "0"
+            # Convert from raw (smallest unit) to TENSOR
+            tensor_value = value / 1e18 if value > 0 else 0
+            if tensor_value == 0:
+                return "0"
+            if tensor_value < 0.01:
+                return f"{tensor_value:.6f}"
+            if tensor_value < 1000:
+                return f"{tensor_value:.2f}"
+            return f"{tensor_value:,.0f}"
+
+        def get_stake_value(subnet, field_name, default=0):
+            """Get raw stake value in wei for calculations."""
+            value = get_subnet_field(subnet, field_name, default) or 0
+            return value if isinstance(value, (int, float)) else 0
+
+        # Get raw stake values for totals
+        subnet_min_stake_raw = get_stake_value(subnet, "min_stake", 0)
+        subnet_max_stake_raw = get_stake_value(subnet, "max_stake", 0)
+        # Prefer new field name from updated SubnetInfo, fall back to legacy key if present
+        subnet_total_stake_raw = get_stake_value(subnet, "total_subnet_stake", 0)
+        if subnet_total_stake_raw == 0:
+            subnet_total_stake_raw = get_stake_value(subnet, "total_stake", 0)
+        # Delegate stake (total delegated stake balance on subnet)
+        subnet_delegate_stake_raw = get_stake_value(subnet, "total_subnet_delegate_stake_balance", 0)
+
+        # Accumulate stake totals
+        total_min_stake += subnet_min_stake_raw
+        total_max_stake += subnet_max_stake_raw
+        total_delegate_stake += subnet_delegate_stake_raw
+        total_stake += subnet_total_stake_raw
+
+        # Format for display
+        min_stake = format_stake(subnet_min_stake_raw)
+        max_stake = format_stake(subnet_max_stake_raw)
+        delegate_stake = format_stake(subnet_delegate_stake_raw)
+        subnet_total_stake_formatted = format_stake(subnet_total_stake_raw)
+
+        # Format subnet name with cyan color
+        subnet_name_display = f"[cyan]{subnet_name}[/cyan]"
+        
+        # Format stake values with TENSOR suffix if > 0
+        min_stake_display = f"{min_stake}" if min_stake != "0" else "0"
+        max_stake_display = f"{max_stake}" if max_stake != "0" else "0"
+        delegate_stake_display = f"{delegate_stake}" if delegate_stake != "0" else "0"
+        total_stake_display = f"{subnet_total_stake_formatted}" if subnet_total_stake_formatted != "0" else "0"
+        
+        table.add_row(
+            subnet_id,
+            subnet_name_display,
+            owner_display,
+            status_display,
+            str(subnet_total_nodes),
+            str(subnet_total_active),
+            min_stake_display,
+            max_stake_display,
+            delegate_stake_display,
+            total_stake_display,
+        )
+
+    # Format totals for footer display
+    def format_total_stake(value):
+        """Format total stake value in TENSOR units for footer."""
+        if value is None or value == 0:
+            return "0"
+        # Convert from raw (smallest unit) to TENSOR
+        tensor_value = value / 1e18 if value > 0 else 0
+        if tensor_value == 0:
+            return "0"
+        if tensor_value < 0.01:
+            return f"{tensor_value:.6f}"
+        if tensor_value < 1000:
+            return f"{tensor_value:,.2f}"
+        return f"{tensor_value:,.0f}"
+
+    # Set footer with totals
+    footer_values = [
+        f"[bold]{total_subnets}[/bold]",  # Total number of subnets
+        "",  # Name column
+        "",  # Owner column
+        "",  # Status column
+        f"[bold]{total_nodes}[/bold]",  # Total nodes
+        f"[bold]{total_active_nodes}[/bold]",  # Total active nodes
+        f"[bold]{format_total_stake(total_min_stake)}[/bold]",  # Total min stake
+        f"[bold]{format_total_stake(total_max_stake)}[/bold]",  # Total max stake
+        f"[bold]{format_total_stake(total_delegate_stake)}[/bold]",  # Total delegate stake
+        f"[bold]{format_total_stake(total_stake)}[/bold]",  # Total stake
+    ]
+    table.set_column_footers(footer_values)
+
+    return table
+
+
+def create_node_table(nodes: list) -> HTCLITable:
+    """Create a standardized node table for displaying all nodes."""
+    table = HTCLITable(
+        title="🔗 Network Nodes",
+        header_style="bold cyan",
+        border_style="cyan",
+    )
+    table.add_column("Subnet", style="bold", width=8)
+    table.add_column("Node ID", style="bold blue", width=8)
+    table.add_column("Coldkey", style="htcli.address", min_width=25, max_width=42)
+    table.add_column("Hotkey", style="htcli.address", min_width=25, max_width=42)
+    table.add_column("Status", style="bold", justify="center", width=14)
+    table.add_column("Stake", style="green", justify="right", width=15)
+    table.add_column("Penalties", style="yellow", justify="center", width=10)
+
+    for node in nodes:
+        # Handle both dict and object formats
+        if hasattr(node, 'subnet_id'):
+            subnet_id = str(node.subnet_id)
+            node_id = str(node.subnet_node_id)
+            coldkey = node.coldkey[:10] + "..." if len(node.coldkey) > 13 else node.coldkey
+            hotkey = node.hotkey[:10] + "..." if len(node.hotkey) > 13 else node.hotkey
+            stake_balance = node.stake_balance / 1e18  # Convert from wei
+            penalties = str(node.penalties)
+
+            # Get classification status
+            classification = node.classification
+            if isinstance(classification, dict):
+                node_class = classification.get('node_class', 'Unknown')
+            else:
+                node_class = 'Unknown'
+        else:
+            subnet_id = str(node.get("subnet_id", "N/A"))
+            node_id = str(node.get("subnet_node_id", "N/A"))
+            coldkey_full = node.get("coldkey", "N/A")
+            coldkey = coldkey_full[:10] + "..." if len(coldkey_full) > 13 else coldkey_full
+            hotkey_full = node.get("hotkey", "N/A")
+            hotkey = hotkey_full[:10] + "..." if len(hotkey_full) > 13 else hotkey_full
+            stake_balance = node.get("stake_balance", 0) / 1e18
+            penalties = str(node.get("penalties", 0))
+
+            classification = node.get("classification", {})
+            node_class = classification.get('node_class', 'Unknown') if isinstance(classification, dict) else 'Unknown'
+
+        # Format status with color
+        if node_class == 'Active':
+            status_display = "[bold green]✓ Active[/]"
+        elif node_class == 'Deactivated':
+            status_display = "[yellow]⚠ Deactivated[/]"
+        elif node_class == 'Included':
+            status_display = "[cyan]◉ Included[/]"
+        elif node_class == 'Queue':
+            status_display = "[blue]⋯ Queued[/]"
+        else:
+            status_display = f"[dim]{node_class}[/]"
+
+        table.add_row(
+            subnet_id,
+            node_id,
+            coldkey,
+            hotkey,
+            status_display,
+            status_display,
+            f"{stake_balance:,.4f}",
+            penalties,
+            penalties,
+        )
+
+    return table
+
+
+def create_wallet_table(wallets: list[dict]) -> HTCLITable:
+    """Create a standardized wallet table."""
+    table = HTCLITable(
+        title="💰 Wallets",
+        header_style="bold green",
+        border_style="green",
+    )
+    table.add_column("Name", style="bold blue", min_width=15)
+    table.add_column("Type", style="bold", width=8)
+    table.add_column("Address", style="htcli.address", min_width=20)
+    table.add_column("Key Type", style="dim", width=8)
+    table.add_column("Balance", style="green", justify="right", width=12)
+
+    for wallet in wallets:
+        table.add_row(
+            wallet.get("name", "Unknown"),
+            wallet.get("wallet_type", "Unknown"),
+            wallet.get("address", "N/A"),
+            wallet.get("key_type", "Unknown"),
+            f"{wallet.get('balance', 0):,}",
+        )
+
+    return table
+
+
+def create_balance_table(balances: list[dict], total_balance: float = 0) -> HTCLITable:
+    """Create a balance table for wallet balances with footer showing total."""
+    table = HTCLITable(
+        title="💰 Balance Information",
+        header_style="bold green",
+        border_style="green",
+        show_footer=True,
+    )
+    table.add_column("Wallet", style="bold blue", min_width=15)
+    table.add_column("Address", style="htcli.address", min_width=20)
+    table.add_column("Balance", style="green", justify="right", width=12)
+    table.add_column("Status", style="bold", justify="center", width=8)
+
+    # Track total for footer
+    total_balance_tensor = 0
+
+    for balance in balances:
+        balance_amount = balance.get("balance_tensor", balance.get("balance", 0))
+
+        # Handle both string and numeric values
+        if isinstance(balance_amount, str):
+            balance_display = balance_amount
+        elif isinstance(balance_amount, (int, float)) and balance_amount > 0:
+            # Convert from wei to TENSOR
+            balance_tensor = balance_amount / 1e18
+            balance_display = f"{balance_tensor:,.2f}"
+            total_balance_tensor += balance_tensor
+        else:
+            balance_display = "0.00"
+
+        table.add_row(
+            balance.get("name", "Unknown"),
+            balance.get("address", "N/A"),
+            balance_display,
+            balance.get("status", "Active"),
+        )
+
+    # Add footer row with total balance
+    footer = [
+        "",
+        "",
+        "[bold]Total[/bold]",
+        f"[bold]{total_balance_tensor:,.2f}[/bold]",
+        "",
+    ]
+    table.set_column_footers(footer)
+
+    return table
+
+
+def create_htcli_balance_table(
+    balances: list[dict],
+    totals: dict,
+    network_name: Optional[str] = None,
+    show_totals: bool = True,
+) -> Table:
+    """Create an HTCLI balance table with staking breakdown and totals footer."""
+    from ...utils.wallet.crypto import format_address_display
+
+    title_lines = ["Wallet Coldkey Balance"]
+    if network_name:
+        title_lines.append(f"Network: {network_name}")
+    title_lines.append("[dim]All values in TENSOR[/dim]")
+    title = "\n".join(
+        [
+            f"[{HTCLIColors.PRIMARY}]{line}[/{HTCLIColors.PRIMARY}]"
+            if "dim" not in line else line
+            for line in title_lines
+        ]
+    )
+
+    table = Table(
+        title=f"\n{title}\n",
+        show_footer=show_totals,
+        show_edge=False,
+        border_style=HTCLIColors.GRAY_500,
+        box=box.SIMPLE_HEAVY,
+        pad_edge=False,
+        expand=True,
+    )
+
+    table.add_column(
+        "[white]Wallet Name", style=HTCLIColors.PRIMARY_LIGHT, no_wrap=True
+    )
+    table.add_column(
+        "[white]Coldkey Address", style="htcli.address", no_wrap=True
+    )
+    table.add_column(
+        "[white]Free Balance",
+        justify="right",
+        style=HTCLIColors.BALANCE,
+        no_wrap=True,
+    )
+    table.add_column(
+        "[white]Direct Stake",
+        justify="right",
+        style="#53B5A0",  # Teal for direct stake
+        no_wrap=True,
+    )
+    table.add_column(
+        "[white]Delegate",
+        justify="right",
+        style=HTCLIColors.STAKING_ORANGE,
+        no_wrap=True,
+    )
+    table.add_column(
+        "[white]Node Del.",
+        justify="right",
+        style="#96A3C5",  # Grayish blue for node delegate
+        no_wrap=True,
+    )
+    table.add_column(
+        "[white]Overwatch",
+        justify="right",
+        style="#E066FF",  # Purple for overwatch stake
+        no_wrap=True,
+    )
+    table.add_column(
+        "[white]Unbonding",
+        justify="right",
+        style="#FF6B6B",  # Coral/Red for unbonding (in waiting period)
+        no_wrap=True,
+    )
+    table.add_column(
+        "[white]Total Balance",
+        justify="right",
+        style=HTCLIColors.CRYPTO_GOLD,
+        no_wrap=True,
+    )
+
+    def _format_tensor(value: Optional[int], precision: int = 2) -> str:
+        if value is None:
+            return "--"
+        try:
+            tensor_value = value / 1e18
+        except TypeError:
+            return str(value)
+        return f"{tensor_value:,.{precision}f}"
+
+    for row in balances:
+        address = row.get("address") or "N/A"
+        address_display = format_address_display(address) if address else "N/A"
+
+        free_display = row.get("display_free") or _format_tensor(
+            row.get("free_balance", 0)
+        )
+        direct_display = _format_tensor(row.get("direct_stake", 0))
+        delegate_display = _format_tensor(row.get("delegate_stake", 0))
+        node_delegate_display = _format_tensor(row.get("node_delegate_stake", 0))
+        overwatch_display = _format_tensor(row.get("overwatch_stake", 0))
+        unbonding_display = _format_tensor(row.get("unbonding", 0))
+        total_value = row.get("total_balance")
+        if total_value is None:
+            total_value = (row.get("free_balance", 0) or 0) + (
+                row.get("staked_balance", 0) or 0
+            )
+        total_display = row.get("display_total") or _format_tensor(total_value)
+
+        table.add_row(
+            row.get("name", "Unknown"),
+            address_display,
+            free_display,
+            direct_display,
+            delegate_display,
+            node_delegate_display,
+            overwatch_display,
+            unbonding_display,
+            total_display,
+        )
+
+    if show_totals and totals:
+        wallet_count = len(balances)
+        footers = [
+            f"[bold white]{wallet_count} wallet{'s' if wallet_count != 1 else ''}[/bold white]",
+            "",
+            f"[bold]{_format_tensor(totals.get('free'))}[/bold]",
+            f"[bold]{_format_tensor(totals.get('direct_stake'))}[/bold]",
+            f"[bold]{_format_tensor(totals.get('delegate_stake'))}[/bold]",
+            f"[bold]{_format_tensor(totals.get('node_delegate_stake'))}[/bold]",
+            f"[bold]{_format_tensor(totals.get('overwatch_stake'))}[/bold]",
+            f"[bold]{_format_tensor(totals.get('unbonding'))}[/bold]",
+            f"[bold]{_format_tensor(totals.get('total'))}[/bold]",
+        ]
+        for column, footer in zip(table.columns, footers):
+            column.footer = footer
+
+    return table
+
+
+def create_wallet_minimal_table(wallets: list[dict[str, Any]]) -> HTCLITable:
+    """
+    Create a wallet table with the same structure as display_keys_table but using HTCLITable.
+    """
+    from ...utils.wallet.crypto import format_address_display
+
+    table = HTCLITable(
+        title="Stored Wallets",
+        header_style="htcli.table.header",
+        border_style="htcli.table.border",
+        row_styles=["", "dim"],
+        box_style=box.SIMPLE_HEAD,
+        show_edge=False,
+        padding=(0, 1),
+    )
+
+    table.add_column("Wallet", style="bold white", min_width=18, no_wrap=True)
+    table.add_column("Type", style="htcli.secondary", justify="center", width=10)
+    table.add_column("Address", style="htcli.address", min_width=24)
+    table.add_column("Owner / Coldkey", style="htcli.address", min_width=24)
+    table.add_column("Key Type", style="htcli.value", justify="center", width=10)
+    table.add_column("Encryption", style="htcli.value", justify="center", width=12)
+
+    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)]
+
+    address_to_name = {
+        key.get("ss58_address"): key.get("name", "Unknown") for key in coldkeys
+    }
+
+    def _build_row(key_info: dict, is_hotkey: bool):
+        name = key_info.get("name", "Unknown")
+        icon = "🔥" if is_hotkey else "❄️"
+        wallet_label = f"{icon} {name}"
+
+        wallet_type = (
+            "[htcli.secondary]HOTKEY[/htcli.secondary]"
+            if is_hotkey
+            else "[htcli.success]COLDKEY[/htcli.success]"
+        )
+
+        address = key_info.get("ss58_address") or key_info.get("address") or "N/A"
+        formatted_address = format_address_display(address, max_length=36)
+
+        if is_hotkey:
+            owner_address = key_info.get("owner_address")
+            if owner_address and owner_address in address_to_name:
+                owner_display = (
+                    f"{format_address_display(owner_address, max_length=34)} "
+                    f"({address_to_name[owner_address]})"
+                )
+            else:
+                owner_display = (
+                    format_address_display(owner_address or "N/A", max_length=34)
+                )
+        else:
+            owner_display = formatted_address if formatted_address != "N/A" else "—"
+
+        encrypted_status = (
+            "[green]🔒 Encrypted[/green]"
+            if key_info.get("is_encrypted", True)
+            else "[yellow]Plain[/yellow]"
+        )
+
+        key_type = key_info.get("key_type", "—")
+        key_type_display = key_type.upper() if isinstance(key_type, str) else str(key_type)
+
+        table.add_row(
+            wallet_label,
+            wallet_type,
+            formatted_address,
+            owner_display,
+            key_type_display,
+            encrypted_status,
+        )
+
+    for key in coldkeys:
+        _build_row(key, is_hotkey=False)
+
+    if coldkeys and hotkeys:
+        table.table.add_section()
+
+    for key in hotkeys:
+        _build_row(key, is_hotkey=True)
+
+    return table