htcli 1.1.0__py3-none-any.whl

src/htcli/commands/wallet/display.py

@@ -0,0 +1,806 @@
+"""
+Wallet command display logic.
+
+Handles formatting and displaying results for wallet operations using HTCLI UI components.
+"""
+
+from typing import Optional
+
+from rich.padding import Padding
+
+from ...models.responses import (
+    WalletCreateResponse,
+    WalletDeleteResponse,
+    WalletListResponse,
+    WalletStatusResponse,
+    WalletTransferResponse,
+    WalletUpdateResponse,
+)
+from ...ui.colors import address, address_full, error, info, primary, success, warning
+from ...ui.components import (
+    HTCLIPanel,
+    HTCLITable,
+    create_htcli_balance_table,
+    create_wallet_hierarchy_tree,
+    create_wallet_minimal_table,
+)
+from ...ui.display import (
+    HTCLIConsole,
+    print_error,
+    print_info,
+    print_success,
+    print_warning,
+)
+from ...ui.prompts import confirm_prompt
+
+console = HTCLIConsole()
+
+
+def _copy_to_clipboard(text: str):
+    """Copy text to clipboard if pyperclip is installed."""
+    try:
+        import pyperclip
+
+        pyperclip.copy(text)
+        print_success("📋 Copied to clipboard!", emoji=False)
+    except ImportError:
+        print_warning("📋 Could not copy to clipboard.", emoji=False)
+        print_info(
+            "Install pyperclip for automatic copying: pip install pyperclip",
+            emoji=False,
+        )
+        console.print("Please copy the phrase manually.")
+
+
+def display_wallet_creation_result(
+    response: WalletCreateResponse,
+    copy_mnemonic: bool = False,
+    owner_name: Optional[str] = None,
+    owner_address: Optional[str] = None,
+    preseeded_name: Optional[str] = None,
+):
+    """Display wallet creation results."""
+    print_success("Wallet created successfully!")
+
+    # Display key details in a table
+    table = HTCLITable(title="Wallet Details")
+    table.add_column("Property", style="white")
+    table.add_column("Value", style="dim")
+    table.add_row("Name", response.name)
+    table.add_row("Type", response.wallet_type.title())
+    table.add_row("Key Type", response.key_type.upper())
+    table.add_row("Address", address(response.address))
+    table.add_row("Public Key", response.public_key)
+    if owner_name and owner_address:
+        table.add_row("Owner", f"{owner_name} ({address(owner_address)})")
+    if preseeded_name:
+        table.add_row("Preseeded From", preseeded_name.title())
+    table.add_row("Encryption", "🔒 Enabled" if response.encrypted else "Disabled")
+    console.print(table.table)
+
+    # Mnemonic display in a panel
+    if response.mnemonic:
+        # Display mnemonic with separate subtitle
+        display_mnemonic_with_copy_option(
+            response.mnemonic,
+            response.name,
+            response.wallet_type.title(),
+            copy_mnemonic=copy_mnemonic,
+        )
+
+
+def display_mnemonic_panel(
+    mnemonic: str, wallet_name: str, wallet_type: str = "Coldkey"
+):
+    """Display mnemonic in a beautiful panel."""
+    words = mnemonic.split()
+
+    # Create a table for evenly spaced words
+    mnemonic_table = HTCLITable(
+        show_header=False,
+        show_lines=False,
+        show_edge=False,
+        border_style="red",
+        padding=(0, 1),
+    )
+
+    # Add columns for 4 words per row
+    for _ in range(4):
+        mnemonic_table.add_column("", justify="center", width=20)
+
+    # Add rows of 4 words each
+    for i in range(0, 12, 4):
+        row_words = []
+        for j in range(4):
+            if i + j < len(words):
+                word_num = i + j + 1
+                row_words.append(f"{word_num:2d}. {words[i + j]}")
+            else:
+                row_words.append("")
+        mnemonic_table.add_row(*row_words)
+
+    panel = HTCLIPanel(
+        mnemonic_table.table,
+        title=f"[bold red]🔐 {wallet_type} Recovery Phrase[/bold red]",
+        border_style="red",
+        padding=(1, 2),
+        highlight=True,
+    )
+    console.print(panel.panel)
+
+
+def display_mnemonic_with_copy_option(
+    mnemonic: str,
+    wallet_name: str,
+    wallet_type: str = "Coldkey",
+    copy_mnemonic: bool = False,
+):
+    """Display mnemonic and offer clipboard copy option.
+
+    Args:
+        mnemonic: The recovery phrase to display
+        wallet_name: Name of the wallet
+        wallet_type: Type of wallet (Coldkey/Hotkey)
+        copy_mnemonic: If True, automatically copy to clipboard without prompting
+    """
+    # Display the mnemonic in a beautiful panel only
+    display_mnemonic_panel(mnemonic, wallet_name, wallet_type)
+
+    # Display subtitle separately
+    console.print(
+        "[bold yellow]Store this securely. It is the only way to recover your wallet.[/bold yellow]"
+    )
+    console.print()
+
+    # Handle clipboard copy
+    if copy_mnemonic:
+        # Automatically copy if flag is set
+        _copy_to_clipboard(mnemonic)
+    else:
+        # Offer clipboard copy only if flag is not set
+        if confirm_prompt("Copy recovery phrase to clipboard?", default=False):
+            _copy_to_clipboard(mnemonic)
+
+    # Final security reminder
+    console.print("\n[bold red]🔒 Security Reminder:[/bold red]")
+    console.print("• Store this recovery phrase in a secure, offline location")
+    console.print("• Never share it with anyone")
+    console.print("• Consider using a hardware wallet for additional security")
+    console.print("• Test your recovery process in a safe environment")
+    console.print()
+
+
+def display_wallet_generation_result(
+    coldkey_response: WalletCreateResponse,
+    hotkey_response: WalletCreateResponse,
+    copy_mnemonic: bool = False,
+):
+    """Display unified results for wallet generation (both coldkey and hotkey)."""
+    console.print()
+    print_success("Wallet created successfully!")
+    console.print(primary("Both coldkey and hotkey have been generated.\n"))
+
+    # Create a unified summary table
+    summary_table = HTCLITable(title="Wallet Summary")
+    summary_table.add_column("Property", style="bold white")
+    summary_table.add_column("Coldkey", style="cyan")
+    summary_table.add_column("Hotkey", style="yellow")
+
+    summary_table.add_row("Name", coldkey_response.name, hotkey_response.name)
+    summary_table.add_row(
+        "Address", address(coldkey_response.address), address(hotkey_response.address)
+    )
+    summary_table.add_row(
+        "Key Type", coldkey_response.key_type.upper(), hotkey_response.key_type.upper()
+    )
+    summary_table.add_row(
+        "Encryption",
+        "🔒 Enabled" if coldkey_response.encrypted else "Disabled",
+        "🔒 Enabled" if hotkey_response.encrypted else "Disabled",
+    )
+    summary_table.add_row(
+        "Owner", "—", f"{coldkey_response.name} ({address(coldkey_response.address)})"
+    )
+
+    console.print(summary_table.table)
+    console.print()
+
+    # Display both mnemonics in a unified format
+    console.print("[bold red]🔐 Recovery Phrases[/bold red]\n")
+    console.print(
+        "[bold yellow]⚠️  CRITICAL: Store these phrases securely. They are the only way to recover your wallets.[/bold yellow]\n"
+    )
+
+    # Coldkey mnemonic
+    console.print("[bold cyan]📘 Coldkey Recovery Phrase:[/bold cyan]")
+    display_mnemonic_panel(coldkey_response.mnemonic, coldkey_response.name, "Coldkey")
+    console.print()
+
+    # Hotkey mnemonic
+    console.print("[bold yellow]📗 Hotkey Recovery Phrase:[/bold yellow]")
+    display_mnemonic_panel(hotkey_response.mnemonic, hotkey_response.name, "Hotkey")
+    console.print()
+
+    # Handle clipboard copy
+    if copy_mnemonic:
+        # Copy both mnemonics (coldkey first, then hotkey)
+        combined = (
+            f"Coldkey: {coldkey_response.mnemonic}\nHotkey: {hotkey_response.mnemonic}"
+        )
+        _copy_to_clipboard(combined)
+    else:
+        # Offer to copy each mnemonic separately
+        if confirm_prompt("Copy coldkey recovery phrase to clipboard?", default=False):
+            _copy_to_clipboard(coldkey_response.mnemonic)
+        if confirm_prompt("Copy hotkey recovery phrase to clipboard?", default=False):
+            _copy_to_clipboard(hotkey_response.mnemonic)
+
+    # Final security reminder
+    console.print("\n[bold red]🔒 Security Reminder:[/bold red]")
+    console.print("• Store both recovery phrases in a secure, offline location")
+    console.print("• Never share them with anyone")
+    console.print("• Consider using a hardware wallet for additional security")
+    console.print("• Test your recovery process in a safe environment")
+    console.print("• Keep coldkey and hotkey phrases separate and clearly labeled")
+    console.print()
+
+
+def display_wallet_restoration_result(
+    response: WalletCreateResponse,
+    import_method: str,
+    owner_name: Optional[str] = None,
+    owner_address: Optional[str] = None,
+):
+    """Display wallet restoration results."""
+    print_success(f"Wallet restored successfully from {import_method}!")
+    console.print()
+
+    # Display key details in a table
+    table = HTCLITable(title="Restored Wallet Details")
+    table.add_column("Property", style="bold #5EE7FF")
+    table.add_column("Value", style="#CBD5E0")
+    table.add_row("Name", response.name)
+    table.add_row("Type", response.wallet_type.title())
+    table.add_row("Key Type", response.key_type.upper())
+    table.add_row("Address", address(response.address))
+    table.add_row("Public Key", response.public_key)
+    if owner_name and owner_address:
+        table.add_row("Owner", f"{owner_name} ({address(owner_address)})")
+    table.add_row("Encryption", "🔒 Enabled" if response.encrypted else "Disabled")
+    table.render()
+
+
+def display_wallet_list(response: WalletListResponse, format_type: str = "tree"):
+    """Display wallet list using existing patterns."""
+    if not response.wallets:
+        # Show friendly panel when no wallets exist
+        content = """[htcli.info]📭 No wallets found in your wallet directory.[/htcli.info]
+
+[htcli.subtitle]💡 To create your first wallet, use one of these commands:[/htcli.subtitle]
+
+[htcli.value]• Generate a new coldkey:[/htcli.value]
+  [bold cyan]htcli wallet generate-coldkey --name <wallet-name>[/bold cyan]
+
+[htcli.value]• Generate a new hotkey:[/htcli.value]
+  [bold cyan]htcli wallet generate-hotkey --name <hotkey-name> --owner <coldkey-name>[/bold cyan]
+
+[htcli.value]• Restore from mnemonic:[/htcli.value]
+  [bold cyan]htcli wallet restore-coldkey --name <wallet-name>[/bold cyan]
+
+[htcli.info]For more information, run: [bold]htcli wallet --help[/bold][/htcli.info]"""
+
+        panel = HTCLIPanel(
+            content,
+            title="💼 No Wallets Found",
+            border_style="htcli.info",
+            highlight=True,
+        )
+        panel.render(console.console)
+        console.print()
+        return
+
+    if format_type == "json":
+        console.print_json(data=response.wallets)
+    elif format_type == "table":
+        table = create_wallet_minimal_table(response.wallets)
+        console.print(table.table)
+        # Show summary
+        console.print(
+            f"\n[bold]Summary:[/bold] {response.coldkeys} coldkeys, {response.hotkeys} hotkeys"
+        )
+    else:  # tree format
+        _ = create_wallet_hierarchy_tree(response.wallets)
+
+
+def display_wallet_status(response: WalletStatusResponse, format_type: str = "table"):
+    """Display wallet status using existing patterns."""
+    if not response.wallets:
+        print_warning("No wallets found.")
+        print_info("Create a wallet with: htcli wallet generate-coldkey")
+        return
+
+    console.print(primary("🔐 Your Blockchain Identity"))
+    console.print(f"   Total Keys: {response.total_keys}")
+    console.print(f"   Total Addresses: {response.total_addresses}")
+    console.print()
+
+    if format_type == "json":
+        console.print_json(data=response.wallets)
+    else:
+        table = create_wallet_minimal_table(response.wallets)
+        table.render()
+        # Show summary
+        console.print(
+            f"\n[bold]Summary:[/bold] {response.total_keys} keys, {response.total_addresses} addresses"
+        )
+
+
+def display_balance_info(address: str, balance: float = 0):
+    """Display helpful information when balance is 0."""
+    if balance == 0:
+        console.print(
+            "\n[bold yellow]💡 Note:[/bold yellow] This wallet has no balance."
+        )
+        console.print(f"• To receive funds, share this address: [bold]{address}[/bold]")
+        console.print(
+            "• You can transfer funds from another wallet using: [bold]htcli wallet transfer[/bold]"
+        )
+        console.print("• Transaction fees are typically around 0.001-0.01 TENSOR")
+
+
+def display_all_wallet_balances(
+    wallet_balances: list[dict],
+    totals: dict,
+    format_type: str,
+    network_name: Optional[str] = None,
+):
+    """Display balance for all wallets using the new standardized table."""
+    if not wallet_balances:
+        print_warning("No wallets found or balances retrieved.")
+        return
+
+    if format_type == "json":
+        json_data = {
+            "wallets": [
+                {
+                    "name": wb.get("name"),
+                    "address": wb.get("address"),
+                    "free_balance": wb.get("free_balance", 0),
+                    "direct_stake": wb.get("direct_stake", 0),
+                    "delegate_stake": wb.get("delegate_stake", 0),
+                    "node_delegate_stake": wb.get("node_delegate_stake", 0),
+                    "overwatch_stake": wb.get("overwatch_stake", 0),
+                    "unbonding": wb.get("unbonding", 0),
+                    "staked_balance": wb.get("staked_balance", 0),
+                    "total_balance": wb.get("total_balance", 0),
+                }
+                for wb in wallet_balances
+            ],
+            "totals": totals,
+            "network": network_name,
+        }
+        console.print_json(data=json_data)
+    else:
+        table = create_htcli_balance_table(
+            wallet_balances, totals, network_name=network_name, show_totals=True
+        )
+        console.print(Padding(table, (0, 0, 1, 0)))
+
+
+def display_single_wallet_balance(
+    response,
+    wallet_name: Optional[str],
+    wallet_type: str,
+    format_type: str,
+    show_guidance: bool,
+    staking_balance: int = 0,
+    staking_breakdown: Optional[dict] = None,
+    network_name: Optional[str] = None,
+):
+    """Display the balance for a single wallet or address using the new standardized table."""
+    breakdown = _normalize_staking_breakdown(staking_breakdown, staking_balance)
+    staking_balance = breakdown["total"]
+    balance_wei = _response_balance(response)
+
+    if format_type == "json":
+        data = response.dict() if hasattr(response, "dict") else response
+        if isinstance(data, dict):
+            data["staking_balance"] = staking_balance
+            data["staking_breakdown"] = {
+                "direct_stake": breakdown["direct_stake"],
+                "delegate_stake": breakdown["delegate_stake"],
+                "node_delegate_stake": breakdown["node_delegate_stake"],
+                "overwatch_stake": breakdown["overwatch_stake"],
+                "unbonding": breakdown["unbonding"],
+            }
+            data["total_balance"] = balance_wei + staking_balance
+        console.print_json(data=data)
+        return
+
+    # BalanceResponse has fields directly - convert from wei to TENSOR for display
+    total_balance = balance_wei + staking_balance
+
+    table = create_htcli_balance_table(
+        [
+            {
+                "name": wallet_name or wallet_type,
+                "address": response.address or "Unknown",
+                "free_balance": balance_wei,
+                "direct_stake": breakdown["direct_stake"],
+                "delegate_stake": breakdown["delegate_stake"],
+                "node_delegate_stake": breakdown["node_delegate_stake"],
+                "overwatch_stake": breakdown["overwatch_stake"],
+                "unbonding": breakdown["unbonding"],
+                "staked_balance": staking_balance,
+                "total_balance": total_balance,
+            }
+        ],
+        totals={
+            "free": balance_wei,
+            "direct_stake": breakdown["direct_stake"],
+            "delegate_stake": breakdown["delegate_stake"],
+            "node_delegate_stake": breakdown["node_delegate_stake"],
+            "overwatch_stake": breakdown["overwatch_stake"],
+            "unbonding": breakdown["unbonding"],
+            "staked": staking_balance,
+            "total": total_balance,
+        },
+        network_name=network_name,
+        show_totals=False,
+    )
+    console.print(Padding(table, (0, 0, 1, 0)))
+
+    # Display additional details in a panel below the table
+    # TODO: Re-enable panel after fixing display issues
+    # from ...ui.components import HTCLIPanel
+
+    # balance_wei = response.balance or 0
+    # details_content = f"""[htcli.accent]Account Information[/htcli.accent]
+
+    # [htcli.value]Wallet Name:[/htcli.value] {wallet_name or "N/A"}
+    # [htcli.value]Wallet Type:[/htcli.value] {wallet_type}
+    # [htcli.value]Address:[/htcli.value] {response.address or "Unknown"}
+    # [htcli.value]Status:[/htcli.value] Active
+
+    # [htcli.accent]Balance Details[/htcli.accent]
+
+    # [htcli.value]Balance (TENSOR):[/htcli.value] {balance_tensor:,.2f} TENSOR
+    # [htcli.value]Balance (Wei):[/htcli.value] {balance_wei:,} wei
+    # [htcli.value]Available:[/htcli.value] {balance_tensor:,.2f} TENSOR
+    # """
+
+    # details_panel = HTCLIPanel(
+    #     details_content,
+    #     title="📊 Account Details",
+    #     border_style="htcli.info",
+    #     padding=(1, 2),
+    # )
+    # details_panel.render()
+
+    if show_guidance:
+        display_balance_info(response.address or "Unknown", response.balance or 0)
+
+
+def _response_balance(response) -> int:
+    if isinstance(response, dict):
+        return int(response.get("balance", 0) or 0)
+    return int(getattr(response, "balance", 0) or 0)
+
+
+def _normalize_staking_breakdown(
+    staking_breakdown: Optional[dict], staking_balance: int
+) -> dict:
+    component_keys = (
+        "direct_stake",
+        "delegate_stake",
+        "node_delegate_stake",
+        "overwatch_stake",
+        "unbonding",
+    )
+    breakdown = dict.fromkeys(component_keys, 0)
+
+    if staking_breakdown:
+        for key in component_keys:
+            breakdown[key] = int(staking_breakdown.get(key, 0) or 0)
+
+    component_total = sum(breakdown.values())
+    breakdown["total"] = int(
+        (staking_breakdown or {}).get("total", 0)
+        or component_total
+        or staking_balance
+        or 0
+    )
+    return breakdown
+
+
+def display_wallet_transfer_result(
+    response: WalletTransferResponse, dry_run: bool = False
+):
+    """Display wallet transfer results with beautiful formatting."""
+    from ...ui.components import HTCLIPanel
+
+    # Format the amount nicely - handle string type
+    if isinstance(response.amount, str):
+        try:
+            amount_float = float(response.amount)
+            amount_str = f"{amount_float:,.4f} TENSOR"
+        except (ValueError, TypeError):
+            amount_str = f"{response.amount} TENSOR"
+    elif isinstance(response.amount, (int, float)):
+        amount_str = f"{response.amount:,.4f} TENSOR"
+    else:
+        amount_str = str(response.amount)
+
+    # Safely format addresses with checksum
+    from ...utils.wallet.crypto import format_address_display
+
+    from_addr = (
+        format_address_display(str(response.from_address), truncate=False)
+        if response.from_address
+        else "Unknown"
+    )
+    to_addr = (
+        format_address_display(str(response.to_address), truncate=False)
+        if response.to_address
+        else "Unknown"
+    )
+
+    # Build content string
+    content = f"""[htcli.success]✅ Transfer completed successfully![/htcli.success]
+
+[htcli.value]From:[/htcli.value]   [htcli.address]{from_addr}[/htcli.address]
+[htcli.value]To:[/htcli.value]     [htcli.address]{to_addr}[/htcli.address]
+[htcli.value]Amount:[/htcli.value] [htcli.amount]{amount_str}[/htcli.amount]
+"""
+
+    # Add transaction details for real transfers
+    if not dry_run and response.transaction_hash:
+        content += f"\n[htcli.value]Transaction Hash:[/htcli.value] [htcli.subtitle]{response.transaction_hash}[/htcli.subtitle]\n"
+        # Add block hash if available
+        if response.block_hash:
+            content += f"[htcli.value]Block Hash:[/htcli.value] [htcli.subtitle]{response.block_hash}[/htcli.subtitle]\n"
+
+    # Display with HTCLIPanel
+    panel = HTCLIPanel(
+        content,
+        title="💸 Transfer Complete" if not dry_run else "🔍 Transfer Preview",
+        border_style="htcli.success" if not dry_run else "htcli.info",
+        highlight=True,
+    )
+    panel.render()
+
+
+def display_wallet_update_result(response: WalletUpdateResponse):
+    """Display wallet update results."""
+    print_success("Wallet updated successfully!")
+    console.print()
+
+    console.print(f"[bold]Wallet:[/bold] {response.old_name} → {response.new_name}")
+    console.print(f"[bold]Address:[/bold] {address(response.address)}")
+    console.print(f"[bold]Key Type:[/bold] {response.key_type.upper()}")
+
+    console.print()
+    console.print("[bold]Updates:[/bold]")
+    console.print(
+        f"   Name: {'✅ Updated' if response.name_updated else '❌ No change'}"
+    )
+    console.print(
+        f"   Password: {'✅ Updated' if response.password_updated else '❌ No change'}"
+    )
+
+    if response.owner_updated is not None:
+        console.print(
+            f"   Owner: {'✅ Updated' if response.owner_updated else '❌ No change'}"
+        )
+        if (
+            response.owner_updated
+            and response.old_owner_address
+            and response.new_owner_address
+        ):
+            console.print(
+                f"      {address(response.old_owner_address)} → {address(response.new_owner_address)}"
+            )
+            # Show on-chain transaction details if available
+            if response.transaction_hash:
+                console.print()
+                console.print("[bold]On-Chain Update:[/bold]")
+                console.print(f"   Transaction: {response.transaction_hash}")
+                if response.block_hash:
+                    console.print(f"   Block Hash: {response.block_hash}")
+                if response.block_number:
+                    console.print(f"   Block Number: {response.block_number}")
+                console.print()
+
+
+def display_wallet_deletion_result(response: WalletDeleteResponse):
+    """Display wallet deletion results in a beautiful panel."""
+    import sys
+
+    from ...ui.components import HTCLIPanel
+
+    # Build content string
+    content = f"""[htcli.success]🎉 Successfully deleted {response.total_deleted} wallet(s)[/htcli.success]
+
+[htcli.title]📊 Deletion Statistics:[/htcli.title]
+   • Coldkeys: [htcli.value]{response.coldkeys_deleted}[/htcli.value]
+   • Standalone Hotkeys: [htcli.value]{response.hotkeys_deleted}[/htcli.value] (directly deleted)
+   • Associated Hotkeys: [htcli.value]{response.associated_hotkeys_deleted}[/htcli.value] (deleted with owner coldkey)"""
+
+    content += "\n\n[htcli.error]🗑️  Deleted Wallets:[/htcli.error]"
+    for wallet_name in response.deleted_wallets:
+        content += f"\n   • [htcli.value]{wallet_name}[/htcli.value]"
+
+    # Show associated hotkey details if any
+    if response.associated_hotkey_details:
+        content += "\n\n[htcli.title]🔑 Associated Hotkeys Deleted:[/htcli.title]"
+        for hotkey_info in response.associated_hotkey_details:
+            hotkey_name = hotkey_info.get("name", "Unknown")
+            owner_name = hotkey_info.get("owner", "Unknown")
+            content += f"\n   • [htcli.value]{hotkey_name}[/htcli.value] (owned by [htcli.accent]{owner_name}[/htcli.accent])"
+
+    content += (
+        "\n\n[htcli.warning]💡 Note: This action cannot be undone.[/htcli.warning]"
+    )
+
+    # Create and display panel
+    panel = HTCLIPanel(
+        content,
+        title="✅ Wallet Deletion Complete",
+        border_style="htcli.success",
+        highlight=True,
+    )
+
+    console.print()
+    panel.render()
+    console.print()
+
+    # Ensure output is flushed
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+
+def display_wallet_describe_result(wallet_info: dict, balance_info: dict = None):
+    """Display comprehensive wallet information."""
+    from ...utils.blockchain.formatting import TensorAmount
+
+    print_success("Wallet Information")
+    console.print()
+
+    # Main wallet details table
+    table = HTCLITable(
+        title=f"[bold blue]📋 {wallet_info['name']} Details[/bold blue]",
+        border_style="blue",
+        header_style="bold cyan",
+    )
+    table.add_column("Property", style="bold white", width=20)
+    table.add_column("Value", style="bright_white", width=60)
+
+    # Basic wallet information
+    table.add_row("Name", wallet_info["name"])
+    table.add_row(
+        "Type", "Hotkey" if wallet_info.get("is_hotkey", False) else "Coldkey"
+    )
+    table.add_row("Key Type", wallet_info.get("key_type", "ECDSA").upper())
+    table.add_row("Address (Full)", address_full(wallet_info["address"]))
+    table.add_row("Public Key", wallet_info.get("public_key", "N/A"))
+    table.add_row(
+        "Encryption",
+        "🔒 Enabled" if wallet_info.get("encrypted", False) else "Disabled",
+    )
+
+    # Owner information for hotkeys
+    if wallet_info.get("is_hotkey", False) and wallet_info.get("owner_name"):
+        table.add_row(
+            "Owner",
+            f"{wallet_info['owner_name']} ({address(wallet_info.get('owner_address', 'N/A'))})",
+        )
+
+    console.print(table.table)
+    console.print()
+
+    # Balance information for coldkeys
+    if not wallet_info.get("is_hotkey", False) and balance_info:
+        if "error" in balance_info:
+            print_warning(f"Unable to fetch balance: {balance_info['error']}")
+        else:
+            balance_table = HTCLITable(
+                title="[bold green]💰 Balance Information[/bold green]",
+                border_style="green",
+                header_style="bold bright_green",
+            )
+            balance_table.add_column("Property", style="bold white", width=20)
+            balance_table.add_column("Value", style="bright_white", width=40)
+
+            try:
+                balance = balance_info.get("balance", 0)
+                if isinstance(balance, (int, float)) and balance > 0:
+                    amount = TensorAmount.from_wei(balance)
+                    balance_table.add_row(
+                        "Free Balance", f"{amount.tensor:,.3f} TENSOR"
+                    )
+                    balance_table.add_row("Raw Balance", f"{balance:,}")
+                else:
+                    balance_table.add_row("Free Balance", "0.000 TENSOR")
+                    balance_table.add_row("Raw Balance", "0")
+            except Exception:
+                balance_table.add_row("Free Balance", "[red]Error calculating[/red]")
+                balance_table.add_row("Raw Balance", "[red]Error calculating[/red]")
+
+            console.print(balance_table.table)
+            console.print()
+
+    # Additional information for hotkeys
+    if wallet_info.get("is_hotkey", False):
+        hotkey_table = HTCLITable(
+            title="[bold yellow]Hotkey Information[/bold yellow]",
+            border_style="yellow",
+            header_style="bold bright_yellow",
+        )
+        hotkey_table.add_column("Property", style="bold white", width=20)
+        hotkey_table.add_column("Value", style="bright_white", width=40)
+
+        hotkey_table.add_row("Purpose", "Used for node operations and staking")
+        hotkey_table.add_row(
+            "Security", "Keep this key secure but accessible for node operations"
+        )
+        hotkey_table.add_row("Owner", wallet_info.get("owner_name", "Unknown"))
+
+        console.print(hotkey_table.table)
+        console.print()
+
+    # Security reminders
+    security_table = HTCLITable(
+        title="[bold red]🔒 Security Information[/bold red]",
+        border_style="red",
+        header_style="bold bright_red",
+    )
+    security_table.add_column("Property", style="bold white", width=20)
+    security_table.add_column("Value", style="bright_white", width=60)
+
+    if wallet_info.get("is_hotkey", False):
+        security_table.add_row("Backup", "Store hotkey securely for node operations")
+        security_table.add_row("Access", "Keep accessible for automated node functions")
+        security_table.add_row("Rotation", "Consider rotating hotkeys periodically")
+    else:
+        security_table.add_row("Backup", "Store coldkey in secure, offline location")
+        security_table.add_row("Access", "Limit access to essential operations only")
+        security_table.add_row(
+            "Recovery", "Keep recovery phrase in multiple secure locations"
+        )
+
+    console.print(security_table.table)
+
+
+def display_identity_update_result(response: dict, hotkey_address: str):
+    """Display identity update results."""
+    print_success("Identity updated successfully!")
+    console.print()
+
+    # Display identity details in a table
+    table = HTCLITable(
+        title="[bold blue]🆔 Identity Information[/bold blue]",
+        border_style="blue",
+        header_style="bold cyan",
+    )
+    table.add_column("Property", style="bold white", width=20)
+    table.add_column("Value", style="bright_white", width=60)
+
+    # Hotkey Address
+    table.add_row("Hotkey", address(hotkey_address))
+
+    # Parse fields from the extrinsic call if possible, or display generic success
+    # Since we don't have the full parsed identity object here, we'll show what we can
+    # Ideally, we should fetch the updated identity to show here, but for now:
+
+    console.print(table.table)
+    console.print()
+
+    # Transaction details
+    if response.get("transaction_hash"):
+        console.print("[bold]Transaction Details:[/bold]")
+        console.print(f"   Transaction Hash: {response.get('transaction_hash')}")
+        if response.get("block_hash"):
+            console.print(f"   Block Hash: {response.get('block_hash')}")
+        if response.get("block_number"):
+            console.print(f"   Block Number: {response.get('block_number')}")
+        console.print()