htcli 1.1.0__py3-none-any.whl

src/htcli/commands/subnet/handlers.py

@@ -0,0 +1,2855 @@
+from typing import Optional
+
+import typer
+
+from ...dependencies import get_client
+from ...errors.base import SubnetActivationError, SubnetError, SubnetRegistrationError
+from ...errors.handlers import (
+    handle_and_display_error,
+    handle_and_display_node_error,
+    handle_substrate_error,
+)
+from ...ui.colors import success
+from ...ui.components import HTCLILoadingContext
+from ...ui.display import print_error, print_info
+from ...utils import retrieve_wallet_with_validation
+from ...utils.constants import (
+    MAX_SUBNET_PENALTY_COUNT,
+    MIN_SUBNET_DELEGATE_STAKE_FACTOR_PERCENT,
+    MIN_SUBNET_NODES,
+    format_percentage,
+)
+from ...utils.logging import get_logger
+from .error_handling import handle_subnet_error
+
+logger = get_logger(__name__)
+from .display import (
+    display_activation_requirements,  # New display functions
+    display_bootnodes_rpc,
+    display_generic_success,
+    display_subnet_info,
+    display_subnet_info_rpc,
+    display_subnet_list,
+    display_subnet_list_with_coldkey,
+    display_subnet_nodes,
+    display_subnet_nodes_rpc,
+    display_subnets_overview,
+)
+from .prompts import (
+    prompt_activate_subnet,
+    prompt_bootnode_access,
+    prompt_check_activation,
+    prompt_clear_emergency_validator_set,
+    prompt_get_subnet,
+    prompt_list_nodes,
+    prompt_owner_accept,
+    prompt_owner_remove,
+    prompt_owner_transfer,
+    prompt_owner_update,
+    prompt_owner_update_extended,
+    prompt_owner_update_name,
+    prompt_owner_update_repo,
+    prompt_pause_subnet,
+    prompt_register_subnet,
+    prompt_set_emergency_validator_set,
+    prompt_unpause_subnet,
+)
+
+DELEGATE_STAKE_FACTOR_DISPLAY = format_percentage(
+    MIN_SUBNET_DELEGATE_STAKE_FACTOR_PERCENT, precision=3
+)
+
+ACTIVATION_REQUIREMENTS_TEXT = f"""📋 Activation requirements:
+
+1. Minimum nodes:
+   • Register at least {MIN_SUBNET_NODES} active/electable nodes
+
+2. Delegate stake:
+   • Total delegate stake across your nodes must meet the floating minimum
+     (~{DELEGATE_STAKE_FACTOR_DISPLAY} of total supply × node-count multiplier)
+
+3. Penalties:
+   • Subnet penalty count must stay at or below {MAX_SUBNET_PENALTY_COUNT}
+
+4. Timing:
+   • Make sure the minimum registration epochs have elapsed before retrying"""
+
+ACTIVATION_NEXT_STEPS_TEXT = """💡 Next Steps:
+
+• Register additional nodes if you're below the minimum
+• Delegate more stake (or attract delegations) to exceed the floating threshold
+• Resolve any penalties affecting the subnet before retrying
+• Retry activation once the conditions above are comfortably met"""
+
+
+# Read Handlers
+def registration_cost_handler():
+    """Handle subnet registration cost query."""
+    try:
+        client = get_client()
+
+        # Ensure client is connected and RPC is available
+        if not client.rpc:
+            raise RuntimeError(
+                "Client RPC layer not initialized. Connection may have failed."
+            )
+
+        with HTCLILoadingContext("Querying subnet registration cost..."):
+            current_cost = client.rpc.chain.get_subnet_registration_cost()
+            block_number = client.rpc.chain.get_block_number()
+            current_epoch = client.rpc.chain.get_current_epoch()
+
+        # Display - provide helpful message if cost is None
+        if current_cost is None:
+            print_error("Failed to query registration cost from blockchain.")
+            print_info(
+                "This may indicate a connection issue or the storage values are not set yet."
+            )
+        else:
+            from ...commands.chain.display import display_registration_cost
+
+            display_registration_cost(current_cost, block_number, current_epoch)
+
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def check_registration_cost_handler():
+    """Check subnet registration cost and compare with all wallet balances."""
+    try:
+        from ...ui.display import print_error, print_info, print_warning
+        from ...utils.wallet.crypto import list_keys
+
+        client = get_client()
+
+        print_info("💰 Fetching subnet registration cost...")
+        print_info("📡 Querying Network pallet storage values...")
+
+        # Get current registration cost
+        cost_wei = client.rpc.chain.get_subnet_registration_cost()
+
+        if cost_wei is None:
+            print_error("Failed to fetch registration cost from blockchain")
+            print_warning("\n💡 Possible causes:")
+            print_warning("  1. Network pallet storage values not initialized")
+            print_warning("  2. Blockchain connection issue")
+            print_warning("  3. Storage value names may have changed")
+            print_warning("\n📋 Required storage values:")
+            print_warning("  - Network::LastRegistrationCost")
+            print_warning("  - Network::MinRegistrationCost")
+            print_warning("  - Network::LastSubnetRegistrationBlock")
+            print_warning("  - Network::RegistrationCostDecayBlocks")
+            print_warning("  - Network::RegistrationCostAlpha")
+            print_warning("\n🔧 Check the logs above to see which value is missing")
+            return
+
+        cost_tensor = cost_wei / 1e18
+
+        # Get all coldkey wallets
+        all_wallets = list_keys()
+        coldkeys = [w for w in all_wallets if not w.get("is_hotkey", False)]
+
+        if not coldkeys:
+            from ...ui.display import print_warning
+
+            print_warning(
+                "No coldkey wallets found. Create one with: htcli wallet generate-coldkey"
+            )
+            return
+
+        print_info(f"📊 Checking {len(coldkeys)} coldkey wallet balances...")
+
+        # Fetch balances for all coldkeys with progress indicator
+        from ...ui.components import HTCLIProgress
+
+        wallet_data = []
+        with HTCLIProgress() as progress:
+            task = progress.add_task("Fetching balances...", total=len(coldkeys))
+
+            for wallet in coldkeys:
+                wallet_name = wallet["name"]
+                address = wallet.get("ss58_address")
+
+                progress.update(
+                    task,
+                    advance=1,
+                    description=f"Checking [bold]{wallet_name}[/bold]...",
+                )
+
+                try:
+                    balance_response = client.rpc.wallet.get_balance(address)
+                    if balance_response.success:
+                        balance_wei = balance_response.balance
+                        balance_tensor = balance_wei / 1e18
+                        sufficient = balance_wei >= cost_wei
+                        shortfall = (
+                            (cost_wei - balance_wei) / 1e18 if not sufficient else 0
+                        )
+
+                        wallet_data.append(
+                            {
+                                "name": wallet_name,
+                                "address": address,
+                                "balance": balance_tensor,
+                                "sufficient": sufficient,
+                                "shortfall": shortfall,
+                            }
+                        )
+                    else:
+                        wallet_data.append(
+                            {
+                                "name": wallet_name,
+                                "address": address,
+                                "balance": 0,
+                                "sufficient": False,
+                                "shortfall": cost_tensor,
+                                "error": "Failed to fetch balance",
+                            }
+                        )
+                except Exception as e:
+                    wallet_data.append(
+                        {
+                            "name": wallet_name,
+                            "address": address,
+                            "balance": 0,
+                            "sufficient": False,
+                            "shortfall": cost_tensor,
+                            "error": str(e),
+                        }
+                    )
+
+        # Display results
+        from .display import display_registration_cost_comparison
+
+        display_registration_cost_comparison(cost_tensor, wallet_data)
+
+    except Exception as e:
+        handle_substrate_error(e)
+
+
+def list_subnets_handler(
+    all_subnets: bool,
+    active_only: bool,
+    coldkey: Optional[str] = None,
+):
+    """Handle listing subnets with proper error handling and optional coldkey filtering."""
+    try:
+        client = get_client()
+
+        # Ensure connection is established
+        if not client.connect():
+            print_error("Failed to connect to blockchain")
+            return
+
+        # Normalize empty string from "--coldkey \"\"" into None to trigger prompting
+        # if isinstance(coldkey, str) and coldkey.strip() == "":
+        #     coldkey = None
+
+        # If no mode specified, default to listing all subnets
+        if not all_subnets:
+            # Default to all subnets when no parameters are provided
+            all_subnets = True
+
+        # Handle coldkey filtering
+        if coldkey:
+            # Resolve coldkey and fetch subnets with spinner
+            subnet_data = None
+            with HTCLILoadingContext("Resolving coldkey and fetching subnets..."):
+                original_coldkey = coldkey
+
+                # If coldkey looks like a wallet name, resolve to address
+                if not (coldkey.startswith("0x") or len(coldkey) in (48, 49)):
+                    # Treat as wallet name: resolve to its address if exists
+                    try:
+                        from ...utils.wallet.crypto import get_wallet_info_by_name
+
+                        info = get_wallet_info_by_name(coldkey, is_hotkey=False)
+                        # Prefer EVM address, fallback to ss58_address
+                        coldkey = (
+                            info.get("address") or info.get("ss58_address") or coldkey
+                        )
+                        logger.debug(
+                            f"Resolved wallet name '{original_coldkey}' to address '{coldkey}'"
+                        )
+                    except FileNotFoundError:
+                        # Wallet name not found - show error and exit
+                        print_error(f"Wallet '{coldkey}' not found")
+                        return
+                    except Exception as e:
+                        logger.warning(f"Error resolving wallet name '{coldkey}': {e}")
+                        # Leave as provided; will try to use as address
+
+                # Normalize Ethereum addresses to lowercase (addresses are case-insensitive)
+                if coldkey.startswith("0x"):
+                    coldkey = coldkey.lower()
+
+                # Get subnet IDs for this coldkey using efficient storage queries
+                subnet_ids = client.rpc.subnet.get_subnet_ids_for_coldkey(coldkey)
+
+                if not subnet_ids:
+                    # No subnets found - will show message after spinner clears
+                    subnet_data = []
+                else:
+                    # Fetch subnet info for the found subnet IDs
+                    subnets_info = []
+                    for subnet_id in sorted(subnet_ids):
+                        try:
+                            subnet_info = client.rpc.subnet.get_subnet_info(subnet_id)
+                            if subnet_info:
+                                subnets_info.append(subnet_info)
+                        except Exception as e:
+                            logger.warning(
+                                f"Failed to get subnet {subnet_id} info: {e}"
+                            )
+                            continue
+
+                    if subnets_info:
+                        # Convert SubnetInfo models to dicts for display
+                        subnet_data = []
+                        for subnet in subnets_info:
+                            # Use model_dump() to get all fields
+                            subnet_dict = subnet.model_dump()
+
+                            # Decode byte fields to strings
+                            for field in ["name", "repo", "description", "misc"]:
+                                if field in subnet_dict and isinstance(
+                                    subnet_dict[field], bytes
+                                ):
+                                    try:
+                                        decoded = subnet_dict[field].decode("utf-8")
+                                        subnet_dict[field] = decoded if decoded else ""
+                                    except:
+                                        subnet_dict[field] = ""
+
+                            # Convert state enum to string if needed
+                            if "state" in subnet_dict and not isinstance(
+                                subnet_dict["state"], str
+                            ):
+                                if hasattr(subnet_dict["state"], "value"):
+                                    subnet_dict["state"] = subnet_dict["state"].value
+                                elif hasattr(subnet_dict["state"], "name"):
+                                    subnet_dict["state"] = subnet_dict["state"].name
+
+                            subnet_data.append(subnet_dict)
+                    else:
+                        subnet_data = []
+
+            # Display results AFTER spinner is cleared
+            if subnet_data is None:
+                # Error case - already handled
+                pass
+            elif len(subnet_data) == 0:
+                # No subnets found - informational message
+                print_info(f"No subnets found for coldkey: {coldkey}")
+            else:
+                # Display the subnet list
+                display_subnet_list(subnet_data)
+        elif all_subnets:
+            # Use RPC method to get all subnets info
+            with HTCLILoadingContext("Fetching all subnets"):
+                all_subnets_models = client.rpc.subnet.get_all_subnets_info()
+
+            logger.info(f"Retrieved {len(all_subnets_models)} subnets from RPC")
+
+            # Convert Pydantic models to dicts for display - include all fields for comprehensive table
+            all_subnets_data = []
+            for subnet in all_subnets_models:
+                subnet_id = (
+                    subnet.id
+                    if hasattr(subnet, "id")
+                    else (
+                        subnet.get("id", "unknown")
+                        if isinstance(subnet, dict)
+                        else "unknown"
+                    )
+                )
+                logger.debug(f"Processing subnet ID: {subnet_id}")
+                # Use model_dump() to get all fields, then decode byte fields
+                subnet_dict = subnet.model_dump()
+
+                # Decode byte fields to strings
+                for field in ["name", "repo", "description", "misc"]:
+                    if field in subnet_dict and isinstance(subnet_dict[field], bytes):
+                        try:
+                            decoded = subnet_dict[field].decode("utf-8")
+                            subnet_dict[field] = decoded if decoded else ""
+                        except:
+                            subnet_dict[field] = ""
+
+                # Convert state enum to string if needed
+                state_value = subnet_dict.get("state")
+                if state_value and not isinstance(state_value, str):
+                    if hasattr(state_value, "value"):
+                        subnet_dict["state"] = state_value.value
+                    elif hasattr(state_value, "name"):
+                        subnet_dict["state"] = state_value.name
+                    else:
+                        subnet_dict["state"] = str(state_value)
+                elif not state_value:
+                    subnet_dict["state"] = "Unknown"
+
+                # Filter by active_only if specified
+                if active_only:
+                    state_str = subnet_dict.get("state", "").lower()
+                    if state_str != "active":
+                        continue  # Skip non-active subnets
+
+                all_subnets_data.append(subnet_dict)
+
+            # Display the subnet list
+            display_subnet_list(all_subnets_data)
+
+    except Exception as e:
+        # Use specific subnet error handling
+        if "subnet" in str(e).lower() or "network" in str(e).lower():
+            error = handle_substrate_error(e)
+            if not isinstance(
+                error, (SubnetError, SubnetActivationError, SubnetRegistrationError)
+            ):
+                error = SubnetError(f"Failed to list subnets: {str(e)}")
+            error.display()
+        else:
+            handle_and_display_error(e)
+
+
+def get_subnet_handler(subnet_id: Optional[int]):
+    """Handle getting subnet information with proper error handling."""
+    try:
+        if subnet_id is None:
+            subnet_id = prompt_get_subnet()
+
+        if subnet_id < 0:
+            raise ValueError("Subnet ID must be a non-negative integer")
+
+        client = get_client()
+        with HTCLILoadingContext(f"Fetching data for subnet {subnet_id}..."):
+            result = client.rpc.subnet.get_subnet_data(subnet_id)
+        display_subnet_info(result.data)
+    except ValueError as e:
+        # Handle validation errors
+        from ...ui.display import print_error
+
+        print_error(f"Invalid subnet ID: {str(e)}")
+    except Exception as e:
+        # Use specific subnet error handling
+        if "subnet" in str(e).lower() or "not found" in str(e).lower():
+            error = handle_substrate_error(e)
+            if not isinstance(
+                error, (SubnetError, SubnetActivationError, SubnetRegistrationError)
+            ):
+                error = SubnetError(f"Failed to get subnet {subnet_id}: {str(e)}")
+            error.display()
+        else:
+            handle_and_display_error(e)
+
+
+def list_nodes_handler(subnet_id: Optional[int]):
+    try:
+        if subnet_id is None:
+            subnet_id = prompt_list_nodes()
+        client = get_client()
+        with HTCLILoadingContext(f"Fetching nodes for subnet {subnet_id}..."):
+            result = client.rpc.subnet.get_subnet_nodes(subnet_id)
+        display_subnet_nodes(result["data"])
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def check_activation_handler(subnet_id: Optional[int]):
+    try:
+        if subnet_id is None:
+            subnet_id = prompt_check_activation()
+        client = get_client()
+        with HTCLILoadingContext(f"Checking activation for subnet {subnet_id}..."):
+            result = client.rpc.subnet.check_subnet_activation_requirements(subnet_id)
+        display_activation_requirements(result["data"])
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+# Write Handlers
+def register_subnet_handler(
+    coldkey: Optional[str] = None,
+    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,
+):
+    """Handle subnet registration with simplified flow."""
+    try:
+        # Collect missing parameters interactively
+        try:
+            # Note: Fields like churn_limit, queue_epochs, max_registered_nodes, etc.
+            # are NOT part of RegistrationSubnetData and are ignored during registration.
+            # They can be set separately after registration using owner update commands.
+            request = prompt_register_subnet(
+                name=name,
+                repo=repo,
+                description=description,
+                misc=misc,
+                min_stake=min_stake,
+                max_stake=max_stake,
+                max_cost=max_cost,
+                delegate_stake_percentage=delegate_stake_percentage,
+                initial_coldkeys=initial_coldkeys,
+                key_types=key_types,
+                bootnodes=bootnodes,
+            )
+        except (KeyboardInterrupt, typer.Abort):
+            # Re-raise cancellation exceptions to properly exit
+            raise
+        except Exception as ve:
+            # Handle Pydantic ValidationError specifically (must check before ValueError)
+            from pydantic import ValidationError
+
+            from ...errors.handlers import (
+                display_pydantic_validation_error,
+                get_validation_suggestions,
+            )
+
+            if isinstance(ve, ValidationError):
+                suggestions = get_validation_suggestions(ve)
+                display_pydantic_validation_error(
+                    ve,
+                    model_name="SubnetRegisterRequest",
+                    suggestions=suggestions,
+                )
+                return
+            # Handle other ValueError exceptions
+            elif isinstance(ve, ValueError):
+                from ...ui.display import print_error
+
+                print_error(f"Invalid input: {str(ve)}")
+                return
+            # Re-raise if it's not a handled exception
+            raise
+
+        # Get client and check connection status
+        from ...ui.display import print_error, print_info
+
+        client = get_client()
+
+        # Check if substrate connection is available
+        if not client.substrate:
+            print_error("Blockchain connection failed!")
+            raise RuntimeError("Not connected to blockchain")
+
+        # Test basic connectivity
+        try:
+            _ = client.substrate.properties
+        except Exception as conn_error:
+            print_error(f"Blockchain connectivity failed: {str(conn_error)}")
+            raise RuntimeError(
+                f"Blockchain connectivity failed: {str(conn_error)}"
+            ) from conn_error
+
+        # Get keypair using provided coldkey or prompt for it
+        if coldkey:
+            # Resolve coldkey from provided input (address or wallet name)
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            try:
+                wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+            except ValueError as e:
+                print_error(f"Failed to resolve coldkey '{coldkey}': {str(e)}")
+                print_error("Please provide a valid coldkey wallet name or address.")
+                raise
+        else:
+            # Fall back to interactive prompting
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        from ...ui.display import HTCLIConsole
+
+        console = HTCLIConsole()
+
+        # Query current registration cost
+        print_info("💰 Querying current subnet registration cost...")
+        current_cost = client.rpc.chain.get_subnet_registration_cost()
+
+        if current_cost:
+            cost_tensor = current_cost / 1e18
+            console.print("")
+            console.print("[bold yellow]" + "=" * 70 + "[/]")
+            console.print("[bold yellow]⚠️  SUBNET REGISTRATION COST NOTICE[/]")
+            console.print("[bold yellow]" + "=" * 70 + "[/]")
+            console.print(
+                f"[htcli.warning]Current registration cost: [bold]{cost_tensor:,.2f} TENSOR[/bold][/]"
+            )
+            console.print(
+                f"[htcli.info]Your max_cost: {request.max_cost / 1e18:,.2f} TENSOR[/]"
+            )
+            console.print("")
+
+            if request.max_cost < current_cost:
+                console.print(
+                    "[bold red]❌ ERROR: Your max_cost is LOWER than current cost![/]"
+                )
+                console.print(f"[htcli.error]Required: {cost_tensor:,.2f} TENSOR[/]")
+                console.print(
+                    f"[htcli.error]Your max: {request.max_cost / 1e18:,.2f} TENSOR[/]"
+                )
+                console.print("")
+                console.print("[htcli.info]💡 To proceed, increase --max-cost:[/]")
+                console.print(f"[htcli.info]   --max-cost {int(current_cost * 1.1)}[/]")
+                console.print("[bold yellow]" + "=" * 70 + "[/]")
+                print_error("Registration aborted due to insufficient max_cost")
+                return
+
+            console.print("[htcli.success]✅ Your max_cost is sufficient[/]")
+            console.print(f"[htcli.info]Expected cost: ~{cost_tensor:,.2f} TENSOR[/]")
+            console.print(
+                f"[htcli.info]Buffer: {((request.max_cost - current_cost) / 1e18):,.2f} TENSOR[/]"
+            )
+            console.print("[bold yellow]" + "=" * 70 + "[/]")
+            console.print("")
+
+            # Check balance using wallet's stored address (not keypair's derived address)
+            # NOTE: Commented out to let the chain return its own error
+            # user_balance = client.rpc.chain.get_account_balance(wallet_address)
+            # if user_balance is not None:
+            #     balance_tensor = user_balance / 1e18
+            #     console.print(
+            #         f"[htcli.info]Your balance: {balance_tensor:,.2f} TENSOR[/]"
+            #     )
+            #     if user_balance < current_cost:
+            #         console.print("[bold red]❌ INSUFFICIENT BALANCE![/]")
+            #         console.print(
+            #             f"[htcli.error]Required: {cost_tensor:,.2f} TENSOR[/]"
+            #         )
+            #         console.print(
+            #             f"[htcli.error]Your balance: {balance_tensor:,.2f} TENSOR[/]"
+            #         )
+            #         console.print(
+            #             f"[htcli.error]Shortfall: {(cost_tensor - balance_tensor):,.2f} TENSOR[/]"
+            #         )
+            #         console.print("")
+            #         console.print("[htcli.info]💡 To proceed with registration:[/htcli.info]")
+            #         console.print(f"[htcli.info]   • Transfer at least {(cost_tensor - balance_tensor):,.2f} TENSOR to this wallet[/htcli.info]")
+            #         console.print(f"[htcli.info]   • Or use a different wallet with sufficient balance[/htcli.info]")
+            #         return
+            #     console.print(
+            #         "[htcli.success]✅ Sufficient balance for registration[/]"
+            #     )
+            #     console.print("")
+
+        # Show registration summary before submitting
+        from ...ui.components import HTCLIPanel
+
+        console = HTCLIConsole()
+
+        # Format initial coldkeys info with max nodes per coldkey
+        initial_coldkeys_info = ""
+        if request.initial_coldkeys:
+            coldkey_count = len(request.initial_coldkeys)
+            total_max_nodes = sum(request.initial_coldkeys.values())
+
+            # Show summary: count and total max nodes
+            initial_coldkeys_info = f"{coldkey_count} coldkey(s)"
+
+            # If all have same value (default case), show simplified
+            unique_values = set(request.initial_coldkeys.values())
+            if len(unique_values) == 1:
+                max_nodes = list(unique_values)[0]
+                initial_coldkeys_info += f" (each can register up to {max_nodes} node{'s' if max_nodes > 1 else ''})"
+            else:
+                # Show range or detailed breakdown
+                min_nodes = min(request.initial_coldkeys.values())
+                max_nodes = max(request.initial_coldkeys.values())
+                if min_nodes == max_nodes:
+                    initial_coldkeys_info += f" (each can register up to {max_nodes} node{'s' if max_nodes > 1 else ''})"
+                else:
+                    initial_coldkeys_info += f" (can register {min_nodes}-{max_nodes} nodes each, total: {total_max_nodes} max nodes)"
+
+            initial_coldkeys_info += " (becomes permissionless after activation)"
+        else:
+            initial_coldkeys_info = "0 (becomes permissionless after activation)"
+
+        summary = f"""[htcli.accent]Subnet Registration Summary[/htcli.accent]
+
+[htcli.value]Name:[/htcli.value] {request.name}
+[htcli.value]Repository:[/htcli.value] {request.repo}
+[htcli.value]Min Stake:[/htcli.value] {request.min_stake / 1e18:,.2f} TENSOR
+[htcli.value]Max Stake:[/htcli.value] {request.max_stake / 1e18:,.2f} TENSOR
+[htcli.value]Max Cost:[/htcli.value] {request.max_cost / 1e18:,.2f} TENSOR
+[htcli.value]Initial Coldkeys:[/htcli.value] {initial_coldkeys_info}
+
+[htcli.info]💡 Submitting to blockchain...[/htcli.info]
+[htcli.info]💡 Note: Configuration fields (churn_limit, queue_epochs, etc.) can be set after registration using owner update commands.[/htcli.info]
+"""
+
+        panel = HTCLIPanel(
+            summary,
+            title="🚀 Submitting Subnet Registration",
+            border_style="htcli.info",
+            highlight=True,
+        )
+        panel.render(console.console)
+        console.print("")
+
+        with HTCLILoadingContext("Registering subnet on blockchain..."):
+            result = client.extrinsics.subnet.register_subnet(request, keypair=keypair)
+
+        # Display result with clear messages (not JSON)
+        if result.success:
+            resolved_block_number = getattr(result, "block_number", None)
+            block_hash = getattr(result, "block_hash", None)
+
+            if not resolved_block_number and block_hash:
+                try:
+                    resolved = client.rpc.chain.get_block_number(block_hash=block_hash)
+                    if resolved is not None:
+                        resolved_block_number = resolved
+                except Exception as fetch_error:
+                    logger.debug(
+                        f"Unable to resolve block number for hash {block_hash}: {fetch_error}"
+                    )
+
+            block_display = (
+                resolved_block_number if resolved_block_number else "Pending"
+            )
+            block_hash_display = block_hash or "N/A"
+
+            success_msg = f"""[htcli.success]✅ Subnet registered successfully![/htcli.success]
+
+[htcli.value]Subnet ID:[/htcli.value] {result.subnet_id if hasattr(result, "subnet_id") else "Pending"}
+[htcli.value]Transaction:[/htcli.value] {result.transaction_hash if hasattr(result, "transaction_hash") else "N/A"}
+[htcli.value]Block:[/htcli.value] {block_display}
+[htcli.value]Block Hash:[/htcli.value] {block_hash_display}
+
+[htcli.info]💡 Your subnet is now registered! You can now register nodes.[/htcli.info]
+"""
+            success_panel = HTCLIPanel(
+                success_msg,
+                title="🎉 Registration Complete",
+                border_style="htcli.success",
+                highlight=True,
+            )
+            success_panel.render(console.console)
+        else:
+            # Format error message beautifully like success message
+            error_msg = result.error if hasattr(result, "error") else "Unknown error"
+
+            # Parse blockchain error name for better display
+            error_name = "Registration Failed"
+            error_description = error_msg
+            if ":" in error_msg:
+                parts = error_msg.split(":", 1)
+                error_name = parts[0].strip()
+                error_description = parts[1].strip()
+
+            # Get helpful tips based on error type - COMPREHENSIVE ERROR COVERAGE
+            tips = []
+
+            # Balance and cost errors
+            if "NotEnoughBalanceToRegisterSubnet" in error_msg:
+                tips = [
+                    f"Your wallet needs approximately {request.max_cost / 1e18:,.2f} TENSOR",
+                    "Transfer more TENSOR to your wallet before retrying",
+                    "Or use a different wallet with sufficient balance",
+                ]
+            elif "CostGreaterThanMaxCost" in error_msg:
+                tips = [
+                    "The registration cost exceeds your specified max_cost",
+                    "Increase your --max-cost parameter (e.g., double it)",
+                    "Registration costs increase as more subnets are created",
+                ]
+
+            # Stake validation errors
+            elif "InvalidSubnetMinStake" in error_msg:
+                tips = [
+                    "min_stake must be between 100-250 TENSOR",
+                    f"Current value: {request.min_stake / 1e18:,.2f} TENSOR",
+                    "Use --min-stake flag with a value in this range",
+                ]
+            elif "InvalidSubnetMaxStake" in error_msg:
+                tips = [
+                    "max_stake must be ≤ 1000 TENSOR (NetworkMaxStakeBalance)",
+                    f"Current value: {request.max_stake / 1e18:,.2f} TENSOR",
+                    "Use --max-stake flag with a lower value",
+                ]
+            elif "InvalidSubnetStakeParameters" in error_msg:
+                tips = [
+                    "min_stake must be less than or equal to max_stake",
+                    f"Current min_stake: {request.min_stake / 1e18:,.2f} TENSOR",
+                    f"Current max_stake: {request.max_stake / 1e18:,.2f} TENSOR",
+                    "Adjust your stake parameters to satisfy: min_stake ≤ max_stake",
+                ]
+
+            # Delegate percentage errors
+            elif (
+                "InvalidMinDelegateStakePercentage" in error_msg
+                or "InvalidDelegateStakePercentage" in error_msg
+            ):
+                tips = [
+                    "delegate_percentage must be between 5% and 95%",
+                    "Use --delegate-percentage flag (e.g., 20 for 20%)",
+                    "This controls how much of emissions go to delegate stakers",
+                ]
+
+            # Node configuration errors
+            elif "InvalidMaxRegisteredNodes" in error_msg:
+                tips = [
+                    "max_registered_nodes must be between 1 and 64",
+                    f"Current value: {request.max_registered_nodes}",
+                    "Blockchain enforces MaxMaxRegisteredNodes = 64",
+                ]
+            elif "InvalidMaxSubnetNodePenalties" in error_msg:
+                tips = [
+                    "max_node_penalties must be within the allowed range",
+                    "Check MinMaxSubnetNodePenalties and MaxMaxSubnetNodePenalties",
+                    "Adjust --max-node-penalties parameter",
+                ]
+
+            # Bootnode errors
+            elif "BootnodesEmpty" in error_msg:
+                tips = [
+                    "At least one bootnode is required for subnet registration",
+                    "Use --bootnodes flag with valid multiaddr format",
+                    "Example: /dns4/bootnode.example.com/tcp/30333/p2p/12D3KooW...",
+                ]
+            elif "TooManyBootnodes" in error_msg:
+                tips = [
+                    "Too many bootnodes provided",
+                    "Maximum allowed bootnodes: 32 (MaxBootnodes)",
+                    "Remove some bootnode entries and retry",
+                ]
+
+            # Initial coldkeys errors
+            elif "InvalidSubnetRegistrationInitialColdkeys" in error_msg:
+                tips = [
+                    "Initial coldkeys validation failed",
+                    "Must provide at least 3 coldkeys (MinSubnetNodes = 3)",
+                    "Each coldkey must have at least 1 registration slot",
+                    "After subnet activation, it becomes permissionless automatically",
+                    "The whitelist is removed and anyone can register nodes",
+                ]
+
+            # Epoch configuration errors
+            elif "InvalidChurnLimit" in error_msg:
+                tips = [
+                    "churn_limit is outside the allowed range",
+                    "Must be between MinChurnLimit and MaxChurnLimit",
+                    "Adjust --churn-limit parameter",
+                ]
+            elif "InvalidRegistrationQueueEpochs" in error_msg:
+                tips = [
+                    "subnet_node_queue_epochs is outside the allowed range",
+                    "Must be between MinQueueEpochs and MaxQueueEpochs",
+                    "Adjust --registration-queue-epochs parameter",
+                ]
+            elif "InvalidIdleClassificationEpochs" in error_msg:
+                tips = [
+                    "idle_classification_epochs is outside the allowed range",
+                    "Must be between MinIdleClassificationEpochs and MaxIdleClassificationEpochs",
+                    "Adjust --activation-grace-epochs parameter",
+                ]
+            elif "InvalidIncludedClassificationEpochs" in error_msg:
+                tips = [
+                    "included_classification_epochs is outside the allowed range",
+                    "Must be between MinIncludedClassificationEpochs and MaxIncludedClassificationEpochs",
+                    "Adjust --included-classification-epochs parameter",
+                ]
+
+            # Uniqueness constraint errors
+            elif "SubnetNameExist" in error_msg:
+                tips = [
+                    "This subnet name is already taken by another subnet",
+                    "Choose a unique name for your subnet",
+                    "Use --name flag with a different value",
+                ]
+            elif "SubnetRepoExist" in error_msg:
+                tips = [
+                    "This repository URL is already registered to another subnet",
+                    "Use a different repository URL",
+                    "Each subnet must have a unique repository",
+                ]
+
+            # Capacity errors
+            elif "MaxSubnets" in error_msg:
+                tips = [
+                    "Maximum number of subnets reached on the network",
+                    "Wait for inactive subnets to be removed",
+                    "Inactive subnets are periodically cleaned up by the protocol",
+                ]
+
+            # Generic fallback
+            else:
+                tips = [
+                    "Check all parameter values are within valid ranges",
+                    "Ensure wallet has sufficient balance",
+                    "Verify network connection is stable",
+                    "Review the documentation for parameter requirements",
+                ]
+
+            # Build formatted error message
+            tips_text = "\n".join([f"   • {tip}" for tip in tips])
+
+            error_display = f"""[htcli.error]❌ {error_name}[/htcli.error]
+
+[htcli.value]Error:[/htcli.value] {error_description}
+
+[htcli.info]💡 How to fix this:[/htcli.info]
+{tips_text}
+"""
+
+            error_panel = HTCLIPanel(
+                error_display,
+                title="⚠️  Subnet Registration Failed",
+                border_style="htcli.error",
+                highlight=True,
+            )
+            error_panel.render(console.console)
+            console.print("")
+    except ValueError as e:
+        # Handle validation errors - provide more specific error messages
+        error_msg = str(e)
+        if "incompatible private key format" in error_msg:
+            from ...ui.display import print_error
+
+            print_error(f"Wallet format error: {error_msg}")
+            print_error(
+                "Please recreate your wallet or use a different wallet with compatible format."
+            )
+        else:
+            from ...ui.display import print_error
+
+            print_error(f"Validation error: {error_msg}")
+    except (KeyboardInterrupt, typer.Abort):
+        # Re-raise cancellation exceptions to properly exit
+        raise
+    except RuntimeError as e:
+        # Handle connection errors
+        from ...ui.display import print_error
+
+        print_error(f"Connection Error: {str(e)}")
+    except Exception as e:
+        # Check for wallet-related errors first and provide better context
+        error_str = str(e).lower()
+        if any(
+            pattern in error_str
+            for pattern in [
+                "wallet",
+                "key",
+                "signature",
+                "password",
+                "coldkey",
+                "hotkey",
+            ]
+        ):
+            from ...errors.handlers import handle_wallet_error
+            from ...ui.display import print_error
+
+            print_error(f"Wallet error: {str(e)}")
+            wallet_error = handle_wallet_error(e, operation="subnet registration")
+            wallet_error.display()
+            return
+
+        # Use specific subnet registration error handling
+        if "registration" in error_str or "subnet" in error_str:
+            error = handle_substrate_error(e)
+            if not isinstance(error, SubnetRegistrationError):
+                error = SubnetRegistrationError(f"Failed to register subnet: {str(e)}")
+            error.display()
+        else:
+            handle_and_display_error(e)
+
+
+def activate_subnet_handler(subnet_id: Optional[int], coldkey: Optional[str] = None):
+    """Handle subnet activation with proper error handling."""
+    result_dict = None  # Initialize to avoid UnboundLocalError
+    try:
+        if subnet_id is None:
+            subnet_id = prompt_activate_subnet()
+
+        if subnet_id < 0:
+            raise ValueError("Subnet ID must be a non-negative integer")
+
+        # Get signing wallet using provided coldkey or prompt for it
+        if coldkey:
+            # Resolve coldkey from provided input (address or wallet name)
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            try:
+                wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+            except ValueError as e:
+                from ...ui.display import print_error
+
+                print_error(f"Failed to resolve coldkey '{coldkey}': {str(e)}")
+                print_error("Please provide a valid coldkey wallet name or address.")
+                raise
+        else:
+            # Fall back to interactive prompting
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey", purpose="sign the activation transaction"
+            )
+
+        client = get_client()
+
+        # Ensure connection is established
+        if not client.connect():
+            from ...ui.display import print_error
+
+            print_error("Failed to connect to blockchain")
+            return
+
+        # Check if substrate connection is available
+        if not client.substrate:
+            from ...ui.display import print_error
+
+            print_error("Blockchain connection failed!")
+            raise RuntimeError("Not connected to blockchain")
+
+        # Check if extrinsics layer is initialized
+        if not client.extrinsics:
+            from ...ui.display import print_error
+
+            print_error("Extrinsics layer not initialized. Connection may have failed.")
+            raise RuntimeError("Extrinsics layer not available")
+
+        from ...models.requests.subnet import SubnetActivateRequest
+
+        request = SubnetActivateRequest(subnet_id=subnet_id)
+
+        with HTCLILoadingContext(f"Activating subnet {subnet_id}..."):
+            result = client.extrinsics.subnet.activate_subnet(request, keypair=keypair)
+
+        # Convert SimpleExtrinsicResponse to dict for display
+        result_dict = {
+            "message": result.message or f"Subnet {subnet_id} activated successfully",
+            "transaction_hash": result.transaction_hash,
+            "block_number": result.block_number,
+            "block_hash": result.block_hash,
+            "success": result.success,
+        }
+        if result.error:
+            result_dict["error"] = result.error
+
+        if not result.success:
+            error_msg = result_dict.get("error", "Activation failed")
+
+            # Handle specific activation errors with helpful messages
+            from ...ui.components import HTCLIPanel
+            from ...ui.display import HTCLIConsole, print_error, print_info
+
+            console = HTCLIConsole()
+
+            if "NotSubnetOwner" in error_msg:
+                error_panel = HTCLIPanel(
+                    f"Only the subnet owner can activate subnet {subnet_id}.\n\n"
+                    f"💡 Make sure you're using the coldkey wallet that registered this subnet.",
+                    title="❌ Permission Denied",
+                    border_style="htcli.error",
+                    highlight=True,
+                )
+                error_panel.render(console.console)
+                return
+            elif "InvalidSubnetId" in error_msg:
+                error_panel = HTCLIPanel(
+                    f"Subnet {subnet_id} does not exist.\n\n"
+                    f"💡 Check the subnet ID and try again.\n"
+                    f"   Use: htcli subnet list to see available subnets",
+                    title="❌ Invalid Subnet ID",
+                    border_style="htcli.error",
+                    highlight=True,
+                )
+                error_panel.render(console.console)
+                return
+            elif "SubnetActivatedAlready" in error_msg:
+                error_panel = HTCLIPanel(
+                    f"Subnet {subnet_id} is already activated.\n\n"
+                    f"💡 The subnet is already in active state.\n"
+                    f"   Use: htcli subnet info --subnet-id {subnet_id} to check subnet status",
+                    title="✅ Already Activated",
+                    border_style="htcli.info",
+                    highlight=True,
+                )
+                error_panel.render(console.console)
+                return
+            elif "MinSubnetRegistrationEpochsNotMet" in error_msg:
+                error_panel = HTCLIPanel(
+                    f"Subnet {subnet_id} cannot be activated yet.\n\n"
+                    f"⏱️  Minimum registration epochs not met.\n"
+                    f"   Subnets must wait a minimum number of epochs after registration before activation.\n\n"
+                    f"💡 Wait a few more epochs and try again once the minimum has elapsed.",
+                    title="⏳ Too Early to Activate",
+                    border_style="htcli.warning",
+                    highlight=True,
+                )
+                error_panel.render(console.console)
+                return
+            elif "SubnetActivationConditionsNotMetYet" in error_msg:
+                # Show error message and summarize requirements
+                error_panel = HTCLIPanel(
+                    f"Subnet {subnet_id} cannot be activated yet because activation conditions are not met.",
+                    title="⚠️  Activation Conditions Not Met",
+                    border_style="htcli.error",
+                    highlight=True,
+                )
+                error_panel.render(console.console)
+                console.print("")
+
+                requirements_panel = HTCLIPanel(
+                    ACTIVATION_REQUIREMENTS_TEXT,
+                    title="🧮 What You Need",
+                    border_style="htcli.info",
+                    highlight=True,
+                )
+                requirements_panel.render(console.console)
+
+                next_steps_panel = HTCLIPanel(
+                    ACTIVATION_NEXT_STEPS_TEXT,
+                    title="🚀 Getting Ready",
+                    border_style="htcli.info",
+                    highlight=True,
+                )
+                console.print("")
+                next_steps_panel.render(console.console)
+                return
+            elif "SubnetDeactivated" in error_msg:
+                # Subnet was removed during activation attempt (instead of being activated)
+                # This happens when activation conditions aren't met during enactment period
+                removal_reason = (
+                    getattr(result, "removal_reason", None) if result else None
+                )
+                reason_display = removal_reason or "activation conditions not met"
+
+                error_panel = HTCLIPanel(
+                    f"⚠️  Subnet {subnet_id} was **removed** instead of being activated.\n\n"
+                    f"📋 **Reason**: {reason_display}\n\n"
+                    f"This typically happens when:\n"
+                    f"  • The subnet didn't meet minimum node requirements\n"
+                    f"  • The subnet didn't have enough delegate stake\n"
+                    f"  • The enactment period expired\n\n"
+                    f"💡 To try again, you'll need to register a new subnet and ensure\n"
+                    f"   all activation requirements are met before the enactment deadline.",
+                    title="❌ Subnet Removed During Activation",
+                    border_style="htcli.error",
+                    highlight=True,
+                )
+                error_panel.render(console.console)
+                return
+            else:
+                # Generic error - show the error message
+                from ...ui.display import print_error
+
+                print_error(error_msg)
+            return
+
+        display_generic_success(result_dict)
+    except ValueError as e:
+        # Handle validation errors
+        from ...ui.display import print_error
+
+        print_error(f"Invalid subnet ID: {str(e)}")
+    except Exception as e:
+        # Use specific subnet activation error handling
+        error_msg = str(e)
+
+        from ...ui.components import HTCLIPanel
+        from ...ui.display import HTCLIConsole, print_error, print_info
+
+        console = HTCLIConsole()
+
+        # Handle specific activation errors with helpful messages
+        if "NotSubnetOwner" in error_msg:
+            error_panel = HTCLIPanel(
+                f"Only the subnet owner can activate subnet {subnet_id}.\n\n"
+                f"💡 Make sure you're using the coldkey wallet that registered this subnet.",
+                title="❌ Permission Denied",
+                border_style="htcli.error",
+                highlight=True,
+            )
+            error_panel.render(console.console)
+            return
+        elif "InvalidSubnetId" in error_msg:
+            error_panel = HTCLIPanel(
+                f"Subnet {subnet_id} does not exist.\n\n"
+                f"💡 Check the subnet ID and try again.\n"
+                f"   Use: htcli subnet list to see available subnets",
+                title="❌ Invalid Subnet ID",
+                border_style="htcli.error",
+                highlight=True,
+            )
+            error_panel.render(console.console)
+            return
+        elif "SubnetActivatedAlready" in error_msg:
+            error_panel = HTCLIPanel(
+                f"Subnet {subnet_id} is already activated.\n\n"
+                f"💡 The subnet is already in active state.\n"
+                f"   Use: htcli subnet info --subnet-id {subnet_id} to check subnet status",
+                title="✅ Already Activated",
+                border_style="htcli.info",
+                highlight=True,
+            )
+            error_panel.render(console.console)
+            return
+        elif "MinSubnetRegistrationEpochsNotMet" in error_msg:
+            error_panel = HTCLIPanel(
+                f"Subnet {subnet_id} cannot be activated yet.\n\n"
+                f"⏱️  Minimum registration epochs not met.\n"
+                f"   Subnets must wait a minimum number of epochs after registration before activation.\n\n"
+                f"💡 Wait a few more epochs and try again once the minimum has elapsed.",
+                title="⏳ Too Early to Activate",
+                border_style="htcli.warning",
+                highlight=True,
+            )
+            error_panel.render(console.console)
+            return
+        elif "SubnetActivationConditionsNotMetYet" in error_msg:
+            # Show error message and summarize requirements
+            error_panel = HTCLIPanel(
+                f"Subnet {subnet_id} cannot be activated yet because activation conditions are not met.",
+                title="⚠️  Activation Conditions Not Met",
+                border_style="htcli.error",
+                highlight=True,
+            )
+            error_panel.render(console.console)
+            console.print("")
+
+            requirements_panel = HTCLIPanel(
+                ACTIVATION_REQUIREMENTS_TEXT,
+                title="🧮 What You Need",
+                border_style="htcli.info",
+                highlight=True,
+            )
+            requirements_panel.render(console.console)
+
+            next_steps_panel = HTCLIPanel(
+                ACTIVATION_NEXT_STEPS_TEXT,
+                title="🚀 Getting Ready",
+                border_style="htcli.info",
+                highlight=True,
+            )
+            console.print("")
+            next_steps_panel.render(console.console)
+            return
+        else:
+            # Generic error - show the error message
+            from ...ui.display import print_error
+
+            print_error(error_msg)
+            handle_and_display_error(e)
+
+
+def pause_subnet_handler(subnet_id: Optional[int], coldkey: Optional[str] = None):
+    try:
+        if subnet_id is None:
+            subnet_id = prompt_pause_subnet()
+
+        # Get signing wallet using comprehensive wallet retrieval mechanism
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        # Create request object
+        from ...models.requests.subnet import SubnetActivateRequest
+
+        request = SubnetActivateRequest(subnet_id=subnet_id)
+
+        with HTCLILoadingContext(f"Pausing subnet {subnet_id}..."):
+            result = client.extrinsics.subnet.owner_pause_subnet(request, keypair)
+
+        # Check for errors in result
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Pause failed")
+            if handle_subnet_error(error_msg, subnet_id, "pause", client):
+                return
+
+        display_generic_success(result)
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "pause"):
+            handle_and_display_error(e)
+
+
+def unpause_subnet_handler(subnet_id: Optional[int], coldkey: Optional[str] = None):
+    try:
+        if subnet_id is None:
+            subnet_id = prompt_unpause_subnet()
+        # Get signing wallet using comprehensive wallet retrieval mechanism
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        # Create request object
+        from ...models.requests.subnet import SubnetActivateRequest
+
+        request = SubnetActivateRequest(subnet_id=subnet_id)
+
+        with HTCLILoadingContext(f"Unpausing subnet {subnet_id}..."):
+            result = client.extrinsics.subnet.owner_unpause_subnet(request, keypair)
+
+        # Check for errors in result
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Unpause failed")
+            if handle_subnet_error(error_msg, subnet_id, "unpause", client):
+                return
+
+        display_generic_success(result)
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "unpause"):
+            handle_and_display_error(e)
+
+
+# Owner Handlers
+def owner_update_handler(
+    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,
+    coldkey: Optional[str] = None,
+):
+    """Unified handler for updating subnet properties."""
+    try:
+
+        # Prompt for missing information
+        if subnet_id is None or (
+            new_name is None
+            and new_repo is None
+            and target_node_registrations is None
+            and node_burn_rate_alpha is None
+            and queue_immunity_epochs is None
+            and min_weight_decrease_threshold is None
+            and min_node_reputation is None
+            and absent_reputation_penalty is None
+            and included_reputation_boost is None
+            and below_min_weight_penalty is None
+            and non_attestor_penalty is None
+            and validator_absent_penalty is None
+            and validator_non_consensus_penalty is None
+            and non_consensus_attestor_penalty is None
+        ):
+            from .prompts import prompt_owner_update_extended
+
+            prompt_result = prompt_owner_update_extended(
+                subnet_id,
+                new_name,
+                new_repo,
+                target_node_registrations,
+                node_burn_rate_alpha,
+                queue_immunity_epochs,
+                min_weight_decrease_threshold,
+                min_node_reputation,
+                absent_reputation_penalty,
+                included_reputation_boost,
+                below_min_weight_penalty,
+                non_attestor_penalty,
+                validator_absent_penalty,
+                validator_non_consensus_penalty,
+                non_consensus_attestor_penalty,
+            )
+            subnet_id = prompt_result.get("subnet_id", subnet_id)
+            new_name = prompt_result.get("new_name", new_name)
+            new_repo = prompt_result.get("new_repo", new_repo)
+            target_node_registrations = prompt_result.get(
+                "target_node_registrations", target_node_registrations
+            )
+            node_burn_rate_alpha = prompt_result.get(
+                "node_burn_rate_alpha", node_burn_rate_alpha
+            )
+            queue_immunity_epochs = prompt_result.get(
+                "queue_immunity_epochs", queue_immunity_epochs
+            )
+            min_weight_decrease_threshold = prompt_result.get(
+                "min_weight_decrease_threshold", min_weight_decrease_threshold
+            )
+            min_node_reputation = prompt_result.get(
+                "min_node_reputation", min_node_reputation
+            )
+            absent_reputation_penalty = prompt_result.get(
+                "absent_reputation_penalty", absent_reputation_penalty
+            )
+            included_reputation_boost = prompt_result.get(
+                "included_reputation_boost", included_reputation_boost
+            )
+            below_min_weight_penalty = prompt_result.get(
+                "below_min_weight_penalty", below_min_weight_penalty
+            )
+            non_attestor_penalty = prompt_result.get(
+                "non_attestor_penalty", non_attestor_penalty
+            )
+            validator_absent_penalty = prompt_result.get(
+                "validator_absent_penalty", validator_absent_penalty
+            )
+            validator_non_consensus_penalty = prompt_result.get(
+                "validator_non_consensus_penalty", validator_non_consensus_penalty
+            )
+            non_consensus_attestor_penalty = prompt_result.get(
+                "non_consensus_attestor_penalty", non_consensus_attestor_penalty
+            )
+
+        # Validate subnet_id is provided
+        if subnet_id is None:
+            print_error("Subnet ID is required. Exiting.")
+            return
+
+        # Validate subnet_id is non-negative
+        if subnet_id < 0:
+            print_error("Subnet ID must be a non-negative integer.")
+            return
+
+        # Check if all update fields are None (nothing to change)
+        if (
+            new_name is None
+            and new_repo is None
+            and target_node_registrations is None
+            and node_burn_rate_alpha is None
+            and queue_immunity_epochs is None
+            and min_weight_decrease_threshold is None
+            and min_node_reputation is None
+            and absent_reputation_penalty is None
+            and included_reputation_boost is None
+            and below_min_weight_penalty is None
+            and non_attestor_penalty is None
+            and validator_absent_penalty is None
+            and validator_non_consensus_penalty is None
+            and non_consensus_attestor_penalty is None
+        ):
+            print_info("No fields were provided to be changed. Exiting.")
+            return
+
+        # Get signing wallet using comprehensive wallet retrieval mechanism
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        # Delegate all extrinsics to the client layer in one place
+        with HTCLILoadingContext(f"Updating subnet {subnet_id} parameters..."):
+            results = client.extrinsics.subnet.owner_update_parameters(
+                subnet_id=subnet_id,
+                new_name=new_name,
+                new_repo=new_repo,
+                target_node_registrations=target_node_registrations,
+                node_burn_rate_alpha=node_burn_rate_alpha,
+                queue_immunity_epochs=queue_immunity_epochs,
+                min_weight_decrease_threshold=min_weight_decrease_threshold,
+                min_node_reputation=min_node_reputation,
+                absent_reputation_penalty=absent_reputation_penalty,
+                included_reputation_boost=included_reputation_boost,
+                below_min_weight_penalty=below_min_weight_penalty,
+                non_attestor_penalty=non_attestor_penalty,
+                validator_absent_penalty=validator_absent_penalty,
+                validator_non_consensus_penalty=validator_non_consensus_penalty,
+                non_consensus_attestor_penalty=non_consensus_attestor_penalty,
+                keypair=keypair,
+            )
+
+        # Check for any errors and let the shared handler convert them
+        for field, result in results:
+            if isinstance(result, dict) and not result.get("success", False):
+                error_msg = result.get("error", "Update failed")
+                if handle_subnet_error(error_msg, subnet_id, f"update {field}", client):
+                    return
+
+        # Display consolidated results in a single panel
+        if results:
+            from .display import display_subnet_updates_summary
+
+            display_subnet_updates_summary(subnet_id, results, client)
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "update"):
+            handle_and_display_error(e)
+
+
+def owner_update_name_handler(
+    subnet_id: Optional[int], new_name: Optional[str], coldkey: Optional[str] = None
+):
+    try:
+        from ...models.requests.subnet import SubnetUpdateRequest
+
+        if subnet_id is None or new_name is None:
+            subnet_id, new_name = prompt_owner_update_name()
+
+        # Get signing wallet using comprehensive wallet retrieval mechanism
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        with HTCLILoadingContext(f"Updating name for subnet {subnet_id}..."):
+            request = SubnetUpdateRequest(subnet_id=subnet_id, value=new_name)
+            result = client.extrinsics.subnet.owner_update_name(
+                request, keypair=keypair
+            )
+
+        # Check for errors in result
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Update failed")
+            if handle_subnet_error(error_msg, subnet_id, "update name", client):
+                return
+
+        display_generic_success(result)
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "update name"):
+            handle_and_display_error(e)
+
+
+def owner_update_repo_handler(
+    subnet_id: Optional[int], new_repo: Optional[str], coldkey: Optional[str] = None
+):
+    try:
+        from ...models.requests.subnet import SubnetUpdateRequest
+
+        if subnet_id is None or new_repo is None:
+            subnet_id, new_repo = prompt_owner_update_repo()
+
+        # Get signing wallet using comprehensive wallet retrieval mechanism
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        with HTCLILoadingContext(f"Updating repo for subnet {subnet_id}..."):
+            request = SubnetUpdateRequest(subnet_id=subnet_id, value=new_repo)
+            result = client.extrinsics.subnet.owner_update_repo(
+                request, keypair=keypair
+            )
+
+        # Check for errors in result
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Update failed")
+            if handle_subnet_error(error_msg, subnet_id, "update repository", client):
+                return
+
+        display_generic_success(result)
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "update repository"):
+            handle_and_display_error(e)
+
+
+def owner_transfer_handler(
+    subnet_id: Optional[int], new_owner: Optional[str], coldkey: Optional[str] = None
+):
+    try:
+        if subnet_id is None or new_owner is None:
+            subnet_id, new_owner = prompt_owner_transfer()
+
+        # Resolve new_owner: can be either EVM address or wallet name
+        from ...utils.blockchain.validation import validate_address
+        from ...utils.wallet.crypto import get_wallet_info_by_name
+        from ...utils.wallet.crypto import public_key_to_evm_address
+
+        if not new_owner:
+            raise ValueError("New owner address cannot be empty")
+
+        new_owner = new_owner.strip()
+
+        # First, check if it's already a valid EVM address
+        if validate_address(new_owner):
+            # Normalize EVM addresses to lowercase (addresses are case-insensitive)
+            new_owner = new_owner.lower()
+        else:
+            # Try to resolve as wallet name
+            try:
+                wallet_info = get_wallet_info_by_name(
+                    new_owner,
+                    is_hotkey=False,  # Looking for coldkey wallets
+                )
+
+                if wallet_info:
+                    # Try to get EVM address from wallet info
+                    resolved_address = wallet_info.get(
+                        "evm_address"
+                    ) or wallet_info.get("address")
+
+                    # If we have an address, check if it's EVM format
+                    if resolved_address and validate_address(resolved_address):
+                        new_owner = resolved_address.lower()
+                    else:
+                        # Try to derive from public key
+                        public_key_hex = wallet_info.get("public_key")
+                        if public_key_hex:
+                            try:
+                                resolved_address = public_key_to_evm_address(
+                                    bytes.fromhex(public_key_hex)
+                                )
+                                if validate_address(resolved_address):
+                                    new_owner = resolved_address.lower()
+                                else:
+                                    raise ValueError(
+                                        f"Wallet '{new_owner}' does not have a valid EVM address. "
+                                        "Please use an EVM address (0x...) directly."
+                                    )
+                            except Exception as e:
+                                raise ValueError(
+                                    f"Failed to derive EVM address from wallet '{new_owner}': {str(e)}"
+                                ) from e
+                        else:
+                            raise ValueError(
+                                f"Wallet '{new_owner}' does not have a valid EVM address. "
+                                "Please use an EVM address (0x...) directly."
+                            )
+                else:
+                    raise ValueError(f"Wallet '{new_owner}' not found")
+            except FileNotFoundError:
+                raise ValueError(
+                    f"Wallet '{new_owner}' not found. "
+                    "Please provide either a wallet name or a valid EVM address (0x...)."
+                )
+            except ValueError:
+                # Re-raise ValueError as-is (already has good error message)
+                raise
+            except Exception as e:
+                raise ValueError(
+                    f"Failed to resolve new owner '{new_owner}': {str(e)}"
+                ) from e
+
+        # Get signing wallet using comprehensive wallet retrieval mechanism
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transfer transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        from ...models.requests.subnet import SubnetOwnershipTransferRequest
+
+        request = SubnetOwnershipTransferRequest(
+            subnet_id=subnet_id, new_owner=new_owner
+        )
+
+        # Use spinner with message that updates
+        from ...ui.components import HTCLILoadingContext
+
+        with HTCLILoadingContext(
+            f"Submitting transfer ownership transaction for subnet {subnet_id}..."
+        ):
+            result = client.extrinsics.subnet.transfer_subnet_ownership(
+                request, keypair=keypair
+            )
+
+        # Debug: Log what we received
+        from ...utils.logging import get_logger
+
+        logger = get_logger(__name__)
+        logger.debug(f"Transfer ownership result: {result}")
+        logger.debug(
+            f"Result keys: {list(result.keys()) if isinstance(result, dict) else 'not a dict'}"
+        )
+
+        # Extract transaction details first
+        tx_hash = result.get("transaction_hash") or result.get("extrinsic_hash")
+        block_number = result.get("block_number")
+        block_hash = result.get("block_hash")
+
+        # CRITICAL: Check for errors in result OR missing transaction details
+        # If success is False OR we don't have a transaction hash, treat as failure
+        if isinstance(result, dict) and (
+            not result.get("success", False) or not tx_hash
+        ):
+            raw_error = result.get(
+                "error", "Transfer failed - no transaction hash returned"
+            )
+            if not tx_hash and result.get("success", False):
+                raw_error = "Transaction submitted but no transaction hash returned. The transaction may have failed."
+
+            # Try to parse error if it's a string representation of a dict
+            error_msg = raw_error
+            if (
+                isinstance(raw_error, str)
+                and raw_error.startswith("{")
+                and "'code'" in raw_error
+            ):
+                try:
+                    import ast
+
+                    error_dict = ast.literal_eval(raw_error)
+                    if isinstance(error_dict, dict):
+                        # Extract the actual error message
+                        error_data = error_dict.get("data", "")
+                        error_message = error_dict.get("message", "")
+                        error_code = error_dict.get("code", "")
+                        error_msg = (
+                            f"{error_message}: {error_data}"
+                            if error_data
+                            else error_message
+                        )
+                        if error_code:
+                            error_msg = f"[Code {error_code}] {error_msg}"
+                except Exception:
+                    # If parsing fails, use original
+                    pass
+
+            # Log the original error before parsing
+            logger.error(
+                f"Transfer ownership failed - ORIGINAL ERROR (raw): {raw_error}"
+            )
+            logger.error(f"Transfer ownership failed - PARSED ERROR: {error_msg}")
+            logger.error(f"Full result dict: {result}")
+
+            # Display original error before parsing
+            from ...ui.display import HTCLIConsole as DebugConsole
+
+            debug_console = DebugConsole()
+            debug_console.print()
+            debug_console.print(
+                "[bold yellow]🔍 DEBUG: Original Error (before parsing):[/bold yellow]"
+            )
+            debug_console.print(f"[yellow]Raw: {raw_error}[/yellow]")
+            debug_console.print(f"[yellow]Parsed: {error_msg}[/yellow]")
+            debug_console.print(f"[dim]Full result: {result}[/dim]")
+            debug_console.print()
+
+            if handle_subnet_error(error_msg, subnet_id, "transfer ownership", client):
+                return
+            # If handle_subnet_error didn't handle it, raise an exception to prevent showing success
+            raise RuntimeError(error_msg)
+
+        # CRITICAL: Double-check we have transaction hash before showing success
+        # This is a safety check - we should NEVER show success without a transaction hash
+        if not tx_hash:
+            error_msg = "Transaction failed - no transaction hash returned. The transaction may have been rejected by the chain."
+            logger.error(f"Transfer ownership failed: {error_msg}")
+            if handle_subnet_error(error_msg, subnet_id, "transfer ownership", client):
+                return
+
+        # Try to resolve block number if missing but we have block hash
+        if not block_number and block_hash:
+            try:
+                resolved = client.rpc.chain.get_block_number(block_hash=block_hash)
+                if resolved is not None:
+                    block_number = resolved
+            except Exception:
+                pass  # Ignore if we can't resolve
+
+        # Display detailed success message with transaction details
+        from ...ui.components import HTCLIPanel
+        from ...ui.display import HTCLIConsole
+
+        console = HTCLIConsole()
+        console.print()  # Blank line after spinner
+
+        block_display = block_number if block_number is not None else "Pending"
+        block_hash_display = block_hash or "N/A"
+        tx_hash_display = tx_hash or "N/A"
+
+        success_msg = f"""[htcli.success]✅ Subnet {subnet_id} ownership transfer initiated successfully![/htcli.success]
+
+[htcli.value]Transaction Hash:[/htcli.value] {tx_hash_display}
+[htcli.value]Block Number:[/htcli.value] {block_display}
+[htcli.value]Block Hash:[/htcli.value] {block_hash_display}
+
+[htcli.info]💡 The new owner must accept the transfer using: htcli subnet accept --subnet-id {subnet_id}[/htcli.info]
+"""
+
+        panel = HTCLIPanel(
+            success_msg,
+            title="✅ Transfer Initiated",
+            border_style="htcli.success",
+            highlight=True,
+        )
+        panel.render()
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "transfer ownership"):
+            handle_and_display_error(e)
+
+
+def owner_accept_handler(subnet_id: Optional[int], coldkey: Optional[str] = None):
+    try:
+        if subnet_id is None:
+            subnet_id = prompt_owner_accept()
+        # Get signing wallet using comprehensive wallet retrieval mechanism
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the ownership acceptance transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        from ...models.requests.subnet import SubnetOwnershipAcceptRequest
+
+        request = SubnetOwnershipAcceptRequest(subnet_id=subnet_id)
+
+        # Use the same simple pattern as other handlers
+        # The spinner will handle any output suppression needed
+        with HTCLILoadingContext(
+            f"Submitting accept ownership transaction for subnet {subnet_id}..."
+        ):
+            result = client.extrinsics.subnet.accept_subnet_ownership(
+                request, keypair=keypair
+            )
+
+        # Debug: Log what we received
+        from ...utils.logging import get_logger
+
+        logger = get_logger(__name__)
+        logger.debug(f"Accept ownership result: {result}")
+        logger.debug(
+            f"Result keys: {list(result.keys()) if isinstance(result, dict) else 'not a dict'}"
+        )
+
+        # Extract transaction details first
+        tx_hash = result.get("transaction_hash") or result.get("extrinsic_hash")
+        block_number = result.get("block_number")
+        block_hash = result.get("block_hash")
+
+        logger.debug(
+            f"Extracted - tx_hash: {tx_hash}, block_number: {block_number}, block_hash: {block_hash}"
+        )
+
+        # CRITICAL: Check for errors in result OR missing transaction details
+        # If success is False OR we don't have a transaction hash, treat as failure
+        if isinstance(result, dict) and (
+            not result.get("success", False) or not tx_hash
+        ):
+            error_msg = result.get(
+                "error", "Accept failed - no transaction hash returned"
+            )
+            if not tx_hash and result.get("success", False):
+                error_msg = "Transaction submitted but no transaction hash returned. The transaction may have failed."
+
+            logger.error(f"Accept ownership failed: {error_msg}")
+            if handle_subnet_error(error_msg, subnet_id, "accept ownership", client):
+                return
+            # If handle_subnet_error didn't handle it, raise an exception to prevent showing success
+            raise RuntimeError(error_msg)
+
+        # CRITICAL: Double-check we have transaction hash before showing success
+        # This is a safety check - we should NEVER show success without a transaction hash
+        if not tx_hash:
+            error_msg = "Transaction failed - no transaction hash returned. The transaction may have been rejected by the chain."
+            logger.error(f"Accept ownership failed: {error_msg}")
+            if handle_subnet_error(error_msg, subnet_id, "accept ownership", client):
+                return
+            raise RuntimeError(error_msg)
+
+        # Try to resolve block number if missing but we have block hash
+        if not block_number and block_hash:
+            try:
+                resolved = client.rpc.chain.get_block_number(block_hash=block_hash)
+                if resolved is not None:
+                    block_number = resolved
+            except Exception:
+                pass  # Ignore if we can't resolve
+
+        # Display detailed success message with transaction details
+        from ...ui.components import HTCLIPanel
+        from ...ui.display import HTCLIConsole
+
+        console = HTCLIConsole()
+        console.print()  # Blank line after spinner
+
+        block_display = block_number if block_number is not None else "Pending"
+        block_hash_display = block_hash or "N/A"
+        tx_hash_display = tx_hash or "N/A"
+
+        success_msg = f"""[htcli.success]✅ Subnet {subnet_id} ownership accepted successfully![/htcli.success]
+
+[htcli.value]Transaction Hash:[/htcli.value] {tx_hash_display}
+[htcli.value]Block Number:[/htcli.value] {block_display}
+[htcli.value]Block Hash:[/htcli.value] {block_hash_display}
+
+[htcli.info]💡 You are now the owner of subnet {subnet_id}.[/htcli.info]
+"""
+
+        panel = HTCLIPanel(
+            success_msg,
+            title="✅ Ownership Accepted",
+            border_style="htcli.success",
+            highlight=True,
+        )
+        panel.render()
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "accept ownership"):
+            handle_and_display_error(e)
+
+
+def owner_remove_handler(subnet_id: Optional[int], coldkey: Optional[str] = None):
+    """Handle subnet removal with proper error handling and confirmation."""
+    try:
+        if subnet_id is None:
+            subnet_id = prompt_owner_remove()
+
+        if subnet_id < 0:
+            raise ValueError("Subnet ID must be a non-negative integer")
+
+        # Get signing wallet using comprehensive wallet retrieval mechanism
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        from ...models.requests.subnet import SubnetRemoveRequest
+
+        request = SubnetRemoveRequest(subnet_id=subnet_id)
+
+        with HTCLILoadingContext(f"Removing subnet {subnet_id}..."):
+            result = client.extrinsics.subnet.remove_subnet(request, keypair=keypair)
+
+        # Check for errors in result
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Remove failed")
+            if handle_subnet_error(error_msg, subnet_id, "remove", client):
+                return
+
+        display_generic_success(result)
+    except ValueError as e:
+        # Handle validation errors and user cancellation
+        if "cancelled" in str(e).lower():
+            from ...ui.display import HTCLIConsole
+
+            console = HTCLIConsole()
+            console.print("[htcli.warning]Subnet removal cancelled by user.[/]")
+        else:
+            from ...ui.display import print_error
+
+            print_error(f"Invalid subnet ID: {str(e)}")
+    except Exception as e:
+        error_msg = str(e)
+        # Use specific subnet error handling
+        if not handle_subnet_error(error_msg, subnet_id, "remove"):
+            if "subnet" in error_msg.lower() or "remove" in error_msg.lower():
+                error = handle_substrate_error(e)
+                if not isinstance(error, SubnetError):
+                    error = SubnetError(
+                        f"Failed to remove subnet {subnet_id}: {error_msg}"
+                    )
+                error.display()
+            else:
+                handle_and_display_error(e)
+
+
+def get_node_status_handler(subnet_id: Optional[int], node_id: Optional[int]):
+    """Handle getting node status with proper error handling."""
+    try:
+        if subnet_id is None:
+            from .prompts import prompt_get_subnet
+
+            subnet_id = prompt_get_subnet()
+
+        if node_id is None:
+            from ...ui.prompts import integer_prompt
+
+            node_id = integer_prompt(
+                "Enter the node ID within the subnet",
+                min_value=0,
+            )
+
+        with HTCLILoadingContext(
+            f"Fetching node {node_id} status from subnet {subnet_id}..."
+        ):
+            client = get_client()
+            result = client.rpc.node.get_subnet_node_info(subnet_id, node_id)
+
+        # Display the node status information
+        if result:
+            from ...ui.display import print_info, print_success
+
+            print_success(f"Node {node_id} status in subnet {subnet_id}")
+            classification = getattr(result, "classification", {}) or {}
+            status = classification.get("node_class", "Unknown")
+            print_info(f"Status: {status}")
+            print_info(f"Stake: {getattr(result, 'stake_balance', 0)}")
+            print_info(f"Reputation: {getattr(result, 'subnet_node_reputation', 0)}")
+        else:
+            from ...ui.display import print_error
+
+            print_error(f"Node {node_id} not found in subnet {subnet_id}")
+
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def get_node_staking_handler(subnet_id: Optional[int], node_id: Optional[int]):
+    """Handle getting node staking information with proper error handling."""
+    try:
+        if subnet_id is None:
+            from .prompts import prompt_get_subnet
+
+            subnet_id = prompt_get_subnet()
+
+        if node_id is None:
+            from ...ui.prompts import integer_prompt
+
+            node_id = integer_prompt(
+                "Enter the node ID within the subnet",
+                min_value=0,
+            )
+
+        client = get_client()
+        with HTCLILoadingContext(
+            f"Fetching staking info for node {node_id} in subnet {subnet_id}..."
+        ):
+            result = client.rpc.node.get_node_staking_info(subnet_id, node_id)
+
+        # Display the node staking information
+        if result.get("success"):
+            staking_data = result.get("data", {})
+            from ...ui.display import print_info, print_success
+
+            print_success(f"Node {node_id} staking info in subnet {subnet_id}")
+            print_info(f"Node Stake: {staking_data.get('node_stake', 0)}")
+            print_info(
+                f"Delegate Stake Shares: {staking_data.get('delegate_stake_shares', 0)}"
+            )
+            print_info(f"Reward Rate: {staking_data.get('reward_rate', 0)}")
+        else:
+            from ...ui.display import print_error
+
+            print_error(
+                f"Failed to get node staking info: {result.get('message', 'Unknown error')}"
+            )
+
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+# New RPC-based handlers
+def get_subnet_info_handler(subnet_id: Optional[int], all_subnets: bool = False):
+    """Handle getting subnet information using RPC."""
+    try:
+        if all_subnets and subnet_id is not None:
+            print_error("Cannot use --all with --subnet-id. Please choose one.")
+            return
+
+        if subnet_id is not None and subnet_id < 0:
+            display_subnet_info_rpc(None)
+            return
+
+        client = get_client()
+
+        if all_subnets:
+            with HTCLILoadingContext("Fetching information for all subnets..."):
+                subnet_models = client.rpc.subnet.get_all_subnets_info()
+
+            display_subnets_overview(subnet_models or [])
+            return
+
+        if subnet_id is None:
+            from ...utils.prompts import integer_prompt
+
+            subnet_id = integer_prompt("Enter subnet ID")
+
+        with HTCLILoadingContext(f"Fetching subnet {subnet_id} information..."):
+            subnet_model = client.rpc.subnet.get_subnet_info(subnet_id)
+
+        # Convert Pydantic model to dict for display
+        if subnet_model:
+            # Use Pydantic's model_dump() to get all fields as dict
+            subnet_dict = subnet_model.model_dump()
+
+            # Convert bytes fields to strings for display
+            if isinstance(subnet_dict.get("name"), bytes):
+                decoded_name = subnet_dict["name"].decode("utf-8")
+                subnet_dict["name"] = decoded_name if decoded_name else "Not set"
+            if isinstance(subnet_dict.get("description"), bytes):
+                decoded_desc = subnet_dict["description"].decode("utf-8")
+                subnet_dict["description"] = decoded_desc if decoded_desc else "Not set"
+            if isinstance(subnet_dict.get("repo"), bytes):
+                decoded_repo = subnet_dict["repo"].decode("utf-8")
+                subnet_dict["repo"] = decoded_repo if decoded_repo else "Not set"
+            if isinstance(subnet_dict.get("tags"), bytes):
+                decoded_tags = subnet_dict["tags"].decode("utf-8")
+                subnet_dict["tags"] = decoded_tags if decoded_tags else "Not set"
+
+            # Handle empty sets for initial_coldkeys
+            if (
+                isinstance(subnet_dict.get("initial_coldkeys"), set)
+                and not subnet_dict["initial_coldkeys"]
+            ):
+                subnet_dict["initial_coldkeys"] = (
+                    None  # Will display as "None" or can be handled by display function
+                )
+
+            # Convert state enum to string
+            if hasattr(subnet_dict.get("state"), "value"):
+                subnet_dict["state"] = subnet_dict["state"].value
+            elif hasattr(subnet_dict.get("state"), "name"):
+                subnet_dict["state"] = subnet_dict["state"].name
+
+            display_subnet_info_rpc(subnet_dict)
+        else:
+            display_subnet_info_rpc(None)
+
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def get_subnet_nodes_handler(subnet_id: Optional[int], coldkey: Optional[str] = None):
+    """Handle getting subnet nodes using RPC. Can filter by subnet_id or coldkey."""
+    try:
+        if subnet_id is not None and subnet_id < 0:
+            print_info(f"No nodes found for subnet {subnet_id}")
+            return
+
+        client = get_client()
+
+        # Prioritize subnet_id when both are provided to ensure consistency
+        # This ensures we get all nodes for the subnet, then filter by coldkey
+        if subnet_id is not None:
+            # Use subnet_id to get nodes
+            with HTCLILoadingContext(f"Fetching nodes for subnet {subnet_id}..."):
+                all_nodes = client.rpc.node.get_subnet_nodes_info(subnet_id)
+
+            # If coldkey is also provided, filter by coldkey
+            if coldkey:
+                # Resolve coldkey if it's a wallet name
+                if not (coldkey.startswith("0x") or len(coldkey) in (48, 49)):
+                    # Treat as wallet name: resolve to its address if exists
+                    try:
+                        from ...utils.wallet.crypto import get_wallet_info_by_name
+
+                        info = get_wallet_info_by_name(coldkey, is_hotkey=False)
+                        # Prefer EVM address, fallback to ss58_address
+                        coldkey = (
+                            info.get("evm_address")
+                            or info.get("address")
+                            or info.get("ss58_address")
+                            or coldkey
+                        )
+                    except FileNotFoundError:
+                        # Wallet name not found - show error and exit
+                        print_error(f"Wallet '{coldkey}' not found")
+                        return
+                    except Exception:
+                        # Leave as provided; RPC layer will handle format checks
+                        pass
+
+                # Normalize Ethereum addresses to lowercase (addresses are case-insensitive)
+                if coldkey and coldkey.startswith("0x"):
+                    coldkey = coldkey.lower()
+
+                # Filter nodes by coldkey
+                nodes_models = [
+                    node
+                    for node in all_nodes
+                    if node.coldkey and node.coldkey.lower() == coldkey.lower()
+                ]
+                logger.debug(
+                    f"After filtering by coldkey {coldkey}: {len(nodes_models)} nodes"
+                )
+            else:
+                nodes_models = all_nodes
+
+        elif coldkey:
+            # Only coldkey provided (no subnet_id) - use coldkey RPC method
+            # Resolve coldkey and fetch nodes
+            subnet_id = None  # Ensure subnet_id is defined for display logic
+            with HTCLILoadingContext("Resolving coldkey and fetching nodes..."):
+                # If coldkey looks like a wallet name, resolve to address
+                if not (coldkey.startswith("0x") or len(coldkey) in (48, 49)):
+                    # Treat as wallet name: resolve to its address if exists
+                    try:
+                        from ...utils.wallet.crypto import get_wallet_info_by_name
+
+                        info = get_wallet_info_by_name(coldkey, is_hotkey=False)
+                        # Prefer EVM address, fallback to ss58_address
+                        coldkey = (
+                            info.get("evm_address")
+                            or info.get("address")
+                            or info.get("ss58_address")
+                            or coldkey
+                        )
+                    except FileNotFoundError:
+                        # Wallet name not found - show error and exit
+                        print_error(f"Wallet '{coldkey}' not found")
+                        return
+                    except Exception:
+                        # Leave as provided; RPC layer will handle format checks
+                        pass
+
+                # Normalize Ethereum addresses to lowercase (addresses are case-insensitive)
+                if coldkey and coldkey.startswith("0x"):
+                    coldkey = coldkey.lower()
+
+                # Get nodes for this coldkey using RPC method
+                nodes_models = client.rpc.node.get_coldkey_subnet_nodes_info(coldkey)
+                logger.debug(
+                    f"Retrieved {len(nodes_models)} total nodes for coldkey {coldkey}"
+                )
+                if nodes_models:
+                    logger.debug(
+                        f"Node subnet IDs: {[node.subnet_id for node in nodes_models]}"
+                    )
+
+        else:
+            # Neither provided - prompt for subnet_id
+            from ...utils.prompts import integer_prompt
+
+            subnet_id = integer_prompt("Enter subnet ID")
+            with HTCLILoadingContext(f"Fetching nodes for subnet {subnet_id}..."):
+                nodes_models = client.rpc.node.get_subnet_nodes_info(subnet_id)
+
+        # Convert Pydantic models to dicts for display
+        nodes_data = []
+        for node in nodes_models:
+            try:
+                node_dict = {
+                    "id": node.subnet_node_id,
+                    "subnet_id": node.subnet_id,
+                    "coldkey": node.coldkey,
+                    "hotkey": node.hotkey,
+                    "stake_balance": node.stake_balance,
+                    "node_delegate_stake_balance": node.node_delegate_stake_balance,
+                    "status": (
+                        str(node.classification.get("node_class", "Unknown"))
+                        if isinstance(node.classification, dict)
+                        else str(node.classification)
+                    ),
+                }
+                nodes_data.append(node_dict)
+                logger.debug(
+                    f"Added node {node.subnet_node_id} (subnet {node.subnet_id}, coldkey {node.coldkey})"
+                )
+            except Exception as e:
+                logger.warning(
+                    f"Failed to convert node {getattr(node, 'subnet_node_id', 'unknown')} to dict: {e}"
+                )
+                continue
+
+        # Display nodes (empty list if none)
+        if not nodes_data:
+            if coldkey:
+                print_info(f"No nodes found for coldkey: {coldkey}")
+            else:
+                print_info(f"No nodes found for subnet {subnet_id}")
+            return
+
+        # Use subnet_id if provided, otherwise None (for coldkey listing)
+        display_subnet_nodes_rpc(nodes_data, subnet_id if subnet_id else None)
+
+    except Exception as e:
+        handle_and_display_node_error(e, operation="list")
+
+
+def get_bootnodes_handler(subnet_id: Optional[int]):
+    """Handle getting subnet bootnodes using RPC."""
+    try:
+        if subnet_id is None:
+            from ...utils.prompts import integer_prompt
+
+            subnet_id = integer_prompt("Enter subnet ID")
+
+        if subnet_id < 0:
+
+            class BootnodesData:
+                def __init__(self):
+                    self.bootnodes = []
+                    self.node_bootnodes = []
+
+            display_bootnodes_rpc(BootnodesData(), subnet_id)
+            return
+
+        client = get_client()
+
+        with HTCLILoadingContext(f"Fetching bootnodes for subnet {subnet_id}..."):
+            bootnodes_dict = client.rpc.subnet.get_subnet_bootnodes(subnet_id)
+
+        # Helper to decode bytes to string
+        def decode_list(items):
+            decoded_items = []
+            for item in items:
+                if isinstance(item, bytes):
+                    try:
+                        decoded_items.append(item.decode("utf-8"))
+                    except Exception:
+                        decoded_items.append(str(item))
+                else:
+                    decoded_items.append(str(item))
+            return decoded_items
+
+        # Wrap bootnodes in object for display (display expects .bootnodes and .node_bootnodes)
+        class BootnodesData:
+            def __init__(self, bootnodes, node_bootnodes):
+                self.bootnodes = decode_list(bootnodes)
+                self.node_bootnodes = decode_list(node_bootnodes)
+
+        # Extract lists from the dictionary returned by get_subnet_bootnodes
+        bootnodes_data = BootnodesData(
+            bootnodes_dict.get("bootnodes", []),
+            bootnodes_dict.get("node_bootnodes", []),
+        )
+
+        # Display bootnodes
+        display_bootnodes_rpc(bootnodes_data, subnet_id)
+
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def owner_set_emergency_validator_set_handler(
+    subnet_id: Optional[int], node_ids: Optional[str], coldkey: Optional[str] = None
+):
+    """Handle setting emergency validator set."""
+    try:
+        from .prompts import prompt_set_emergency_validator_set
+
+        if subnet_id is None or node_ids is None:
+            subnet_id, node_ids = prompt_set_emergency_validator_set(
+                subnet_id, node_ids
+            )
+
+        # Parse node IDs from comma-separated string
+        node_ids_list = [int(nid.strip()) for nid in node_ids.split(",") if nid.strip()]
+
+        # Get signing wallet
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        with HTCLILoadingContext(
+            f"Setting emergency validator set for subnet {subnet_id}..."
+        ):
+            result = client.extrinsics.subnet.owner_set_emergency_validator_set(
+                subnet_id=subnet_id, subnet_node_ids=node_ids_list, keypair=keypair
+            )
+
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Operation failed")
+            if handle_subnet_error(
+                error_msg, subnet_id, "set emergency validator set", client
+            ):
+                return
+
+        from .display import display_emergency_validator_set_result
+
+        display_emergency_validator_set_result(
+            result, subnet_id, node_ids_list, action="set"
+        )
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "set emergency validator set"):
+            handle_and_display_error(e)
+
+
+def owner_clear_emergency_validator_set_handler(
+    subnet_id: Optional[int], coldkey: Optional[str] = None
+):
+    """Handle clearing emergency validator set."""
+    try:
+        from .prompts import prompt_clear_emergency_validator_set
+
+        if subnet_id is None:
+            subnet_id = prompt_clear_emergency_validator_set()
+
+        # Get signing wallet
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        # Clear by setting empty list
+        with HTCLILoadingContext(
+            f"Clearing emergency validator set for subnet {subnet_id}..."
+        ):
+            result = client.extrinsics.subnet.owner_set_emergency_validator_set(
+                subnet_id=subnet_id, subnet_node_ids=[], keypair=keypair
+            )
+
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Operation failed")
+            if handle_subnet_error(
+                error_msg, subnet_id, "clear emergency validator set", client
+            ):
+                return
+
+        from .display import display_emergency_validator_set_result
+
+        display_emergency_validator_set_result(result, subnet_id, [], action="clear")
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(
+            error_msg, subnet_id, "clear emergency validator set"
+        ):
+            handle_and_display_error(e)
+
+
+def owner_add_bootnode_access_handler(
+    subnet_id: Optional[int], account: Optional[str], coldkey: Optional[str] = None
+):
+    """Handle adding bootnode access."""
+    try:
+        from .prompts import prompt_bootnode_access
+        from ...utils.blockchain.validation import validate_address
+        from ...utils.wallet.crypto import get_wallet_info_by_name
+        from ...utils.wallet.crypto import public_key_to_evm_address
+
+        if subnet_id is None or account is None:
+            subnet_id, account = prompt_bootnode_access(
+                subnet_id, account, action="add"
+            )
+
+        # Resolve account: can be either EVM address or wallet name
+        original_account = account
+        if account.startswith("0x"):
+            # Already an EVM address - normalize to lowercase
+            account = account.lower()
+        else:
+            # Try to resolve as wallet name
+            try:
+                wallet_info = get_wallet_info_by_name(
+                    account,
+                    is_hotkey=False,  # Looking for coldkey wallets
+                )
+
+                if wallet_info:
+                    # Try to get EVM address from wallet info
+                    resolved_address = wallet_info.get(
+                        "evm_address"
+                    ) or wallet_info.get("address")
+
+                    # If we have an address, check if it's EVM format
+                    if resolved_address and validate_address(resolved_address):
+                        account = resolved_address.lower()
+                    else:
+                        # Try to derive from public key
+                        public_key_hex = wallet_info.get("public_key")
+                        if public_key_hex:
+                            try:
+                                resolved_address = public_key_to_evm_address(
+                                    bytes.fromhex(public_key_hex)
+                                )
+                                if validate_address(resolved_address):
+                                    account = resolved_address.lower()
+                                else:
+                                    raise ValueError(
+                                        f"Wallet '{original_account}' does not have a valid EVM address. "
+                                        "Please use an EVM address (0x...) directly."
+                                    )
+                            except Exception as e:
+                                raise ValueError(
+                                    f"Failed to derive EVM address from wallet '{original_account}': {str(e)}"
+                                ) from e
+                        else:
+                            raise ValueError(
+                                f"Wallet '{original_account}' does not have a valid EVM address. "
+                                "Please provide an EVM address (0x...) directly."
+                            )
+                else:
+                    raise ValueError(f"Wallet '{account}' not found")
+            except FileNotFoundError:
+                raise ValueError(
+                    f"Wallet '{account}' not found. "
+                    "Please provide either a wallet name or a valid EVM address (0x...)."
+                )
+            except ValueError:
+                # Re-raise ValueError as-is
+                raise
+            except Exception as e:
+                # For other errors, provide helpful message
+                raise ValueError(
+                    f"Failed to resolve account '{account}': {str(e)}. "
+                    "Please provide either a wallet name or a valid EVM address (0x...)."
+                )
+
+        # Get signing wallet
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        with HTCLILoadingContext(f"Adding bootnode access for subnet {subnet_id}..."):
+            result = client.extrinsics.subnet.owner_add_bootnode_access(
+                subnet_id=subnet_id, new_account=account, keypair=keypair
+            )
+
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Operation failed")
+            if handle_subnet_error(error_msg, subnet_id, "add bootnode access", client):
+                return
+
+        from .display import display_bootnode_access_result
+
+        display_bootnode_access_result(result, subnet_id, account, action="add")
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "add bootnode access"):
+            handle_and_display_error(e)
+
+
+def owner_remove_bootnode_access_handler(
+    subnet_id: Optional[int], account: Optional[str], coldkey: Optional[str] = None
+):
+    """Handle removing bootnode access."""
+    try:
+        from .prompts import prompt_bootnode_access
+        from ...utils.blockchain.validation import validate_address
+        from ...utils.wallet.crypto import get_wallet_info_by_name
+        from ...utils.wallet.crypto import public_key_to_evm_address
+
+        if subnet_id is None or account is None:
+            subnet_id, account = prompt_bootnode_access(
+                subnet_id, account, action="remove"
+            )
+
+        # Resolve account: can be either EVM address or wallet name
+        original_account = account
+        if account.startswith("0x"):
+            # Already an EVM address - normalize to lowercase
+            account = account.lower()
+        else:
+            # Try to resolve as wallet name
+            try:
+                wallet_info = get_wallet_info_by_name(
+                    account,
+                    is_hotkey=False,  # Looking for coldkey wallets
+                )
+
+                if wallet_info:
+                    # Try to get EVM address from wallet info
+                    resolved_address = wallet_info.get(
+                        "evm_address"
+                    ) or wallet_info.get("address")
+
+                    # If we have an address, check if it's EVM format
+                    if resolved_address and validate_address(resolved_address):
+                        account = resolved_address.lower()
+                    else:
+                        # Try to derive from public key
+                        public_key_hex = wallet_info.get("public_key")
+                        if public_key_hex:
+                            try:
+                                resolved_address = public_key_to_evm_address(
+                                    bytes.fromhex(public_key_hex)
+                                )
+                                if validate_address(resolved_address):
+                                    account = resolved_address.lower()
+                                else:
+                                    raise ValueError(
+                                        f"Wallet '{original_account}' does not have a valid EVM address. "
+                                        "Please use an EVM address (0x...) directly."
+                                    )
+                            except Exception as e:
+                                raise ValueError(
+                                    f"Failed to derive EVM address from wallet '{original_account}': {str(e)}"
+                                ) from e
+                        else:
+                            raise ValueError(
+                                f"Wallet '{original_account}' does not have a valid EVM address. "
+                                "Please use an EVM address (0x...) directly."
+                            )
+                else:
+                    raise ValueError(f"Wallet '{account}' not found")
+            except FileNotFoundError:
+                raise ValueError(
+                    f"Wallet '{account}' not found. "
+                    "Please provide either a wallet name or a valid EVM address (0x...)."
+                )
+            except ValueError:
+                # Re-raise ValueError as-is
+                raise
+            except Exception as e:
+                # For other errors, provide helpful message
+                raise ValueError(
+                    f"Failed to resolve account '{account}': {str(e)}. "
+                    "Please provide either a wallet name or a valid EVM address (0x...)."
+                )
+
+        # Get signing wallet
+        if coldkey:
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        with HTCLILoadingContext(f"Removing bootnode access for subnet {subnet_id}..."):
+            result = client.extrinsics.subnet.owner_remove_bootnode_access(
+                subnet_id=subnet_id, remove_account=account, keypair=keypair
+            )
+
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Operation failed")
+            if handle_subnet_error(
+                error_msg, subnet_id, "remove bootnode access", client
+            ):
+                return
+
+        from .display import display_bootnode_access_result
+
+        display_bootnode_access_result(result, subnet_id, account, action="remove")
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "remove bootnode access"):
+            handle_and_display_error(e)
+
+
+def owner_add_bootnode_handler(
+    subnet_id: Optional[int],
+    bootnode_address: Optional[str],
+    coldkey: Optional[str] = None,
+):
+    """Handle adding a bootnode address."""
+    try:
+        from ...ui.prompts import integer_prompt, text_prompt
+        from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+        if subnet_id is None:
+            subnet_id = integer_prompt("Enter the Subnet ID (UID)", min_value=0)
+
+        if bootnode_address is None:
+            bootnode_address = text_prompt(
+                "Enter the bootnode address (multiaddr)", required=True
+            )
+
+        import re
+
+        # Regex for multiaddr: /ip4/IP/tcp/PORT/p2p/PEER_ID
+        multiaddr_pattern = r"^/(ip4|ip6)/([^/]+)/(tcp|udp)/(\d+)/p2p/([a-zA-Z0-9]+)$"
+        if not re.match(multiaddr_pattern, bootnode_address):
+            from ...ui.display import print_error
+
+            print_error("Invalid bootnode address format.")
+            print_error("Expected format: /ip4/<IP>/tcp/<PORT>/p2p/<PEER_ID>")
+            print_error("Example: /ip4/127.0.0.1/tcp/30333/p2p/12D3KooW...")
+            return
+
+        # Get keypair
+        if coldkey:
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        with HTCLILoadingContext(f"Adding bootnode to subnet {subnet_id}..."):
+            # Ensure it is a list for the client method
+            result = client.extrinsics.subnet.update_bootnodes(
+                subnet_id=subnet_id,
+                add_bootnodes=[bootnode_address],
+                remove_bootnodes=[],
+                keypair=keypair,
+            )
+
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Operation failed")
+            if handle_subnet_error(error_msg, subnet_id, "add bootnode", client):
+                return
+
+        from ...ui.display import print_success
+
+        print_success(f"Successfully added bootnode to subnet {subnet_id}")
+        if result.get("message"):
+            print_info(result["message"])
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "add bootnode"):
+            handle_and_display_error(e)
+
+
+def owner_remove_bootnode_handler(
+    subnet_id: Optional[int],
+    bootnode_address: Optional[str],
+    coldkey: Optional[str] = None,
+):
+    """Handle removing a bootnode address."""
+    try:
+        from ...ui.prompts import integer_prompt, text_prompt
+        from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+        if subnet_id is None:
+            subnet_id = integer_prompt("Enter the Subnet ID (UID)", min_value=0)
+
+        if bootnode_address is None:
+            bootnode_address = text_prompt(
+                "Enter the bootnode address (multiaddr) to remove", required=True
+            )
+
+        import re
+
+        # Regex for multiaddr: /ip4/IP/tcp/PORT/p2p/PEER_ID
+        multiaddr_pattern = r"^/(ip4|ip6)/([^/]+)/(tcp|udp)/(\d+)/p2p/([a-zA-Z0-9]+)$"
+        if not re.match(multiaddr_pattern, bootnode_address):
+            from ...ui.display import print_error
+
+            print_error("Invalid bootnode address format.")
+            print_error("Expected format: /ip4/<IP>/tcp/<PORT>/p2p/<PEER_ID>")
+            print_error("Example: /ip4/127.0.0.1/tcp/30333/p2p/12D3KooW...")
+            return
+
+        # Get keypair
+        if coldkey:
+            wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey)
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey",
+                purpose="sign the transaction",
+                only_existing_wallets=True,
+            )
+
+        client = get_client()
+        if not client.connect():
+            raise RuntimeError("Could not connect to blockchain")
+
+        with HTCLILoadingContext(f"Removing bootnode from subnet {subnet_id}..."):
+            # Ensure it is a list for the client method
+            result = client.extrinsics.subnet.update_bootnodes(
+                subnet_id=subnet_id,
+                add_bootnodes=[],
+                remove_bootnodes=[bootnode_address],
+                keypair=keypair,
+            )
+
+        if isinstance(result, dict) and not result.get("success", False):
+            error_msg = result.get("error", "Operation failed")
+            if handle_subnet_error(error_msg, subnet_id, "remove bootnode", client):
+                return
+
+        from ...ui.display import print_success
+
+        print_success(f"Successfully removed bootnode from subnet {subnet_id}")
+        if result.get("message"):
+            print_info(result["message"])
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_subnet_error(error_msg, subnet_id, "remove bootnode"):
+            handle_and_display_error(e)