htcli 1.1.0__py3-none-any.whl

src/htcli/commands/subnet/prompts.py

@@ -0,0 +1,1225 @@
+from pathlib import Path
+from typing import Optional
+
+import typer
+from pydantic import ValidationError
+from rich import console
+
+from src.htcli.ui.colors import info  # noqa: F401
+
+from ...client.offchain.wallet import WalletManager
+from ...models.enums.enum_types import KeyType
+from ...models.requests import SubnetRegisterRequest
+from ...ui.display import HTCLIConsole
+from ...ui.prompts import confirm_prompt, integer_prompt, select_prompt, text_prompt
+from ...utils import retrieve_wallet_with_validation
+from ...utils.validation import (
+    validate_subnet_name,
+    validate_subnet_repo,
+    validate_subnet_min_stake,
+    validate_subnet_max_stake,
+    validate_subnet_delegate_stake_percentage,
+    validate_hotkey_address,
+)
+
+
+def prompt_get_subnet() -> int:
+    """Prompt for subnet ID."""
+    return integer_prompt(
+        "Enter the Subnet ID (UID)",
+        min_value=0,
+    )
+
+
+def prompt_list_nodes() -> int:
+    """Prompt for subnet ID to list nodes from."""
+    return integer_prompt(
+        "Enter the Subnet ID (UID) to list nodes from",
+        min_value=0,
+    )
+
+
+def prompt_check_activation() -> int:
+    """Prompt for subnet ID to check activation requirements for."""
+    console = HTCLIConsole()
+    console.print("\n[htcli.info]Check activation requirements for a subnet[/htcli.info]")
+    return integer_prompt(
+        "Enter the Subnet ID (UID) to check activation requirements",
+        min_value=0,
+    )
+
+
+def prompt_activate_subnet() -> int:
+    """Prompt for subnet ID to activate."""
+    return integer_prompt(
+        "Enter the Subnet ID (UID) to activate",
+        min_value=0,
+    )
+
+
+def prompt_pause_subnet() -> int:
+    """Prompt for subnet ID to pause."""
+    return integer_prompt(
+        "Enter the Subnet ID (UID) to pause",
+        min_value=0,
+    )
+
+
+def prompt_unpause_subnet() -> int:
+    """Prompt for subnet ID to unpause."""
+    return integer_prompt(
+        "Enter the Subnet ID (UID) to unpause",
+        min_value=0,
+    )
+
+
+def prompt_owner_update(
+    subnet_id: Optional[int] = None,
+    new_name: Optional[str] = None,
+    new_repo: Optional[str] = None,
+) -> tuple[int, Optional[str], Optional[str]]:
+    """Prompt for subnet ID and update fields."""
+    if subnet_id is None:
+        subnet_id = integer_prompt(
+            "Enter the Subnet ID (UID) to update",
+            min_value=0,
+        )
+
+    if new_name is None and new_repo is None:
+        # Ask what to update
+        update_options = []
+        if new_name is None:
+            update_options.append("name")
+        if new_repo is None:
+            update_options.append("repository URL")
+
+        console.print(info("What would you like to update?"))
+        for i, option in enumerate(update_options, 1):
+            console.print(f"  {i}. {option}")
+
+        choice = integer_prompt(
+            f"Select option (1-{len(update_options)})",
+            min_value=1,
+            max_value=len(update_options),
+        )
+
+        if choice == 1 and "name" in update_options:
+            new_name = text_prompt("Enter the new name for the subnet")
+        elif choice == 2 and "repository URL" in update_options:
+            new_repo = text_prompt(
+                "Enter the new repository URL (optional)", default="", required=False
+            )
+        elif choice == 1 and "repository URL" in update_options:
+            new_repo = text_prompt(
+                "Enter the new repository URL (optional)", default="", required=False
+            )
+    else:
+        # Prompt for missing fields
+        if new_name is None:
+            new_name = text_prompt("Enter the new name for the subnet")
+        if new_repo is None:
+            new_repo = text_prompt(
+                "Enter the new repository URL (optional)", default="", required=False
+            )
+
+    return subnet_id, new_name, new_repo
+
+
+def prompt_owner_update_name() -> tuple[int, str]:
+    """Prompt for subnet ID and new name."""
+    subnet_id = integer_prompt(
+        "Enter the Subnet ID (UID) to update",
+        min_value=0,
+    )
+    new_name = text_prompt(
+        "Enter the new name for the subnet",
+    )
+    return subnet_id, new_name
+
+
+def prompt_owner_update_repo() -> tuple[int, str]:
+    """Prompt for subnet ID and new repo URL."""
+    subnet_id = integer_prompt(
+        "Enter the Subnet ID (UID) to update",
+        min_value=0,
+    )
+    new_repo = text_prompt(
+        "Enter the new repository URL (optional)",
+        default="",
+        required=False,
+    )
+    return subnet_id, new_repo
+
+
+def prompt_owner_transfer() -> tuple[int, str]:
+    """Prompt for subnet ID and new owner (EVM address or wallet name)."""
+    subnet_id = integer_prompt(
+        "Enter the Subnet ID (UID) to transfer",
+        min_value=0,
+    )
+    
+    new_owner = text_prompt(
+        "Enter the new owner's EVM address or wallet name (e.g., 0x... or wallet-name)",
+        required=True,
+    )
+    
+    return subnet_id, new_owner
+
+
+def prompt_owner_accept() -> int:
+    """Prompt for subnet ID to accept ownership of."""
+    return integer_prompt(
+        "Enter the Subnet ID (UID) to accept ownership for",
+        min_value=0,
+    )
+
+
+def prompt_owner_remove() -> int:
+    """Prompt for subnet ID to remove."""
+    subnet_id = integer_prompt(
+        "Enter the Subnet ID (UID) to remove",
+        min_value=0,
+    )
+
+    # Use HTCLI confirmation prompt with warning
+    confirmed = confirm_prompt(
+        f"⚠️  Are you sure you want to permanently remove subnet {subnet_id}? This action cannot be undone.",
+        default=False,
+    )
+
+    if not confirmed:
+        raise ValueError("Subnet removal cancelled by user")
+
+    return subnet_id
+
+
+def prompt_register_subnet(
+    name: Optional[str] = None,
+    repo: Optional[str] = None,
+    description: Optional[str] = None,
+    misc: Optional[str] = None,
+    min_stake: Optional[float] = None,
+    max_stake: Optional[float] = None,
+    max_cost: Optional[float] = None,
+    delegate_stake_percentage: Optional[int] = None,
+    initial_coldkeys: Optional[str] = None,
+    key_types: Optional[str] = None,
+    bootnodes: Optional[str] = None,
+) -> SubnetRegisterRequest:
+    """Iteratively prompt for subnet registration details."""
+    from ...ui.display import print_error
+    
+    # STEP 1: Validate ALL provided parameters FIRST (before any client initialization)
+    # This ensures users see validation errors immediately, even if network is down
+    # Collect all validation errors before proceeding
+    
+    validation_errors = []
+    # Validate name if provided
+    if name is not None:
+        # Handle empty string explicitly
+        if name == "" or (isinstance(name, str) and not name.strip()):
+            validation_errors.append("Invalid subnet name: Subnet name cannot be empty")
+            name = None
+        else:
+            is_valid, error_msg = validate_subnet_name(name)
+            if not is_valid:
+                validation_errors.append(f"Invalid subnet name: {error_msg}")
+                name = None
+
+    # Validate repo if provided
+    if repo is not None:
+        # Handle empty string explicitly
+        if repo == "" or (isinstance(repo, str) and not repo.strip()):
+            validation_errors.append("Invalid repository URL: Repository URL cannot be empty")
+            repo = None
+        else:
+            is_valid, error_msg = validate_subnet_repo(repo)
+            if not is_valid:
+                validation_errors.append(f"Invalid repository URL: {error_msg}")
+                repo = None
+
+    # Note: min_stake and max_stake validation is handled inline during prompting
+    # We don't add errors here since we'll reprompt interactively
+    # Just convert to None if invalid so they get reprompted
+    # This handles CLI-provided values that might be invalid
+    if min_stake is not None:
+        try:
+            # Convert TENSOR to WEI if it's a float
+            if isinstance(min_stake, float):
+                min_stake_wei = int(min_stake * 1e18)
+                is_valid, error_msg = validate_subnet_min_stake(min_stake_wei)
+                if not is_valid:
+                    min_stake = None  # Will be reprompted inline
+                else:
+                    min_stake = min_stake_wei  # Convert to int (wei) if valid
+            # If already in wei (int), validate as-is
+            elif isinstance(min_stake, int):
+                is_valid, error_msg = validate_subnet_min_stake(min_stake)
+                if not is_valid:
+                    min_stake = None  # Will be reprompted inline
+        except Exception:
+            min_stake = None  # Will be reprompted inline
+
+    if max_stake is not None:
+        try:
+            # Convert TENSOR to WEI if it's a float
+            if isinstance(max_stake, float):
+                max_stake_wei = int(max_stake * 1e18)
+                # Note: We can't validate against min_stake here since it might not be set yet
+                # This validation will happen inline during prompting
+                is_valid, error_msg = validate_subnet_max_stake(max_stake_wei, None)
+                if not is_valid:
+                    max_stake = None  # Will be reprompted inline
+                else:
+                    max_stake = max_stake_wei  # Convert to int (wei) if valid
+            # If already in wei (int), validate as-is (without min_stake check)
+            elif isinstance(max_stake, int):
+                is_valid, error_msg = validate_subnet_max_stake(max_stake, None)
+                if not is_valid:
+                    max_stake = None  # Will be reprompted inline
+        except Exception:
+            max_stake = None  # Will be reprompted inline
+
+    # Validate delegate_stake_percentage if provided (before prompting)
+    if delegate_stake_percentage is not None:
+        # If provided as percentage (0-100), convert to wei format for validation
+        if delegate_stake_percentage <= 100:
+            delegate_stake_percentage_wei = int(delegate_stake_percentage * 1e18 / 100)
+        else:
+            # Already in wei format
+            delegate_stake_percentage_wei = delegate_stake_percentage
+        
+        is_valid, error_msg = validate_subnet_delegate_stake_percentage(delegate_stake_percentage_wei)
+        if not is_valid:
+            validation_errors.append(f"Invalid delegate stake percentage: {error_msg}")
+            delegate_stake_percentage = None
+        else:
+            delegate_stake_percentage = delegate_stake_percentage_wei
+
+    # Note: max_registered_nodes is NOT part of RegistrationSubnetData
+    # It's a subnet configuration field set separately after registration
+    # We skip validation here since it's not used in registration
+
+    # Display all validation errors at once
+    if validation_errors:
+        for error in validation_errors:
+            print_error(error)
+        print_error("Please correct the errors above. You will be prompted for valid values.")
+
+    # STEP 2: Now prompt for missing values (client-dependent operations happen here)
+    
+
+    if name is None:
+        name = text_prompt("Enter subnet name")
+
+    if repo is None:
+        # Prompt with validation using a validator function
+        def repo_validator(value: str) -> bool:
+            """Validator function for repo URL."""
+            is_valid, _ = validate_subnet_repo(value)
+            return is_valid
+        
+        repo = text_prompt(
+            "Enter repository URL",
+            required=True,
+            validator=repo_validator,
+            error_message="Repository URL must be a valid HTTP/HTTPS URL (e.g., https://github.com/user/repo)",
+        ).strip()
+    else:
+        repo = repo.strip()
+        # Validation already happened above in STEP 1, but ensure it's still valid
+        # (repo.strip() might have changed it)
+        is_valid, error_msg = validate_subnet_repo(repo)
+        if not is_valid:
+            print_error(f"Invalid repository URL: {error_msg}")
+            repo = None
+            # Re-prompt with validator
+            def repo_validator(value: str) -> bool:
+                """Validator function for repo URL."""
+                is_valid, _ = validate_subnet_repo(value)
+                return is_valid
+            
+            repo = text_prompt(
+                "Enter repository URL",
+                required=True,
+                validator=repo_validator,
+                error_message="Repository URL must be a valid HTTP/HTTPS URL (e.g., https://github.com/user/repo)",
+            ).strip()
+
+    # Prompt for min_stake with inline validation and reprompting
+    if min_stake is None:
+        from ...ui.prompts import amount_prompt
+        from ...ui.display import print_error
+        
+        while min_stake is None:
+            try:
+                # Use default from constants (100 TENSOR)
+                min_stake_tensor = amount_prompt(
+                    "Enter minimum stake required for nodes (in TENSOR)",
+                    currency="TENSOR",
+                    default=100.0,
+                )
+                # Convert TENSOR to WEI
+                min_stake_wei = int(min_stake_tensor * 1e18)
+                
+                # Validate immediately
+                is_valid, error_msg = validate_subnet_min_stake(min_stake_wei)
+                if not is_valid:
+                    print_error(f"Invalid minimum stake ({min_stake_tensor} TENSOR): {error_msg}")
+                    min_stake = None  # Will reprompt
+                else:
+                    min_stake = min_stake_wei
+            except (KeyboardInterrupt, typer.Abort):
+                raise
+            except Exception as e:
+                print_error(f"Invalid input: {str(e)}")
+                min_stake = None  # Retry the prompt
+
+    # Prompt for max_stake with inline validation and reprompting
+    # Must validate against min_stake as well
+    if max_stake is None:
+        from ...ui.prompts import amount_prompt
+        from ...ui.display import print_error
+        
+        while max_stake is None:
+            try:
+                # Use default from constants (1000 TENSOR)
+                max_stake_tensor = amount_prompt(
+                    "Enter maximum stake allowed for nodes (in TENSOR)",
+                    currency="TENSOR",
+                    default=1000.0,
+                )
+                # Convert TENSOR to WEI
+                max_stake_wei = int(max_stake_tensor * 1e18)
+                
+                # Validate immediately (check against min_stake if available)
+                is_valid, error_msg = validate_subnet_max_stake(max_stake_wei, min_stake)
+                if not is_valid:
+                    print_error(f"Invalid maximum stake ({max_stake_tensor} TENSOR): {error_msg}")
+                    max_stake = None  # Will reprompt
+                else:
+                    max_stake = max_stake_wei
+            except (KeyboardInterrupt, typer.Abort):
+                raise
+            except Exception as e:
+                print_error(f"Invalid input: {str(e)}")
+                max_stake = None  # Retry the prompt
+    elif isinstance(max_stake, int):
+        # If provided via CLI and already validated (int/wei), validate against min_stake
+        is_valid, error_msg = validate_subnet_max_stake(max_stake, min_stake)
+        if not is_valid:
+            print_error(f"Invalid maximum stake: {error_msg}")
+            max_stake = None
+            # Reprompt
+            from ...ui.prompts import amount_prompt
+            from ...ui.display import print_error
+            
+            while max_stake is None:
+                try:
+                    max_stake_tensor = amount_prompt(
+                        "Enter maximum stake allowed for nodes (in TENSOR)",
+                        currency="TENSOR",
+                        default=1000.0,
+                    )
+                    max_stake_wei = int(max_stake_tensor * 1e18)
+                    is_valid, error_msg = validate_subnet_max_stake(max_stake_wei, min_stake)
+                    if not is_valid:
+                        print_error(f"Invalid maximum stake ({max_stake_tensor} TENSOR): {error_msg}")
+                        max_stake = None
+                    else:
+                        max_stake = max_stake_wei
+                except (KeyboardInterrupt, typer.Abort):
+                    raise
+                except Exception as e:
+                    print_error(f"Invalid input: {str(e)}")
+                    max_stake = None
+
+    if max_cost is None:
+        # Prompt for max cost in TENSOR (user-friendly)
+        from ...ui.prompts import amount_prompt
+
+        while max_cost is None:
+            try:
+                max_cost_tensor = amount_prompt(
+                    "Enter maximum cost",
+                    currency="TENSOR",
+                    min_amount=0.0,
+                )
+                max_cost = int(max_cost_tensor * 1e18)  # Convert to planck
+            except (KeyboardInterrupt, typer.Abort):
+                # Allow Ctrl+C to break out immediately instead of re-prompting
+                raise
+            except Exception as e:
+                from ...ui.display import print_error
+                print_error(f"Invalid input: {str(e)}")
+                max_cost = None  # Retry the prompt
+    elif isinstance(max_cost, float):
+        # If provided via CLI as float, convert to wei
+        max_cost = int(max_cost * 1e18)
+
+    # Collect additional configuration - only prompt if not provided
+    if description is None:
+        description = text_prompt(
+            "Enter a short description",
+            default="",
+            required=False,
+        ) or ""  # Ensure it's always a string, not None
+
+    if misc is None:
+        misc = text_prompt(
+            "Enter miscellaneous info (optional)",
+            default="",
+            required=False,
+        ) or ""  # Ensure it's always a string, not None
+
+    # Note: churn_limit and other configuration fields are NOT part of RegistrationSubnetData
+    # They are set separately after registration using owner update calls
+    # We skip prompting for them here to match the blockchain structure
+
+    if delegate_stake_percentage is None:
+        while delegate_stake_percentage is None:
+            try:
+                delegate_stake_percentage_pct = integer_prompt(
+                    "Enter delegate stake percentage (0-100)",
+                    default=20,
+                    min_value=0,
+                    max_value=100,
+                )
+                # Convert to wei format
+                delegate_stake_percentage = int(delegate_stake_percentage_pct * 1e18 / 100)
+            except (ValueError, typer.Abort):
+                raise
+
+
+    # Collect initial coldkeys interactively if not provided
+    # parsed_initial_coldkeys can be either:
+    # - A list of addresses (legacy, will be converted to dict with default 1)
+    # - A dict mapping address -> max_registrations (new format)
+    parsed_initial_coldkeys = []
+    if initial_coldkeys:
+        # If provided via CLI, parse as comma-separated addresses
+        # We'll prompt for max_registrations for each address
+        addr_list = [
+            addr.strip() for addr in initial_coldkeys.split(",") if addr.strip()
+        ]
+        
+        # Validate count immediately
+        if len(addr_list) < 3:
+            console = HTCLIConsole()
+            console.print(
+                f"\n[htcli.warning]❌ You provided {len(addr_list)} address(es), but need at least 3[/htcli.warning]"
+            )
+            console.print(
+                "[htcli.warning]⚠️  Subnet registration requires at least 3 initial coldkeys[/htcli.warning]"
+            )
+            raise typer.Exit(code=1)
+        
+        # Prompt for number of nodes each coldkey can register
+        console = HTCLIConsole()
+        console.print(
+            "\n[htcli.info]💡 Node Registration Limits:[/htcli.info]"
+        )
+        console.print(
+            "   • Specify how many nodes each coldkey can register during the registration period"
+        )
+        console.print(
+            "   • Default is 1 node per coldkey (minimum required)"
+        )
+        console.print("")
+        
+        parsed_initial_coldkeys = {}
+        for addr in addr_list:
+            # Show shortened address for display
+            addr_display = addr[:10] + "..." + addr[-8:] if len(addr) > 20 else addr
+            
+            max_nodes = integer_prompt(
+                f"Max nodes for coldkey {addr_display}",
+                default=1,
+                min_value=1,
+                max_value=1000,  # Reasonable upper limit
+            )
+            parsed_initial_coldkeys[addr] = max_nodes
+    else:
+        # Explain initial coldkeys (REQUIRED parameter)
+        console = HTCLIConsole()
+        console.print("\n[htcli.info]💡 Initial Coldkeys (Required):[/htcli.info]")
+        console.print(
+            "   • [bold]Must provide at least 3 coldkeys[/bold] for subnet registration"
+        )
+        console.print(
+            "   • These coldkeys can register nodes during the registration period"
+        )
+        console.print(
+            "   • After activation, the subnet becomes [bold]permissionless[/bold] automatically"
+        )
+        console.print(
+            "   • The whitelist is removed and anyone can register nodes"
+        )
+        console.print("")
+
+        # Ask user how to provide initial coldkeys
+        choice = select_prompt(
+            "How would you like to provide initial coldkeys?",
+            [
+                ("select", "Select from existing coldkey wallets (need 3+)"),
+                ("enter", "Enter addresses manually (need 3+)"),
+            ],
+            default="select",
+        )
+
+        if choice == "select":
+
+            wallet_manager = WalletManager()
+            # Show existing coldkey wallets in simple numbered list
+            try:
+                wallets_response = wallet_manager.list_wallets()
+                all_wallets = wallets_response.get("data", [])
+                coldkeys = [w for w in all_wallets if not w.get("is_hotkey", False)]
+                if coldkeys:
+                    console = HTCLIConsole()
+                    console.print("\n[bold]Available coldkey wallets:[/bold]")
+                    for i, key in enumerate(coldkeys, 1):
+                        name_color = "[bold cyan]"
+                        address_color = "[cyan]"
+                        encrypted_status = ""
+                        if key.get("is_encrypted", False):
+                            encrypted_status = " [dim](encrypted - password required)[/dim]"
+                        console.print(
+                            f"{i}. {name_color}{key['name']}[/]{encrypted_status} - {address_color}{key['ss58_address']}[/]"
+                        )
+                    console.print("")
+            except Exception:
+                # Non-fatal - continue to selection even if listing fails
+                pass
+            # Multi-select by indices (comma-separated), with fallback to interactive selector
+            wallet_selection_retry = True
+            while wallet_selection_retry:
+                try:
+                    # Build index map for coldkeys
+                    idx_to_wallet = (
+                        {str(i + 1): w for i, w in enumerate(coldkeys)} if coldkeys else {}
+                    )
+                    if idx_to_wallet:
+                        console.print(
+                            "\n[htcli.warning]⚠️  You must select at least 3 coldkeys (required for consensus)[/htcli.warning]"
+                        )
+                        console.print(
+                            "[htcli.info]   Example: Enter '1,2,3' to select first three wallets[/htcli.info]\n"
+                        )
+                        selection = text_prompt(
+                            "Select at least 3 coldkey indices (comma-separated, e.g. '1,2,3')",
+                            required=True,
+                            default="1,2,3",  # Helpful default
+                        ).strip()
+                    else:
+                        selection = ""
+
+                    if selection:
+                        indices = [s.strip() for s in selection.split(",") if s.strip()]
+                        successful_selections = 0
+                        failed_selections = []
+                        
+                        # Store selected coldkeys info for prompting
+                        selected_coldkeys_info = []
+                        for idx in indices:
+                            wallet = idx_to_wallet.get(idx)
+                            if wallet:
+                                addr = wallet.get("ss58_address")
+                                if addr:
+                                    # Check if already added (avoid duplicates)
+                                    if not any(c["address"] == addr for c in selected_coldkeys_info):
+                                        selected_coldkeys_info.append({
+                                            "name": wallet.get("name", "Unknown"),
+                                            "address": addr,
+                                        })
+                                        successful_selections += 1
+
+                        # Validate count after selection
+                        if len(selected_coldkeys_info) < 3:
+                            console.print(
+                                f"\n[htcli.warning]❌ You successfully selected {len(selected_coldkeys_info)} coldkey(s), but need at least 3[/htcli.warning]"
+                            )
+                            if failed_selections:
+                                console.print(
+                                    f"[htcli.warning]   {len(failed_selections)} wallet(s) were skipped due to unlock failures[/htcli.warning]"
+                                )
+                            console.print(
+                                "[htcli.warning]⚠️  Subnet registration requires at least 3 initial coldkeys[/htcli.warning]"
+                            )
+                            # Ask user to provide wallets again instead of exiting
+                            from ...ui.prompts import confirm_prompt
+                            if not confirm_prompt("Would you like to select wallets again?", default=True):
+                                raise typer.Exit(code=1)
+                            # Retry by continuing the while loop
+                            continue
+                        
+                        # If we get here, we have enough wallets - exit retry loop
+                        wallet_selection_retry = False
+                        
+                        # Prompt for number of nodes each coldkey can register
+                        console.print(
+                            "\n[htcli.info]💡 Node Registration Limits:[/htcli.info]"
+                        )
+                        console.print(
+                            "   • Specify how many nodes each coldkey can register during the registration period"
+                        )
+                        console.print(
+                            "   • Default is 1 node per coldkey (minimum required)"
+                        )
+                        console.print("")
+                        
+                        # Prompt for max_registrations for each selected coldkey
+                        parsed_initial_coldkeys = {}
+                        for coldkey_info in selected_coldkeys_info:
+                            wallet_name = coldkey_info["name"]
+                            wallet_addr = coldkey_info["address"]
+                            
+                            # Show shortened address for display
+                            addr_display = wallet_addr[:10] + "..." + wallet_addr[-8:] if len(wallet_addr) > 20 else wallet_addr
+                            
+                            max_nodes = integer_prompt(
+                                f"Max nodes for {wallet_name} ({addr_display})",
+                                default=1,
+                                min_value=1,
+                                max_value=1000,  # Reasonable upper limit
+                            )
+                            parsed_initial_coldkeys[wallet_addr] = max_nodes
+                    else:
+                        console.print(
+                            "[htcli.warning]⚠️  Unable to select coldkeys automatically. Please re-run with manual addresses (--initial-coldkeys) or ensure wallet list is available.[/htcli.warning]"
+                        )
+                        raise typer.Exit(code=1)
+                except typer.Exit:
+                    raise
+                except Exception as e:
+                    # If anything fails, check if we should retry
+                    from ...ui.prompts import confirm_prompt
+                    if confirm_prompt("An error occurred. Would you like to try selecting wallets again?", default=True):
+                        continue
+                    # If user doesn't want to retry, re-raise the exception
+                    raise
+
+        elif choice == "create":
+            from ...dependencies import get_client
+            from ...utils.wallet.core import _create_new_wallet
+
+            client = get_client()
+            keep_creating = True
+            created_addresses = []
+            while keep_creating:
+                try:
+                    name, keypair = _create_new_wallet(client, wallet_type="coldkey")
+                    address = keypair.ss58_address
+                    if address not in created_addresses:
+                        created_addresses.append(address)
+                except Exception:
+                    break
+                keep_creating = confirm_prompt(
+                    "Create and add another coldkey?", default=False
+                )
+            
+            # After creating wallets, prompt for max_registrations for each
+            if created_addresses:
+                # Validate count
+                if len(created_addresses) < 3:
+                    console.print(
+                        f"\n[htcli.warning]❌ You created {len(created_addresses)} coldkey(s), but need at least 3[/htcli.warning]"
+                    )
+                    console.print(
+                        "[htcli.warning]⚠️  Subnet registration requires at least 3 initial coldkeys[/htcli.warning]"
+                    )
+                    raise typer.Exit(code=1)
+                
+                console.print(
+                    "\n[htcli.info]💡 Node Registration Limits:[/htcli.info]"
+                )
+                console.print(
+                    "   • Specify how many nodes each coldkey can register during the registration period"
+                )
+                console.print(
+                    "   • Default is 1 node per coldkey (minimum required)"
+                )
+                console.print("")
+                
+                parsed_initial_coldkeys = {}
+                for addr in created_addresses:
+                    # Get wallet name if available
+                    wallet_info = None
+                    try:
+                        from ...utils.wallet.crypto import get_wallet_info_by_address
+                        wallet_info = get_wallet_info_by_address(addr, is_hotkey=False)
+                    except Exception:
+                        pass
+                    
+                    wallet_name = wallet_info.get("name", "Unknown") if wallet_info else "Unknown"
+                    addr_display = addr[:10] + "..." + addr[-8:] if len(addr) > 20 else addr
+                    
+                    max_nodes = integer_prompt(
+                        f"Max nodes for {wallet_name} ({addr_display})",
+                        default=1,
+                        min_value=1,
+                        max_value=1000,
+                    )
+                    parsed_initial_coldkeys[addr] = max_nodes
+            else:
+                # No wallets created, set empty dict (will fail validation)
+                parsed_initial_coldkeys = {}
+
+        elif choice == "enter":
+            console.print(
+                "\n[htcli.warning]⚠️  Remember: You need at least 3 addresses for consensus[/htcli.warning]"
+            )
+            addr_text = text_prompt(
+                "Enter at least 3 coldkey addresses (comma-separated)", required=True
+            )
+            addr_list = [
+                a.strip() for a in addr_text.split(",") if a.strip()
+            ]
+            # Validate count immediately
+            if len(addr_list) < 3:
+                console.print(
+                    f"[htcli.warning]❌ You entered {len(addr_list)} address(es), but need at least 3[/htcli.warning]"
+                )
+                console.print(
+                    "[htcli.warning]⚠️  Subnet registration requires at least 3 initial coldkeys[/htcli.warning]"
+                )
+                raise typer.Exit(code=1)
+            
+            # Prompt for number of nodes each coldkey can register
+            console.print(
+                "\n[htcli.info]💡 Node Registration Limits:[/htcli.info]"
+            )
+            console.print(
+                "   • Specify how many nodes each coldkey can register during the registration period"
+            )
+            console.print(
+                "   • Default is 1 node per coldkey (minimum required)"
+            )
+            console.print("")
+            
+            parsed_initial_coldkeys = {}
+            for addr in addr_list:
+                # Show shortened address for display
+                addr_display = addr[:10] + "..." + addr[-8:] if len(addr) > 20 else addr
+                
+                max_nodes = integer_prompt(
+                    f"Max nodes for coldkey {addr_display}",
+                    default=1,
+                    min_value=1,
+                    max_value=1000,  # Reasonable upper limit
+                )
+                parsed_initial_coldkeys[addr] = max_nodes
+        else:
+            # No valid choice - should not happen with select_prompt
+            console.print(
+                "[htcli.warning]❌ Invalid choice. Subnet registration requires at least 3 initial coldkeys.[/htcli.warning]"
+            )
+            raise typer.Exit(code=1)
+
+    # If initial coldkeys are provided and key_types missing, infer sensible default
+    # Check if parsed_initial_coldkeys is dict or list
+    coldkey_count = len(parsed_initial_coldkeys) if parsed_initial_coldkeys else 0
+    if coldkey_count > 0 and not key_types:
+        key_types = "Ecdsa"  # This will be parsed to KeyType.ECDSA later
+
+    # Collect bootnodes if provided or interactively
+    parsed_bootnodes: list[str] = []
+    if bootnodes:
+        # Filter out None and empty values, ensure all are strings
+        parsed_bootnodes = [
+            b.strip() for b in bootnodes.split(",") 
+            if b and isinstance(b, str) and b.strip()
+        ]
+    else:
+        def _get_default_bootnodes() -> list[str]:
+            default_bootnodes: list[str] = []
+
+            
+
+            if not default_bootnodes:
+                default_bootnodes = [
+                    "/ip4/127.0.0.1/tcp/31330/p2p/QmShJYgxNoKn7xqdRQj5PBcNfPSsbWkgFBPA4mK5PH73JC",
+                    "/ip4/127.0.0.1/tcp/31330/p2p/QmbRz8Bt1pMcVnUzVQpL2icveZz2MF7VtELC44v8kVNwiH",
+                    "/ip4/127.0.0.1/tcp/31330/p2p/QmTJ8uyLJBwVprejUQfYFAywdXWfdnUQbC1Xif6QiTNta1",
+                ]
+
+            return default_bootnodes
+
+        default_bootnodes = _get_default_bootnodes()
+
+        from ...ui.display import print_info
+
+        console = HTCLIConsole()
+        console.print("\n[htcli.info]Default Hypertensor bootnodes:[/htcli.info]")
+        for addr in default_bootnodes:
+            console.print(f"  • [htcli.value]{addr}[/htcli.value]")
+        console.print("")
+
+        bootnode_choice = select_prompt(
+            "How would you like to provide bootnodes?",
+            [
+                ("default", "Use default Hypertensor bootnodes"),
+                ("custom", "Enter bootnodes manually (comma-separated)"),
+            ],
+            default="default",
+        )
+
+        if bootnode_choice == "custom":
+            boot_text = text_prompt(
+                "Enter bootnode multiaddrs (comma-separated)", required=True
+            )
+            # Filter out None and empty values, ensure all are strings
+            parsed_bootnodes = [
+                b.strip() for b in boot_text.split(",") 
+                if b and isinstance(b, str) and b.strip()
+            ]
+            print_info("Using custom bootnodes.")
+        else:
+            # Ensure default_bootnodes are all strings (should already be, but be safe)
+            parsed_bootnodes = [b for b in default_bootnodes if b and isinstance(b, str)]
+            print_info(
+                "Using default Hypertensor bootnodes from subnet template.\n"
+                "Update the subnet bootnodes after registration if needed."
+            )
+
+    # Set defaults for optional parameters if not provided
+    if key_types is None:
+        key_types = "Ed25519"
+
+    # Parse key types if provided and convert to KeyType enum values
+    parsed_key_types = set()
+    if key_types:
+        # Split comma-separated key types and strip whitespace
+        key_type_strings = [kt.strip() for kt in key_types.split(",") if kt.strip()]
+
+        # Map string names to KeyType enum values (case-insensitive)
+        key_type_map = {
+            "rsa": KeyType.RSA,
+            "ed25519": KeyType.ED25519,
+            "secp256k1": KeyType.SECP256K1,
+            "ecdsa": KeyType.ECDSA,
+        }
+
+        for kt_str in key_type_strings:
+            kt_lower = kt_str.lower()
+            if kt_lower in key_type_map:
+                parsed_key_types.add(key_type_map[kt_lower])
+            else:
+                # If invalid key type, show warning and skip
+                from ...ui.display import print_warning
+
+                print_warning(f"Unknown key type '{kt_str}', skipping...")
+    else:
+        # Default to Ed25519 if no key types specified
+        parsed_key_types = {KeyType.ED25519}
+
+    # Validate that we have at least 3 initial coldkeys (blockchain requirement)
+    # parsed_initial_coldkeys is now a dict {address: max_registrations} or a list [addresses]
+    # Handle both cases for backward compatibility
+    if isinstance(parsed_initial_coldkeys, dict):
+        initial_coldkeys_dict = parsed_initial_coldkeys
+        coldkey_count = len(initial_coldkeys_dict)
+    else:
+        # Legacy: list of addresses - convert to dict with default of 1
+        initial_coldkeys_dict = {addr: 1 for addr in parsed_initial_coldkeys}
+        coldkey_count = len(parsed_initial_coldkeys)
+    
+    if coldkey_count < 3:
+        console = HTCLIConsole()
+        console.print(
+            f"\n[htcli.warning]❌ Subnet registration requires at least 3 initial coldkeys, but only {coldkey_count} provided[/htcli.warning]"
+        )
+        console.print(
+            "[htcli.info]💡 After activation, the subnet becomes permissionless automatically[/htcli.info]"
+        )
+        raise typer.Exit(code=1)
+    
+    # Ensure all values are at least 1 (blockchain requirement)
+    initial_coldkeys_dict = {
+        addr: max(max_registrations, 1) 
+        for addr, max_registrations in initial_coldkeys_dict.items()
+    }
+
+    # delegate_stake_percentage is already in wei format from validation above
+    # If it wasn't provided, use default
+    if delegate_stake_percentage is None:
+        delegate_stake_percentage_wei = 100_000_000_000_000_000  # Default 10%
+    else:
+        delegate_stake_percentage_wei = delegate_stake_percentage
+    
+    bootnodes_set = {
+        bn for bn in parsed_bootnodes if bn is not None and isinstance(bn, str) and bn.strip()
+    }
+
+    # Note: Only include fields that are part of RegistrationSubnetData
+    # Other fields (churn_limit, queue_epochs, etc.) are set separately after registration
+    # Ensure description and misc are always strings (not None)
+    return SubnetRegisterRequest(
+        name=name,
+        repo=repo,
+        description=description or "",
+        misc=misc or "",
+        min_stake=min_stake,
+        max_stake=max_stake,
+        max_cost=max_cost,
+        delegate_stake_percentage=delegate_stake_percentage_wei,
+        initial_coldkeys=initial_coldkeys_dict,
+        key_types=parsed_key_types,
+        # Filter out None values and ensure all are strings before creating set
+        bootnodes=bootnodes_set,  # Ensure bootnodes is never None and contains only valid strings
+    )
+
+
+def prompt_owner_update_extended(
+    subnet_id: Optional[int] = None,
+    new_name: Optional[str] = None,
+    new_repo: Optional[str] = None,
+    target_node_registrations: Optional[int] = None,
+    node_burn_rate_alpha: Optional[int] = None,
+    queue_immunity_epochs: Optional[int] = None,
+    min_weight_decrease_threshold: Optional[int] = None,
+    min_node_reputation: Optional[int] = None,
+    absent_reputation_penalty: Optional[int] = None,
+    included_reputation_boost: Optional[int] = None,
+    below_min_weight_penalty: Optional[int] = None,
+    non_attestor_penalty: Optional[int] = None,
+    validator_absent_penalty: Optional[int] = None,
+    validator_non_consensus_penalty: Optional[int] = None,
+    non_consensus_attestor_penalty: Optional[int] = None,
+) -> dict:
+    """Prompt for extended subnet update options in a config-edit style.
+
+    For each configurable field, show a prompt where the user can type a new
+    value or press enter to skip. Only fields with values entered are returned.
+    """
+    if subnet_id is None:
+        subnet_id = integer_prompt("Enter the Subnet ID (UID) to update", min_value=0)
+
+    console_instance = HTCLIConsole()
+    console_instance.print(
+        info(
+            "Subnet update (leave a field blank to keep its current value)."
+        )
+    )
+
+    result: dict = {"subnet_id": subnet_id}
+
+    def prompt_optional_int(message: str) -> Optional[int]:
+        raw = text_prompt(message, default="", required=False)
+        if raw is None:
+            return None
+        raw = raw.strip()
+        if raw == "":
+            return None
+        try:
+            return int(raw)
+        except ValueError:
+            from ...ui.display import print_error
+
+            print_error("Invalid integer, skipping this field.")
+            return None
+
+    # Name
+    if new_name is not None:
+        result["new_name"] = new_name
+    else:
+        name_input = text_prompt(
+            "New subnet name (leave blank to keep current)", default="", required=False
+        )
+        if name_input and name_input.strip():
+            result["new_name"] = name_input.strip()
+
+    # Repo
+    if new_repo is not None:
+        result["new_repo"] = new_repo
+    else:
+        repo_input = text_prompt(
+            "New repository URL (leave blank to keep current)",
+            default="",
+            required=False,
+        )
+        if repo_input and repo_input.strip():
+            result["new_repo"] = repo_input.strip()
+
+    # Numeric config fields
+    if target_node_registrations is not None:
+        result["target_node_registrations"] = target_node_registrations
+    else:
+        value = prompt_optional_int(
+            "Target node registrations per epoch (blank to keep current)"
+        )
+        if value is not None:
+            result["target_node_registrations"] = value
+
+    if node_burn_rate_alpha is not None:
+        result["node_burn_rate_alpha"] = node_burn_rate_alpha
+    else:
+        value = prompt_optional_int(
+            "Node burn rate alpha (blank to keep current)"
+        )
+        if value is not None:
+            result["node_burn_rate_alpha"] = value
+
+    if queue_immunity_epochs is not None:
+        result["queue_immunity_epochs"] = queue_immunity_epochs
+    else:
+        value = prompt_optional_int(
+            "Queue immunity epochs (blank to keep current)"
+        )
+        if value is not None:
+            result["queue_immunity_epochs"] = value
+
+    if min_weight_decrease_threshold is not None:
+        result["min_weight_decrease_threshold"] = min_weight_decrease_threshold
+    else:
+        value = prompt_optional_int(
+            "Min weight decrease threshold (blank to keep current)"
+        )
+        if value is not None:
+            result["min_weight_decrease_threshold"] = value
+
+    if min_node_reputation is not None:
+        result["min_node_reputation"] = min_node_reputation
+    else:
+        value = prompt_optional_int(
+            "Min node reputation (blank to keep current)"
+        )
+        if value is not None:
+            result["min_node_reputation"] = value
+
+    if absent_reputation_penalty is not None:
+        result["absent_reputation_penalty"] = absent_reputation_penalty
+    else:
+        value = prompt_optional_int(
+            "Absent reputation penalty (blank to keep current)"
+        )
+        if value is not None:
+            result["absent_reputation_penalty"] = value
+
+    if included_reputation_boost is not None:
+        result["included_reputation_boost"] = included_reputation_boost
+    else:
+        value = prompt_optional_int(
+            "Included reputation boost (blank to keep current)"
+        )
+        if value is not None:
+            result["included_reputation_boost"] = value
+
+    if below_min_weight_penalty is not None:
+        result["below_min_weight_penalty"] = below_min_weight_penalty
+    else:
+        value = prompt_optional_int(
+            "Below-min weight penalty (blank to keep current)"
+        )
+        if value is not None:
+            result["below_min_weight_penalty"] = value
+
+    if non_attestor_penalty is not None:
+        result["non_attestor_penalty"] = non_attestor_penalty
+    else:
+        value = prompt_optional_int(
+            "Non-attestor penalty (blank to keep current)"
+        )
+        if value is not None:
+            result["non_attestor_penalty"] = value
+
+    if validator_absent_penalty is not None:
+        result["validator_absent_penalty"] = validator_absent_penalty
+    else:
+        value = prompt_optional_int(
+            "Validator absent penalty (blank to keep current)"
+        )
+        if value is not None:
+            result["validator_absent_penalty"] = value
+
+    if validator_non_consensus_penalty is not None:
+        result["validator_non_consensus_penalty"] = validator_non_consensus_penalty
+    else:
+        value = prompt_optional_int(
+            "Validator non-consensus penalty (blank to keep current)"
+        )
+        if value is not None:
+            result["validator_non_consensus_penalty"] = value
+
+    if non_consensus_attestor_penalty is not None:
+        result["non_consensus_attestor_penalty"] = non_consensus_attestor_penalty
+    else:
+        value = prompt_optional_int(
+            "Non-consensus attestor penalty (blank to keep current)"
+        )
+        if value is not None:
+            result["non_consensus_attestor_penalty"] = value
+
+    # Fill in other fields from parameters without overwriting prompted values
+    if "new_name" not in result and new_name is not None:
+        result["new_name"] = new_name
+    if "new_repo" not in result and new_repo is not None:
+        result["new_repo"] = new_repo
+    if "target_node_registrations" not in result and target_node_registrations is not None:
+        result["target_node_registrations"] = target_node_registrations
+    if "node_burn_rate_alpha" not in result and node_burn_rate_alpha is not None:
+        result["node_burn_rate_alpha"] = node_burn_rate_alpha
+    if "queue_immunity_epochs" not in result and queue_immunity_epochs is not None:
+        result["queue_immunity_epochs"] = queue_immunity_epochs
+    if "min_weight_decrease_threshold" not in result and min_weight_decrease_threshold is not None:
+        result["min_weight_decrease_threshold"] = min_weight_decrease_threshold
+    if "min_node_reputation" not in result and min_node_reputation is not None:
+        result["min_node_reputation"] = min_node_reputation
+    if "absent_reputation_penalty" not in result and absent_reputation_penalty is not None:
+        result["absent_reputation_penalty"] = absent_reputation_penalty
+    if "included_reputation_boost" not in result and included_reputation_boost is not None:
+        result["included_reputation_boost"] = included_reputation_boost
+    if "below_min_weight_penalty" not in result and below_min_weight_penalty is not None:
+        result["below_min_weight_penalty"] = below_min_weight_penalty
+    if "non_attestor_penalty" not in result and non_attestor_penalty is not None:
+        result["non_attestor_penalty"] = non_attestor_penalty
+    if "validator_absent_penalty" not in result and validator_absent_penalty is not None:
+        result["validator_absent_penalty"] = validator_absent_penalty
+    if (
+        "validator_non_consensus_penalty" not in result
+        and validator_non_consensus_penalty is not None
+    ):
+        result["validator_non_consensus_penalty"] = validator_non_consensus_penalty
+    if (
+        "non_consensus_attestor_penalty" not in result
+        and non_consensus_attestor_penalty is not None
+    ):
+        result["non_consensus_attestor_penalty"] = non_consensus_attestor_penalty
+
+    return result
+
+
+def prompt_set_emergency_validator_set(
+    subnet_id: Optional[int] = None, node_ids: Optional[str] = None
+) -> tuple[int, str]:
+    """Prompt for emergency validator set parameters."""
+    if subnet_id is None:
+        subnet_id = integer_prompt("Enter the Subnet ID (UID)", min_value=0)
+    if node_ids is None:
+        node_ids = text_prompt(
+            "Enter comma-separated list of subnet node IDs for emergency validator set",
+            required=True,
+        )
+    return subnet_id, node_ids
+
+
+def prompt_clear_emergency_validator_set() -> int:
+    """Prompt for clearing emergency validator set."""
+    return integer_prompt("Enter the Subnet ID (UID) to clear emergency validator set", min_value=0)
+
+
+def prompt_bootnode_access(
+    subnet_id: Optional[int] = None,
+    account: Optional[str] = None,
+    action: str = "add",
+) -> tuple[int, str]:
+    """Prompt for bootnode access parameters."""
+    if subnet_id is None:
+        subnet_id = integer_prompt("Enter the Subnet ID (UID)", min_value=0)
+    if account is None:
+        action_label = "grant" if action == "add" else "revoke"
+        account = text_prompt(
+            f"Enter account address to {action_label} bootnode access to",
+            required=True,
+        )
+    return subnet_id, account