htcli 1.1.0__py3-none-any.whl

src/htcli/commands/wallet/prompts.py

@@ -0,0 +1,1518 @@
+"""
+Wallet command prompting logic.
+
+Handles user interaction and input validation for wallet operations.
+Uses HTCLI UI components and Pydantic models for proper validation.
+"""
+
+import re
+from typing import Optional
+
+from ...models.requests import (
+    PreseededWalletRequest,
+    WalletCreateRequest,
+    WalletDeleteRequest,
+    WalletRestoreRequest,
+    WalletTransferRequest,
+    WalletUpdateRequest,
+)
+from ...errors.base import AmbiguousWalletError
+from ...ui.colors import error, info, warning
+from ...ui.components import HTCLITable
+from ...ui.display import HTCLIConsole
+from ...ui.prompts import (
+    HTCLIPrompt,
+    amount_prompt,
+    confirm_prompt,
+    integer_prompt,
+    password_prompt,
+    prompt_for_optional,
+    prompt_for_required,
+    select_prompt,
+    text_prompt,
+)
+from ...utils.blockchain.validation import validate_wallet_name
+from ...utils.validation import validate_wallet_name_prompt
+from ...utils.wallet.crypto import (
+    _find_wallet_entries,
+    format_address_display,
+    get_wallet_info_by_name,
+    list_keys,
+)
+
+console = HTCLIConsole()
+prompt = HTCLIPrompt()
+
+
+def validate_password_strength(password: str) -> bool:
+    """Validate password strength."""
+    if len(password) < 8:
+        console.print(error("Password must be at least 8 characters long."))
+        return False
+    if not re.search(r"[A-Z]", password):
+        console.print(error("Password must contain at least one uppercase letter."))
+        return False
+    if not re.search(r"[a-z]", password):
+        console.print(error("Password must contain at least one lowercase letter."))
+        return False
+    if not re.search(r"\d", password):
+        console.print(error("Password must contain at least one digit."))
+        return False
+    if not re.search(r"[!@#$%^&*(),.?\":{}|<>]", password):
+        console.print(error("Password must contain at least one special character."))
+        return False
+    return True
+
+
+def prompt_wallet_creation(
+    name: Optional[str] = None,
+    key_type: Optional[str] = None,
+    wallet_type: str = "coldkey",
+    coldkey_name: Optional[str] = None,
+    password: Optional[str] = None,
+) -> WalletCreateRequest:
+    """Collect wallet creation parameters from user."""
+
+    # Validate wallet name if provided
+    if name is not None:
+        is_valid, error_msg = validate_wallet_name_prompt(name)
+        if not is_valid:
+            console.print(error(f"Invalid wallet name: {error_msg}"))
+            name = None
+
+    # Get wallet name and check for existence
+    if not name:
+        if wallet_type == "hotkey":
+            # For hotkeys, we'll check uniqueness after we know the coldkey
+            # So we just validate the name format here
+            prompt_text = f"{wallet_type.capitalize()} name"
+            name = text_prompt(
+                prompt_text,
+                validator=validate_wallet_name,
+                error_message="Invalid wallet name. Use alphanumeric characters, hyphens, and underscores only.",
+            )
+        else:
+            # For coldkeys, check against all existing wallets
+            existing_wallets = [w["name"] for w in list_keys()]
+            while True:
+                prompt_text = (
+                    f"{wallet_type.capitalize()} name"
+                    if wallet_type in ["hotkey", "coldkey"]
+                    else "Wallet name"
+                )
+                name = text_prompt(
+                    prompt_text,
+                    validator=validate_wallet_name,
+                    error_message="Invalid wallet name. Use alphanumeric characters, hyphens, and underscores only.",
+                )
+                if name in existing_wallets:
+                    console.print(
+                        error(
+                            f"Wallet with name '{name}' already exists. Please choose another name."
+                        )
+                    )
+                else:
+                    break
+
+    # Set key type to ECDSA for HyperTensor EVM compatibility
+    if not key_type:
+        key_type = "ecdsa"
+
+    # Get coldkey address for hotkeys
+    if wallet_type == "hotkey" and not coldkey_name:
+        coldkeys = [w for w in list_keys() if not w.get("is_hotkey")]
+        if not coldkeys:
+            raise ValueError("No coldkeys found. Please create a coldkey first.")
+
+        console.print(info("Available coldkeys:"))
+        table = HTCLITable(title="Coldkeys")
+        table.add_column("Index", style="white")
+        table.add_column("Name", style="white")
+        table.add_column("Encrypted", style="dim")
+        for i, w in enumerate(coldkeys):
+            encrypted_status = "✅ Yes" if w.get("is_encrypted") else "❌ No"
+            table.add_row(str(i + 1), w["name"], encrypted_status)
+        console.print(table.table)
+
+        choice = prompt_for_required(
+            "Select coldkey", int, f"Enter a number from 1 to {len(coldkeys)}"
+        )
+        coldkey_name = coldkeys[choice - 1]["name"]
+
+    # For hotkeys, check if the selected coldkey already has a hotkey with this name
+    if wallet_type == "hotkey" and coldkey_name:
+        from ...utils.wallet.crypto import coldkey_has_hotkey, get_wallet_info_by_name
+
+        try:
+            coldkey_info = get_wallet_info_by_name(coldkey_name, is_hotkey=False)
+            coldkey_address = coldkey_info.get("ss58_address") or coldkey_info.get(
+                "address"
+            )
+
+            if coldkey_has_hotkey(coldkey_address, name):
+                console.print(
+                    error(
+                        f"Coldkey '{coldkey_name}' already has a hotkey named '{name}'. "
+                        "Please choose a different name."
+                    )
+                )
+                # Re-prompt for name
+                while True:
+                    name = text_prompt(
+                        f"{wallet_type.capitalize()} name",
+                        validator=validate_wallet_name,
+                        error_message="Invalid wallet name. Use alphanumeric characters, hyphens, and underscores only.",
+                    )
+                    if not coldkey_has_hotkey(coldkey_address, name):
+                        break
+                    console.print(
+                        error(
+                            f"Coldkey '{coldkey_name}' already has a hotkey named '{name}'. "
+                            "Please choose a different name."
+                        )
+                    )
+        except FileNotFoundError:
+            # Coldkey not found, will be handled later
+            pass
+
+    # Get optional password
+    # If password is empty string, it means explicitly no password (from --no-password flag)
+    # If password is None, prompt the user
+    if password is None:
+        if confirm_prompt("Encrypt wallet with password?", default=True):
+            while True:
+                password = password_prompt("Enter password", confirm=True)
+                if validate_password_strength(password):
+                    break
+    elif password == "":
+        # Explicitly no password (from --no-password flag), set to None for storage
+        password = None
+
+    return WalletCreateRequest(
+        name=name,
+        key_type=key_type,
+        wallet_type=wallet_type,
+        owner_address=coldkey_name,
+        password=password,
+    )
+
+
+def prompt_wallet_restoration(
+    name: Optional[str] = None,
+    private_key: Optional[str] = None,
+    mnemonic: Optional[str] = None,
+    key_type: Optional[str] = None,
+    wallet_type: str = "coldkey",
+    coldkey_name: Optional[str] = None,
+    password: Optional[str] = None,
+) -> WalletRestoreRequest:
+    """Collect wallet restoration parameters from user."""
+
+    # Get wallet name
+    if not name:
+        prompt_text = "Hotkey name" if wallet_type == "hotkey" else "Wallet name"
+        name = text_prompt(prompt_text, validator=validate_wallet_name)
+
+    # Get restoration method
+    if not private_key and not mnemonic:
+        method = select_prompt(
+            "Restoration method",
+            choices=[
+                ("mnemonic", "Mnemonic phrase (12 or 24 words)", "mnemonic"),
+                ("private_key", "Private key (64-character hex)", "private_key"),
+            ],
+            default="mnemonic",
+        )
+
+        if method == "mnemonic":
+            mnemonic = text_prompt("Enter mnemonic phrase")
+        else:
+            private_key = text_prompt(
+                "Enter private key (64 hex characters)",
+                validator=lambda x: len(x) == 64
+                and all(c in "0123456789abcdefABCDEF" for c in x),
+            )
+
+    # Get key type
+    if not key_type:
+        key_type = select_prompt(
+            "Select key type",
+            choices=[
+                ("ecdsa", "ECDSA", "ecdsa"),
+                ("sr25519", "SR25519", "sr25519"),
+                ("ed25519", "Ed25519", "ed25519"),
+            ],
+            default="ecdsa",
+        )
+
+    # Get coldkey for hotkeys
+    if wallet_type == "hotkey" and not coldkey_name:
+        coldkeys = [w for w in list_keys() if not w.get("is_hotkey")]
+        if not coldkeys:
+            raise ValueError(
+                "No coldkeys found. Please create a coldkey first to assign as coldkey."
+            )
+
+        console.print(info("Available coldkeys:"))
+        table = HTCLITable(title="Coldkeys")
+        table.add_column("Index", style="htcli.value")
+        table.add_column("Name", style="htcli.value")
+        table.add_column("Encrypted", style="htcli.subtitle")
+        for i, w in enumerate(coldkeys):
+            encrypted_status = "✅ Yes" if w.get("is_encrypted") else "❌ No"
+            table.add_row(str(i + 1), w["name"], encrypted_status)
+        table.render()
+
+        choice = prompt_for_required(
+            "Select coldkey for the restored hotkey",
+            int,
+            f"Enter a number from 1 to {len(coldkeys)}",
+        )
+        coldkey_name = coldkeys[choice - 1]["name"]
+
+    # Get optional password
+    if password is None:
+        if confirm_prompt("Encrypt wallet with password?", default=True):
+            while True:
+                password = password_prompt("Enter password", confirm=True)
+                if validate_password_strength(password):
+                    break
+
+    return WalletRestoreRequest(
+        name=name,
+        private_key=private_key,
+        mnemonic=mnemonic,
+        key_type=key_type,
+        wallet_type=wallet_type,
+        owner_address=coldkey_name,
+        password=password,
+    )
+
+
+def prompt_preseeded_wallet(
+    preseeded_name: str,
+    custom_name: Optional[str] = None,
+    key_type: Optional[str] = None,
+    password: Optional[str] = None,
+) -> PreseededWalletRequest:
+    """Collect preseeded wallet import parameters."""
+
+    # Get custom name if not provided
+    if not custom_name:
+        custom_name = prompt_for_optional(
+            "Custom wallet name", str, f"Leave empty to use '{preseeded_name}'"
+        )
+
+    # Get key type with default
+    if not key_type:
+        key_type = "ecdsa"  # Preseeded wallets default to ECDSA
+
+    # Get optional password
+    if password is None:
+        if confirm_prompt("Encrypt wallet with password?", default=False):
+            password = password_prompt("Enter password", confirm=True, min_length=8)
+
+    return PreseededWalletRequest(
+        preseeded_name=preseeded_name,
+        custom_name=custom_name,
+        key_type=key_type,
+        password=password,
+    )
+
+
+def prompt_wallet_update(
+    current_name: Optional[str] = None,
+    new_name: Optional[str] = None,
+    new_password: Optional[str] = None,
+    remove_password: Optional[bool] = None,
+    new_coldkey: Optional[str] = None,
+    is_hotkey: bool = False,
+    coldkey_name: Optional[str] = None,
+) -> WalletUpdateRequest:
+    """Collect wallet update parameters."""
+
+    # Initialize disambiguation variables for hotkeys
+    owner_address = None
+    owner_coldkey_name = None
+
+    # Get current wallet name
+    if not current_name:
+        # Display list of existing wallets for user to choose from
+        console.print(info("📋 Available Wallets"))
+
+        all_keys = list_keys()
+        filtered_keys = [k for k in all_keys if k.get("is_hotkey", False) == is_hotkey]
+
+        if not filtered_keys:
+            wallet_type = "hotkeys" if is_hotkey else "coldkeys"
+            console.print(warning(f"No {wallet_type} found."))
+            raise ValueError(f"No {wallet_type} available to update")
+
+        # Display wallets in a table
+        table = HTCLITable(
+            title=f"Available {'Hotkeys' if is_hotkey else 'Coldkeys'}",
+            border_style="blue",
+            header_style="bold cyan",
+        )
+
+        if is_hotkey:
+            table.add_column("Index", style="bold white", width=6)
+            table.add_column("Name", style="bold cyan", width=25)
+            table.add_column("Coldkey", style="bold yellow", width=25)
+            table.add_column("Address", style="white", width=30)
+            table.add_column("Encrypted", style="dim", width=10)
+        else:
+            table.add_column("Index", style="bold white", width=8)
+            table.add_column("Name", style="bold cyan", width=30)
+            table.add_column("Address", style="white", width=40)
+            table.add_column("Encrypted", style="dim", width=12)
+
+        for i, wallet in enumerate(filtered_keys):
+            encrypted_status = "🔒 Yes" if wallet.get("is_encrypted", False) else "No"
+            # Format address in MetaMask style: 0x<first 5 chars>...<last 5 chars>
+            address = (
+                wallet.get("ss58_address")
+                or wallet.get("evm_address")
+                or wallet.get("address", "N/A")
+            )
+            if address != "N/A":
+                # Use the format_address_display function for consistent MetaMask-style formatting
+                address_display = format_address_display(address)
+            else:
+                address_display = address
+
+            if is_hotkey:
+                # Try to resolve coldkey name from coldkey address
+                coldkey_name_display = "Unknown"
+                coldkey_address = wallet.get("owner_address")
+                if coldkey_address:
+                    # Try to find the coldkey with this address
+                    for key in all_keys:
+                        if key.get("ss58_address") == coldkey_address and not key.get(
+                            "is_hotkey", False
+                        ):
+                            coldkey_name_display = key.get(
+                                "name", coldkey_address[:20] + "..."
+                            )
+                            break
+                    else:
+                        coldkey_name_display = coldkey_address[:20] + "..."
+
+                table.add_row(
+                    str(i + 1),
+                    wallet.get("name", "N/A"),
+                    coldkey_name_display,
+                    address_display,
+                    encrypted_status,
+                )
+            else:
+                table.add_row(
+                    str(i + 1),
+                    wallet.get("name", "N/A"),
+                    address_display,
+                    encrypted_status,
+                )
+
+        console.print(table.table)
+        console.print()
+
+        # Let user select by index
+        choice = prompt_for_required(
+            f"Select wallet to update (1-{len(filtered_keys)})",
+            int,
+            f"Enter a number from 1 to {len(filtered_keys)}",
+        )
+
+        if not (1 <= choice <= len(filtered_keys)):
+            raise ValueError(
+                f"Invalid selection. Please choose between 1 and {len(filtered_keys)}"
+            )
+
+        selected_wallet = filtered_keys[choice - 1]
+        current_name = selected_wallet["name"]
+
+        # For hotkeys, extract coldkey info from the selected wallet
+        if is_hotkey and not coldkey_name:
+            coldkey_address = selected_wallet.get("owner_address")
+            if coldkey_address:
+                # Find the coldkey name from the owner address
+                for key in all_keys:
+                    if key.get("ss58_address") == coldkey_address and not key.get(
+                        "is_hotkey", False
+                    ):
+                        coldkey_name = key.get("name")
+                        break
+                else:
+                    # If we can't find the coldkey name, we'll need to ask
+                    # But try to get it from the wallet info
+                    try:
+                        wallet_info = get_wallet_info_by_name(
+                            current_name, is_hotkey=True
+                        )
+                        # Try to find coldkey by address
+                        for key in all_keys:
+                            if key.get("ss58_address") == wallet_info.get(
+                                "owner_address"
+                            ) and not key.get("is_hotkey", False):
+                                coldkey_name = key.get("name")
+                                break
+                    except FileNotFoundError:
+                        pass
+
+        # If we have coldkey_name, set owner_address and owner_coldkey_name for disambiguation
+        if is_hotkey and coldkey_name:
+            try:
+                coldkey_info = get_wallet_info_by_name(coldkey_name, is_hotkey=False)
+                owner_address = (
+                    coldkey_info.get("evm_address")
+                    or coldkey_info.get("ss58_address")
+                    or coldkey_info.get("address")
+                )
+                owner_coldkey_name = coldkey_name
+            except FileNotFoundError:
+                pass
+    else:
+        # Validate that the provided wallet name exists
+        # For hotkeys, use coldkey_name to disambiguate if provided
+        # If coldkey_name is NOT provided and wallet is ambiguous, prompt user
+
+        if is_hotkey and coldkey_name:
+            # Get the coldkey address to use for disambiguation
+            try:
+                coldkey_info = get_wallet_info_by_name(coldkey_name, is_hotkey=False)
+                # Prefer evm_address for ECDSA keys (Hypertensor EVM uses ECDSA)
+                # But also check ss58_address and address fields
+                owner_address = (
+                    coldkey_info.get("evm_address")
+                    or coldkey_info.get("ss58_address")
+                    or coldkey_info.get("address")
+                )
+                if not owner_address:
+                    raise ValueError(
+                        f"Could not determine address for coldkey '{coldkey_name}'"
+                    )
+                owner_coldkey_name = coldkey_name
+            except FileNotFoundError:
+                raise ValueError(
+                    f"Coldkey '{coldkey_name}' not found. Please check the coldkey name."
+                )
+
+        # Try to get wallet info with disambiguation
+        try:
+            wallet_info = get_wallet_info_by_name(
+                current_name,
+                is_hotkey=is_hotkey,
+                owner_address=owner_address,
+                owner_coldkey_name=owner_coldkey_name,
+            )
+        except AmbiguousWalletError as e:
+            # FIX: Handle ambiguity by prompting user to select owner coldkey
+            if is_hotkey and len(e.matches) > 1:
+                console.print(
+                    warning(
+                        f"Found {len(e.matches)} hotkeys named '{current_name}'. Please select which one to update:"
+                    )
+                )
+                table = HTCLITable(title="Select Hotkey")
+                table.add_column("Index", style="bold white", width=6)
+                table.add_column("Coldkey", style="bold yellow", width=25)
+                table.add_column("Address", style="white", width=30)
+
+                for i, match in enumerate(e.matches):
+                    owner_ck = match.get("owner_coldkey_name", "Unknown")
+                    address = (
+                        match.get("evm_address")
+                        or match.get("ss58_address")
+                        or match.get("address", "N/A")
+                    )
+                    if address != "N/A":
+                        address_display = format_address_display(address)
+                    else:
+                        address_display = address
+                    table.add_row(str(i + 1), owner_ck, address_display)
+
+                console.print(table.table)
+                console.print()
+
+                choice = prompt_for_required(
+                    f"Select hotkey to update (1-{len(e.matches)})",
+                    int,
+                    f"Enter a number from 1 to {len(e.matches)}",
+                )
+
+                if not (1 <= choice <= len(e.matches)):
+                    raise ValueError(
+                        f"Invalid selection. Please choose between 1 and {len(e.matches)}"
+                    )
+
+                selected_hotkey = e.matches[choice - 1]
+                # Update coldkey_name from the selected hotkey
+                coldkey_name = selected_hotkey.get("owner_coldkey_name")
+                if coldkey_name:
+                    # Get the coldkey address for disambiguation
+                    try:
+                        coldkey_info = get_wallet_info_by_name(
+                            coldkey_name, is_hotkey=False
+                        )
+                        owner_address = (
+                            coldkey_info.get("evm_address")
+                            or coldkey_info.get("ss58_address")
+                            or coldkey_info.get("address")
+                        )
+                        owner_coldkey_name = coldkey_name
+                    except FileNotFoundError:
+                        pass
+
+                # Retry with the selected coldkey
+                wallet_info = get_wallet_info_by_name(
+                    current_name,
+                    is_hotkey=is_hotkey,
+                    owner_address=owner_address,
+                    owner_coldkey_name=owner_coldkey_name,
+                )
+            else:
+                # Re-raise if we can't handle it
+                raise
+        except ValueError as e:
+            # Handle old-style ValueError for backward compatibility
+            error_str = str(e)
+            if "ambiguous" in error_str.lower() and is_hotkey:
+                # Extract the matches from the error message or find them ourselves
+                all_keys = list_keys()
+                hotkey_matches = [
+                    k
+                    for k in all_keys
+                    if k.get("is_hotkey", False) and k.get("name") == current_name
+                ]
+
+                if len(hotkey_matches) > 1:
+                    console.print(
+                        warning(
+                            f"Found {len(hotkey_matches)} hotkeys named '{current_name}'. Please select which one to update:"
+                        )
+                    )
+                    table = HTCLITable(title="Select Hotkey")
+                    table.add_column("Index", style="bold white", width=6)
+                    table.add_column("Coldkey", style="bold yellow", width=25)
+                    table.add_column("Address", style="white", width=30)
+
+                    for i, match in enumerate(hotkey_matches):
+                        owner_ck = match.get("owner_coldkey_name", "Unknown")
+                        address = (
+                            match.get("evm_address")
+                            or match.get("ss58_address")
+                            or match.get("address", "N/A")
+                        )
+                        if address != "N/A":
+                            address_display = format_address_display(address)
+                        else:
+                            address_display = address
+                        table.add_row(str(i + 1), owner_ck, address_display)
+
+                    console.print(table.table)
+                    console.print()
+
+                    choice = prompt_for_required(
+                        f"Select hotkey to update (1-{len(hotkey_matches)})",
+                        int,
+                        f"Enter a number from 1 to {len(hotkey_matches)}",
+                    )
+
+                    if not (1 <= choice <= len(hotkey_matches)):
+                        raise ValueError(
+                            f"Invalid selection. Please choose between 1 and {len(hotkey_matches)}"
+                        )
+
+                    selected_hotkey = hotkey_matches[choice - 1]
+                    coldkey_name = selected_hotkey.get("owner_coldkey_name")
+                    if coldkey_name:
+                        try:
+                            coldkey_info = get_wallet_info_by_name(
+                                coldkey_name, is_hotkey=False
+                            )
+                            owner_address = (
+                                coldkey_info.get("evm_address")
+                                or coldkey_info.get("ss58_address")
+                                or coldkey_info.get("address")
+                            )
+                            owner_coldkey_name = coldkey_name
+                        except FileNotFoundError:
+                            pass
+
+                    wallet_info = get_wallet_info_by_name(
+                        current_name,
+                        is_hotkey=is_hotkey,
+                        owner_address=owner_address,
+                        owner_coldkey_name=owner_coldkey_name,
+                    )
+                else:
+                    raise
+            else:
+                raise
+        except FileNotFoundError as err:
+            # FIX: Check if wallet exists but under different owner to provide better error
+            found_broken = None
+            try:
+                # Try finding it without owner constraint
+                found_broken = get_wallet_info_by_name(
+                    current_name, is_hotkey=is_hotkey
+                )
+            except Exception:
+                # Still not found or ambiguous
+                pass
+
+            if found_broken:
+                # If we get here, it exists!
+                msg = f"Wallet '{current_name}' not found"
+                if coldkey_name:
+                    msg += f" under owner '{coldkey_name}'"
+
+                actual_owner = found_broken.get("owner_coldkey_name")
+                if actual_owner:
+                    msg += f". It appears to be owned by '{actual_owner}'."
+                    if is_hotkey:
+                        msg += (
+                            f"\n\nTry running with '--coldkey {actual_owner}' instead."
+                        )
+                else:
+                    msg += ". Please check the wallet owner."
+
+                raise ValueError(msg) from err
+
+            # Use specific generic error if totally not found
+            raise ValueError(
+                f"Wallet '{current_name}' not found. Please check the wallet name."
+            ) from err
+
+        wallet_type_actual = wallet_info.get("is_hotkey", False)
+
+        # Validate wallet type matches expected type
+        if wallet_type_actual != is_hotkey:
+            expected = "hotkey" if is_hotkey else "coldkey"
+            actual = "hotkey" if wallet_type_actual else "coldkey"
+            raise ValueError(
+                f"Wallet '{current_name}' is a {actual}, but you're trying to update a {expected}. "
+                f"Use 'htcli wallet update-{'hotkey' if wallet_type_actual else 'coldkey'}' instead."
+            )
+
+    # For hotkeys, get the coldkey name only if we still don't have it (e.g., when wallet name provided via CLI)
+    if is_hotkey and not coldkey_name:
+        coldkey_name = prompt_for_required(
+            "Current coldkey name",
+            str,
+            "Specify which coldkey owns this hotkey",
+            validator=validate_wallet_name,
+        )
+        # Get owner address for disambiguation if we just got the coldkey name
+        if coldkey_name:
+            try:
+                coldkey_info = get_wallet_info_by_name(coldkey_name, is_hotkey=False)
+                owner_address = (
+                    coldkey_info.get("evm_address")
+                    or coldkey_info.get("ss58_address")
+                    or coldkey_info.get("address")
+                )
+                owner_coldkey_name = coldkey_name
+            except FileNotFoundError:
+                raise ValueError(
+                    f"Coldkey '{coldkey_name}' not found. Please check the coldkey name."
+                )
+
+    # Ask what to update
+    console.print(info("What would you like to update?"))
+
+    # Get new name if not provided
+    if new_name is None:
+        prompt_text = "New hotkey name" if is_hotkey else "New wallet name"
+        new_name = prompt_for_optional(
+            prompt_text,
+            str,
+            "Leave empty to keep current name",
+            validator=validate_wallet_name,
+        )
+
+    # Check if wallet is encrypted - use disambiguation if available
+    wallet_info = get_wallet_info_by_name(
+        current_name,
+        is_hotkey=is_hotkey,
+        owner_address=owner_address if is_hotkey else None,
+        owner_coldkey_name=owner_coldkey_name if is_hotkey else None,
+    )
+    is_currently_encrypted = wallet_info.get("is_encrypted", False)
+
+    # Password update options - only show if wallet has password protection
+    current_password = None
+    if new_password is None and remove_password is None:
+        if is_currently_encrypted:
+            # Wallet is password-protected, ask what to do
+            password_action = select_prompt(
+                "Password action",
+                choices=[
+                    ("keep", "Keep current password", "keep"),
+                    ("change", "Change password", "change"),
+                    ("remove", "Remove password protection", "remove"),
+                ],
+                default="keep",
+            )
+
+            if password_action == "change":
+                # Ask for current password to decrypt (no min_length validation for current password)
+                current_password = password_prompt(
+                    "Enter current password to decrypt wallet",
+                    min_length=0,  # Don't validate current password length
+                )
+                # Then ask for new password
+                while True:
+                    new_password = password_prompt("Enter new password", confirm=True)
+                    if validate_password_strength(new_password):
+                        break
+            elif password_action == "remove":
+                # Ask for current password to decrypt before removing (no min_length validation for current password)
+                current_password = password_prompt(
+                    "Enter current password to decrypt wallet",
+                    min_length=0,  # Don't validate current password length
+                )
+                remove_password = True
+        else:
+            # Wallet is not password-protected, ask if user wants to add protection
+            if confirm_prompt(
+                "This wallet is not password-protected. Would you like to add password protection?",
+                default=False,
+            ):
+                while True:
+                    new_password = password_prompt("Enter new password", confirm=True)
+                    if validate_password_strength(new_password):
+                        break
+
+    # Get new coldkey for hotkeys
+    if is_hotkey and new_coldkey is None:
+        # First, get current coldkey info to display
+        current_coldkey_name = "Unknown"
+        current_coldkey_address = "Unknown"
+        try:
+            wallet_info = get_wallet_info_by_name(current_name, is_hotkey=is_hotkey)
+            if coldkey_name:  # If we have the coldkey name from earlier
+                try:
+                    coldkey_info = get_wallet_info_by_name(
+                        coldkey_name, is_hotkey=False
+                    )
+                    current_coldkey_name = coldkey_info.get("name", coldkey_name)
+                    current_coldkey_address = coldkey_info.get(
+                        "ss58_address", "Unknown"
+                    )
+                except FileNotFoundError:
+                    current_coldkey_name = coldkey_name
+        except (FileNotFoundError, KeyError):
+            pass
+
+        # Ask user if they want to change coldkey
+        console.print(info("\n💰 Current Coldkey Information:"))
+        console.print(f"   Coldkey Name: {current_coldkey_name}")
+        console.print(f"   Coldkey Address: {current_coldkey_address}\n")
+
+        change_coldkey = confirm_prompt(
+            "Do you want to change the coldkey for this hotkey?",
+            default=False,
+        )
+
+        if change_coldkey:
+            new_coldkey = prompt_for_required(
+                "New coldkey name",
+                str,
+                "Enter the name of the new coldkey",
+                validator=validate_wallet_name,
+            )
+        else:
+            new_coldkey = None
+
+    return WalletUpdateRequest(
+        current_name=current_name,
+        new_name=new_name,
+        new_password=new_password,
+        remove_password=remove_password or False,
+        current_password=current_password,
+        new_owner=new_coldkey,
+        owner_name=coldkey_name if is_hotkey else None,
+    )
+
+
+def prompt_wallet_deletion(
+    coldkey: Optional[str] = None,
+    hotkey: Optional[str] = None,
+    force: Optional[bool] = None,
+) -> WalletDeleteRequest:
+    """Collect wallet deletion parameters.
+
+    Args:
+        coldkey: Coldkey name to delete (required for coldkey deletion or non-orphaned hotkey deletion)
+        hotkey: Hotkey name to delete (optional, requires coldkey unless hotkey is orphaned)
+        force: Skip confirmation prompts
+    """
+    # Validate parameters
+    if not coldkey and not hotkey:
+        raise ValueError("Either --coldkey or --hotkey must be provided")
+
+    if hotkey:
+        # Deleting a hotkey
+        if not validate_wallet_name(hotkey):
+            raise ValueError(f"Invalid hotkey name: {hotkey}")
+        wallet_name = hotkey
+        is_hotkey = True
+
+        if coldkey:
+            # Owner specified - validate coldkey name
+            if not validate_wallet_name(coldkey):
+                raise ValueError(f"Invalid coldkey name: {coldkey}")
+        # else: orphaned hotkey - no coldkey validation needed
+    else:
+        # Deleting a coldkey - coldkey is required
+        if not coldkey:
+            raise ValueError("--coldkey is required for coldkey deletion")
+        if not validate_wallet_name(coldkey):
+            raise ValueError(f"Invalid coldkey name: {coldkey}")
+        wallet_name = coldkey
+        is_hotkey = False
+
+    names = [wallet_name]
+
+    # Check if wallet exists
+    wallet_owners: dict[str, Optional[str]] = (
+        {}
+    )  # name -> owner_address for disambiguation
+    owner_context: dict[str, dict[str, Optional[str]]] = {}
+
+    if is_hotkey:
+        # For hotkey deletion
+        if coldkey:
+            # Owner specified - we know the owner
+            wallet_owners[wallet_name] = None  # Will be resolved from coldkey
+            owner_context[wallet_name] = {"address": None, "coldkey": coldkey}
+        else:
+            # Orphaned hotkey - no owner
+            wallet_owners[wallet_name] = None
+            owner_context[wallet_name] = {"address": None, "coldkey": None}
+    else:
+        # For coldkey deletion, no owner needed
+        wallet_owners[wallet_name] = None
+        owner_context[wallet_name] = {"address": None, "coldkey": wallet_name}
+
+    # Verify wallet exists
+    try:
+        if is_hotkey:
+            if coldkey:
+                # Get coldkey info to resolve owner address
+                coldkey_info = get_wallet_info_by_name(coldkey, is_hotkey=False)
+                owner_address = (
+                    coldkey_info.get("evm_address")
+                    or coldkey_info.get("ss58_address")
+                    or coldkey_info.get("address")
+                )
+                owner_context[wallet_name]["address"] = owner_address
+
+                # Check if hotkey exists
+                hotkey_info = get_wallet_info_by_name(
+                    wallet_name,
+                    is_hotkey=True,
+                    owner_address=owner_address,
+                    owner_coldkey_name=coldkey,
+                )
+            else:
+                # Orphaned hotkey - find it without owner context
+                all_keys = list_keys()
+                matching_hotkeys = [
+                    k
+                    for k in all_keys
+                    if k.get("is_hotkey", False) and k.get("name") == wallet_name
+                ]
+
+                if not matching_hotkeys:
+                    raise FileNotFoundError(f"Hotkey '{wallet_name}' not found")
+
+                # Use first match (for orphaned hotkeys, there should typically be only one)
+                hotkey_info = matching_hotkeys[0]
+                owner_address = hotkey_info.get("owner_address")
+                owner_coldkey_name = hotkey_info.get("owner_coldkey_name")
+                owner_context[wallet_name]["address"] = owner_address
+                owner_context[wallet_name]["coldkey"] = owner_coldkey_name
+
+                # Verify the hotkey file exists by trying to get wallet info
+                hotkey_info_verified = get_wallet_info_by_name(
+                    wallet_name,
+                    is_hotkey=True,
+                    owner_address=owner_address,
+                    owner_coldkey_name=owner_coldkey_name,
+                )
+        else:
+            # Check if coldkey exists
+            coldkey_info = get_wallet_info_by_name(wallet_name, is_hotkey=False)
+    except (ValueError, FileNotFoundError) as e:
+        console.print(warning(f"❌ Wallet does not exist: {str(e)}"))
+        raise KeyboardInterrupt("Operation cancelled")
+
+    # Get confirmation with granular control
+    if not force:
+        # Collect deletion decision
+        deletion_plan = {}
+        owner_meta = owner_context.get(wallet_name, {})
+        owner_address = owner_meta.get("address")
+        owner_coldkey_name = owner_meta.get("coldkey")
+
+        if is_hotkey:
+            # Deleting a hotkey
+            owner_display = (
+                owner_coldkey_name
+                if owner_coldkey_name
+                else "orphaned (no valid owner)"
+            )
+            console.print(
+                warning(f"⚠️ Deleting hotkey: {wallet_name} (owned by {owner_display})")
+            )
+            deletion_plan[wallet_name] = {
+                "type": "hotkey",
+                "delete_hotkeys": False,
+                "associated_hotkeys": [],
+            }
+        else:
+            # Deleting a coldkey - check for associated hotkeys
+            wallet_info = get_wallet_info_by_name(wallet_name, is_hotkey=False)
+            all_keys = list_keys()
+
+            # Get all possible address formats from coldkey info
+            coldkey_addresses = set()
+            if wallet_info.get("address"):
+                coldkey_addresses.add(wallet_info["address"])
+            if wallet_info.get("ss58_address"):
+                coldkey_addresses.add(wallet_info["ss58_address"])
+            if wallet_info.get("evm_address"):
+                coldkey_addresses.add(wallet_info["evm_address"])
+
+            # Find hotkeys by matching any address format OR owner_coldkey_name
+            associated_hotkeys = []
+            for key in all_keys:
+                if not key.get("is_hotkey", False):
+                    continue
+
+                # Check if owner_address matches any of the coldkey's address formats
+                owner_address = key.get("owner_address")
+                owner_matches = owner_address and owner_address in coldkey_addresses
+
+                # Check if owner_coldkey_name matches
+                owner_name_matches = key.get("owner_coldkey_name") == wallet_name
+
+                if owner_matches or owner_name_matches:
+                    associated_hotkeys.append(key)
+
+            console.print(warning(f"⚠️ Deleting coldkey: {wallet_name}"))
+
+            if associated_hotkeys:
+                console.print(f"Found {len(associated_hotkeys)} associated hotkey(s):")
+                for hotkey in associated_hotkeys:
+                    console.print(f"  • {hotkey['name']}")
+
+                # Ask about deleting associated hotkeys
+                delete_hotkeys = confirm_prompt(
+                    f"Delete {len(associated_hotkeys)} associated hotkey(s) along with coldkey '{wallet_name}'?",
+                    default=True,
+                )
+
+                deletion_plan[wallet_name] = {
+                    "type": "coldkey",
+                    "delete_hotkeys": delete_hotkeys,
+                    "associated_hotkeys": associated_hotkeys if delete_hotkeys else [],
+                }
+            else:
+                console.print(
+                    f"No associated hotkeys found for coldkey '{wallet_name}'"
+                )
+                deletion_plan[wallet_name] = {
+                    "type": "coldkey",
+                    "delete_hotkeys": False,
+                    "associated_hotkeys": [],
+                }
+
+        console.print()
+        console.print(warning("🗑️ Deletion Summary:"))
+        for name, plan in deletion_plan.items():
+            if plan["type"] == "coldkey":
+                if plan["delete_hotkeys"] and plan["associated_hotkeys"]:
+                    console.print(
+                        f"  • {name} (coldkey) + {len(plan['associated_hotkeys'])} hotkey(s):"
+                    )
+                    # Show hotkey names and owner
+                    for hotkey in plan["associated_hotkeys"]:
+                        hotkey_name = hotkey.get("name", "Unknown")
+                        console.print(f"    - {hotkey_name} (owned by {name})")
+                else:
+                    console.print(
+                        f"  • {name} (coldkey only - hotkeys will become orphaned)"
+                    )
+            else:
+                console.print(f"  • {name} (hotkey)")
+
+        console.print()
+        console.print(warning("This action cannot be undone!"))
+
+        confirmed = confirm_prompt(
+            "Proceed with the deletion plan above?", default=False
+        )
+
+        if not confirmed:
+            raise KeyboardInterrupt("Operation cancelled")
+
+        # Store the deletion plan in the request
+        return WalletDeleteRequest(
+            names=names,
+            force=force,
+            deletion_plan=deletion_plan,
+            wallet_owners=wallet_owners,
+            wallet_owner_context=owner_context,
+        )
+
+    return WalletDeleteRequest(
+        names=names,
+        force=force,
+        wallet_owners=wallet_owners,
+        wallet_owner_context=owner_context,
+    )
+
+
+def prompt_wallet_transfer(
+    from_wallet: Optional[str] = None,
+    to_address: Optional[str] = None,
+    amount: Optional[str] = None,
+    password: Optional[str] = None,
+) -> WalletTransferRequest:
+    """Collect wallet transfer parameters."""
+    # Get source wallet
+    if not from_wallet:
+        keys = list_keys()
+        if not keys:
+            raise Exception("No wallets found.")
+
+        # Filter out hotkeys for transfer (only coldkeys have balances)
+        coldkeys = [key for key in keys if not key.get("is_hotkey", False)]
+
+        if not coldkeys:
+            raise Exception(
+                "No coldkey wallets found. Only coldkeys can be used for transfers."
+            )
+
+        console.print("\n[bold]Available coldkey wallets:[/bold]")
+        for i, key in enumerate(coldkeys, 1):
+            # Coldkey styling - blue/cyan theme
+            key_type = "[bold cyan]Coldkey[/bold cyan]"
+            name_color = "[bold cyan]"
+            address_color = "[cyan]"
+
+            console.print(
+                f"{i}. {name_color}{key['name']}[/] ({key_type}) - {address_color}{key['ss58_address']}[/]"
+            )
+
+        while True:
+            try:
+                choice = integer_prompt(
+                    f"\nEnter wallet number (1-{len(coldkeys)})",
+                    min_value=1,
+                    max_value=len(coldkeys),
+                )
+                from_wallet = coldkeys[choice - 1]["name"]
+                break
+            except (ValueError, IndexError):
+                console.print(error("Invalid selection. Please try again."))
+
+    # Get destination address
+    if not to_address:
+        # Show destination options
+        dest_choice = select_prompt(
+            "Destination type",
+            choices=[
+                ("wallet", "Select wallet", "wallet"),
+                ("address", "Enter address", "address"),
+            ],
+            default="wallet",
+        )
+
+        if dest_choice == "wallet":
+            # Show coldkey wallets for destination selection
+            keys = list_keys()
+            coldkeys = [key for key in keys if not key.get("is_hotkey", False)]
+
+            if not coldkeys:
+                raise Exception("No coldkey wallets found for destination.")
+
+            console.print("\n[bold]Available destination wallets:[/bold]")
+            for i, key in enumerate(coldkeys, 1):
+                # Coldkey styling - blue/cyan theme
+                key_type = "[bold cyan]Coldkey[/bold cyan]"
+                name_color = "[bold cyan]"
+                address_color = "[cyan]"
+
+                console.print(
+                    f"{i}. {name_color}{key['name']}[/] ({key_type}) - {address_color}{key['ss58_address']}[/]"
+                )
+
+            while True:
+                try:
+                    choice = integer_prompt(
+                        f"\nEnter destination wallet number (1-{len(coldkeys)})",
+                        min_value=1,
+                        max_value=len(coldkeys),
+                    )
+                    dest_wallet_info = coldkeys[choice - 1]
+
+                    # Check if destination is the same as source wallet
+                    if dest_wallet_info["name"] == from_wallet:
+                        console.print(
+                            error(
+                                "❌ Cannot transfer to the same wallet. Please select a different destination."
+                            )
+                        )
+                        continue
+
+                    to_address = dest_wallet_info["ss58_address"]
+                    console.print(
+                        f"[green]✓[/green] Selected destination: {dest_wallet_info['name']} ({to_address})"
+                    )
+                    break
+                except (ValueError, IndexError):
+                    console.print(error("Invalid selection. Please try again."))
+        else:
+            # Use text_prompt for direct address input
+            to_address = text_prompt("Destination address", required=True)
+
+            # Try to resolve as wallet name if not a valid address
+            from ...utils.blockchain.validation import detect_address_type
+
+            if detect_address_type(to_address)[0] == "unknown":
+                # Check if it's a valid wallet name
+                from ...utils.blockchain.validation import validate_wallet_name
+
+                if validate_wallet_name(to_address):
+                    try:
+                        # Try to resolve as wallet name
+                        dest_wallet_info = get_wallet_info_by_name(
+                            to_address, is_hotkey=False
+                        )
+
+                        # Check if destination is the same as source wallet
+                        if dest_wallet_info["name"] == from_wallet:
+                            console.print(
+                                error(
+                                    "❌ Cannot transfer to the same wallet. Please enter a different destination."
+                                )
+                            )
+                            raise Exception("Cannot transfer to the same wallet.")
+
+                        console.print(
+                            f"[green]✓[/green] Resolved wallet '{to_address}' to address: {dest_wallet_info['ss58_address']}"
+                        )
+                        to_address = dest_wallet_info["ss58_address"]
+                    except FileNotFoundError:
+                        console.print(
+                            error(f"Destination wallet '{to_address}' not found.")
+                        )
+                        raise Exception(
+                            f"Destination wallet '{to_address}' not found."
+                        ) from None
+                    except Exception as e:
+                        console.print(
+                            error(
+                                f"Error accessing destination wallet '{to_address}': {str(e)}"
+                            )
+                        )
+                        raise Exception(
+                            f"Error accessing destination wallet '{to_address}': {str(e)}"
+                        ) from e
+                else:
+                    console.print(
+                        error("Invalid destination address or wallet name format.")
+                    )
+                    raise Exception(
+                        "Invalid destination address or wallet name format."
+                    )
+
+    # Get amount with validation
+    if not amount:
+        # Get sender's balance for validation
+        try:
+            from ...dependencies import get_client
+
+            client = get_client()
+            wallet_info = get_wallet_info_by_name(from_wallet, is_hotkey=False)
+            balance_response = client.rpc.wallet.get_balance(
+                wallet_info["ss58_address"]
+            )
+
+            if balance_response.success:
+                max_balance = balance_response.balance / 1e18  # Convert wei to TENSOR
+                console.print(info(f"💰 Your balance: {max_balance:,.4f} TENSOR"))
+
+                # Set reasonable maximum (either balance or 1 billion TENSOR, whichever is lower)
+                max_amount = min(max_balance, 1_000_000_000)  # 1 billion TENSOR max
+            else:
+                # If can't get balance, set a reasonable default max
+                max_amount = 1_000_000_000  # 1 billion TENSOR
+                console.print(info("⚠️  Could not fetch balance, using default limit"))
+        except Exception as e:
+            console.print(info(f"⚠️  Balance check failed: {str(e)}"))
+            max_amount = 1_000_000_000  # 1 billion TENSOR default
+
+        amount_float = amount_prompt(
+            "Transfer amount",
+            currency="TENSOR",
+            min_amount=0.000001,
+            max_amount=max_amount,
+        )
+        amount = str(amount_float)
+    else:
+        # Validate CLI-provided amount
+        try:
+            amount_float = float(amount)
+            if amount_float <= 0:
+                raise ValueError("Amount must be positive")
+            if amount_float > 1_000_000_000:  # 1 billion TENSOR
+                raise ValueError("Amount too large. Maximum: 1,000,000,000 TENSOR")
+            if amount_float < 0.000001:
+                raise ValueError("Amount too small. Minimum: 0.000001 TENSOR")
+        except ValueError as e:
+            console.print(error(f"Invalid amount: {str(e)}"))
+            raise
+
+    # Get password if needed
+    if password is None:
+        # Check if the wallet is encrypted
+        try:
+            wallet_info = get_wallet_info_by_name(from_wallet, is_hotkey=False)
+            if wallet_info.get("encrypted", False):
+                console.print(info("Wallet password required for encrypted wallet"))
+                password = password_prompt("Enter wallet password", min_length=1)
+            else:
+                console.print(info("Wallet is not encrypted, no password needed"))
+                password = None
+        except Exception as e:
+            # If we can't determine encryption status, skip password prompt
+            console.print(
+                info(f"Could not determine wallet encryption status: {str(e)}")
+            )
+            console.print(info("Skipping password prompt"))
+            password = None
+
+    return WalletTransferRequest(
+        from_wallet=from_wallet, to_address=to_address, amount=amount, password=password
+    )
+
+
+def prompt_wallet_selection(prompt_text: str = "Select wallet") -> str:
+    """Interactive prompt for wallet selection."""
+    keys = list_keys()
+    if not keys:
+        raise Exception("No wallets found.")
+
+    console.print(f"\n[bold]{prompt_text}:[/bold]")
+    for i, key in enumerate(keys, 1):
+        if key.get("is_hotkey", False):
+            # Hotkey styling - yellow/orange theme
+            key_type = "[bold yellow]Hotkey[/bold yellow]"
+            name_color = "[bold yellow]"
+            address_color = "[yellow]"
+        else:
+            # Coldkey styling - blue/cyan theme
+            key_type = "[bold cyan]Coldkey[/bold cyan]"
+            name_color = "[bold cyan]"
+            address_color = "[cyan]"
+
+        console.print(
+            f"{i}. {name_color}{key['name']}[/] ({key_type}) - {address_color}{key['ss58_address']}[/]"
+        )
+
+    while True:
+        try:
+            choice = integer_prompt(
+                f"Enter wallet number (1-{len(keys)})",
+                min_value=1,
+                max_value=len(keys),
+            )
+            return keys[choice - 1]["name"]
+        except (ValueError, IndexError):
+            console.print(error("Invalid selection. Please try again."))
+
+
+def prompt_wallet_balance(
+    wallet_name: Optional[str] = None,
+    address: Optional[str] = None,
+    show_all: bool = False,
+    format_type: Optional[str] = None,
+    show_guidance: Optional[bool] = None,
+) -> tuple[Optional[str], Optional[str], bool, str, bool]:
+    """Interactive prompt for balance arguments."""
+    # If wallet_name is provided, check if it's actually an address
+    if wallet_name:
+        from ...utils.blockchain.validation import detect_address_type
+
+        addr_type, _, is_valid = detect_address_type(wallet_name)
+        if is_valid and addr_type == "ecdsa":
+            # It's an Ethereum address, move it to address parameter
+            address = wallet_name
+            wallet_name = None
+
+    if not wallet_name and not address and not show_all:
+        choice = select_prompt(
+            "Check balance by",
+            choices=[
+                ("wallet", "Specific wallet", "wallet"),
+                ("address", "Specific address", "address"),
+                ("all", "All coldkey wallets", "all"),
+            ],
+            default="wallet",
+        )
+        if choice == "wallet":
+            keys = list_keys()
+            if not keys:
+                raise Exception("No wallets found.")
+
+            # Filter out hotkeys for balance check (only coldkeys have balances)
+            coldkeys = [key for key in keys if not key.get("is_hotkey", False)]
+
+            if not coldkeys:
+                raise Exception(
+                    "No coldkey wallets found. Only coldkeys have balances."
+                )
+
+            console.print("\n[bold]Available coldkey wallets:[/bold]")
+            for i, key in enumerate(coldkeys, 1):
+                # Coldkey styling - blue/cyan theme
+                key_type = "[bold cyan]Coldkey[/bold cyan]"
+                name_color = "[bold cyan]"
+                address_color = "[cyan]"
+
+                console.print(
+                    f"{i}. {name_color}{key['name']}[/] ({key_type}) - {address_color}{key['ss58_address']}[/]"
+                )
+            while True:
+                try:
+                    choice = integer_prompt(
+                        f"\nEnter wallet number (1-{len(coldkeys)})",
+                        min_value=1,
+                        max_value=len(coldkeys),
+                    )
+                    wallet_name = coldkeys[choice - 1]["name"]
+                    break
+                except (ValueError, IndexError):
+                    console.print(error("Invalid selection. Please try again."))
+        elif choice == "address":
+            from ...utils.blockchain.validation import detect_address_type
+
+            while True:
+                address = text_prompt("Enter address to check balance")
+                if detect_address_type(address)[0] != "unknown":
+                    break
+                else:
+                    console.print("Invalid address format.")
+        else:  # all
+            show_all = True
+
+    if format_type is None:
+        format_type = select_prompt(
+            "Output format", choices=["table", "json"], default="table"
+        )
+
+    if show_guidance is None:
+        show_guidance = confirm_prompt("Show comprehensive guidance?", default=True)
+
+    return wallet_name, address, show_all, format_type, show_guidance
+
+
+def prompt_identity_update(
+    hotkey_name: Optional[str] = None,
+    name: Optional[str] = None,
+    url: Optional[str] = None,
+    image: Optional[str] = None,
+    discord: Optional[str] = None,
+    x: Optional[str] = None,
+    telegram: Optional[str] = None,
+    github: Optional[str] = None,
+    hugging_face: Optional[str] = None,
+    description: Optional[str] = None,
+    misc: Optional[str] = None,
+    password: Optional[str] = None,
+):
+    """Collect identity update parameters."""
+    from ...models.requests.identity import IdentityRegisterRequest
+
+    # Get hotkey name if not provided
+    if not hotkey_name:
+        hotkey_name = prompt_wallet_selection("Select hotkey to update identity")
+
+    # Get identity fields
+    if name is None:
+        name = prompt_for_optional(
+            "Display Name", str, "Enter display name for identity"
+        )
+
+    if description is None:
+        description = prompt_for_optional("Description", str, "Enter short description")
+
+    if url is None:
+        url = prompt_for_optional("Website URL", str, "Enter website URL")
+
+    if image is None:
+        image = prompt_for_optional("Image URL", str, "Enter profile image URL")
+
+    if discord is None:
+        discord = prompt_for_optional("Discord Handle", str, "Enter Discord handle")
+
+    if x is None:
+        x = prompt_for_optional("X (Twitter) Handle", str, "Enter X handle")
+
+    if telegram is None:
+        telegram = prompt_for_optional("Telegram Handle", str, "Enter Telegram handle")
+
+    if github is None:
+        github = prompt_for_optional("GitHub URL", str, "Enter GitHub profile URL")
+
+    if hugging_face is None:
+        hugging_face = prompt_for_optional(
+            "Hugging Face URL", str, "Enter Hugging Face profile URL"
+        )
+
+    if misc is None:
+        misc = prompt_for_optional("Misc Data", str, "Enter any additional data")
+
+    # Get password if needed
+    if password is None:
+        # Check if the wallet is encrypted
+        try:
+            wallet_info = get_wallet_info_by_name(hotkey_name, is_hotkey=True)
+            if wallet_info.get("is_encrypted", False) or wallet_info.get(
+                "encrypted", False
+            ):
+                console.print(info("Wallet password required for encrypted wallet"))
+                password = password_prompt("Enter wallet password", min_length=1)
+            else:
+                password = None
+        except Exception:
+            # If we can't determine encryption status, prompt just in case
+            if confirm_prompt("Is your wallet password protected?", default=False):
+                password = password_prompt("Enter wallet password", min_length=1)
+            else:
+                password = None
+
+    # Construct the request model
+    # Note: We return a tuple of (hotkey_name, password, request_model)
+    # because the IdentityRegisterRequest doesn't include the hotkey name/password
+    # in the way we need for the handler
+    request = IdentityRegisterRequest(
+        hotkey="",  # Will be filled by handler with address
+        name=name or "",
+        url=url or "",
+        image=image or "",
+        discord=discord or "",
+        x=x or "",
+        telegram=telegram or "",
+        github=github or "",
+        hugging_face=hugging_face or "",
+        description=description or "",
+        misc=misc or "",
+    )
+
+    return hotkey_name, password, request