htcli 1.1.0__py3-none-any.whl

src/htcli/commands/stake/handlers.py

@@ -0,0 +1,1902 @@
+"""
+Stake command handlers for RPC-based operations and extrinsic operations.
+"""
+
+from typing import Optional
+
+from ...dependencies import get_client
+from ...errors.handlers import handle_and_display_error
+from ...ui.components import HTCLILoadingContext
+from ...utils import retrieve_wallet_with_validation
+from .display import (
+    display_claim_result,
+    display_coldkey_stakes_rpc,
+    display_delegate_donate_result,
+    display_delegate_stake_result,
+    display_delegate_stakes_rpc,
+    display_delegate_swap_result,
+    display_delegate_transfer_result,
+    display_node_delegate_donate_result,
+    display_node_delegate_stake_result,
+    display_node_delegate_stakes_rpc,
+    display_node_delegate_swap_result,
+    display_node_delegate_transfer_result,
+    display_proof_of_stake_rpc,
+    display_stake_add_result,
+    display_stake_remove_result,
+    display_swap_node_to_subnet_result,
+    display_swap_queue_update_result,
+    display_swap_subnet_to_node_result,
+    display_swap_subnet_to_validator_result,
+    display_swap_validator_to_subnet_result,
+    display_validator_delegate_donate_result,
+    display_validator_delegate_stake_result,
+    display_validator_delegate_swap_result,
+    display_validator_delegate_transfer_result,
+)
+from .error_handling import handle_stake_error
+from .prompts import (
+    prompt_delegate_donate,
+    prompt_delegate_stake_add,
+    prompt_delegate_stake_remove,
+    prompt_delegate_swap,
+    prompt_delegate_transfer,
+    prompt_node_delegate_donate,
+    prompt_node_delegate_stake_add,
+    prompt_node_delegate_stake_remove,
+    prompt_node_delegate_swap,
+    prompt_node_delegate_transfer,
+    prompt_stake_add,
+    prompt_stake_claim,
+    prompt_stake_remove,
+    prompt_swap_node_to_subnet,
+    prompt_swap_queue_update,
+    prompt_swap_subnet_to_node,
+    prompt_swap_subnet_to_validator,
+    prompt_swap_validator_to_subnet,
+    prompt_validator_delegate_donate,
+    prompt_validator_delegate_stake_add,
+    prompt_validator_delegate_stake_remove,
+    prompt_validator_delegate_swap,
+    prompt_validator_delegate_transfer,
+)
+
+
+def get_coldkey_stakes_handler(coldkey: Optional[str]):
+    """Handle getting coldkey stakes using RPC.
+
+    Fetches all stake types:
+    - Direct stakes (from nodes owned by the coldkey)
+    - Delegate stakes (subnet delegate stakes)
+    - Node delegate stakes (node delegate stakes)
+    """
+    try:
+        if coldkey is None:
+            from ...utils.prompts import string_prompt
+
+            coldkey = string_prompt("Enter coldkey address")
+
+        try:
+            from ...utils.wallet.core import resolve_coldkey_address
+
+            resolved_coldkey = resolve_coldkey_address(coldkey)
+        except ValueError as e:
+            from ...ui.display import print_error
+
+            print_error(str(e))
+            return
+
+        client = get_client()
+
+        with HTCLILoadingContext(
+            f"Fetching all stakes for coldkey {resolved_coldkey}..."
+        ):
+            # Fetch all three types of stakes
+            direct_stakes_result = client.rpc.wallet.network_get_coldkey_stakes(
+                resolved_coldkey
+            )
+            delegate_stakes_result = client.rpc.wallet.network_get_delegate_stakes(
+                resolved_coldkey
+            )
+            node_delegate_stakes_result = (
+                client.rpc.wallet.network_get_node_delegate_stakes(resolved_coldkey)
+            )
+
+        # Display all stake types
+        has_any_stakes = False
+
+        # Display direct stakes
+        if direct_stakes_result.success and direct_stakes_result.data:
+            display_coldkey_stakes_rpc(direct_stakes_result.data, resolved_coldkey)
+            has_any_stakes = True
+
+        # Display delegate stakes
+        if delegate_stakes_result.success and delegate_stakes_result.data:
+            display_delegate_stakes_rpc(delegate_stakes_result.data, resolved_coldkey)
+            has_any_stakes = True
+
+        # Display node delegate stakes
+        if node_delegate_stakes_result.success and node_delegate_stakes_result.data:
+            display_node_delegate_stakes_rpc(
+                node_delegate_stakes_result.data, resolved_coldkey
+            )
+            has_any_stakes = True
+
+        # If no stakes found in any category
+        if not has_any_stakes:
+            from ...ui.colors import info
+            from ...ui.display import HTCLIConsole
+
+            console = HTCLIConsole()
+            console.print(info(f"No stakes found for coldkey {resolved_coldkey}"))
+            console.print(
+                info(
+                    "Checked: direct stakes, delegate stakes, and node delegate stakes"
+                )
+            )
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_stake_error(
+            error_msg,
+            None,
+            None,
+            "swap queue update",
+            client if "client" in locals() else None,
+        ):
+            handle_and_display_error(e)
+
+
+def get_delegate_stakes_handler(account: Optional[str]):
+    """Handle getting delegate stakes using RPC."""
+    try:
+        if account is None:
+            from ...utils.prompts import string_prompt
+
+            account = string_prompt("Enter account address")
+
+        try:
+            from ...utils.wallet.core import resolve_coldkey_address
+
+            account = resolve_coldkey_address(account)
+        except ValueError as e:
+            from ...ui.display import print_error
+
+            print_error(str(e))
+            return
+
+        client = get_client()
+
+        with HTCLILoadingContext(f"Fetching delegate stakes for account {account}..."):
+            result = client.rpc.wallet.network_get_delegate_stakes(account)
+
+        if result.success:
+            display_delegate_stakes_rpc(result.data, account)
+        else:
+            from ...ui.display import print_error
+
+            print_error(f"Failed to get delegate stakes: {result.message}")
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_stake_error(
+            error_msg,
+            None,
+            None,
+            "swap queue update",
+            client if "client" in locals() else None,
+        ):
+            handle_and_display_error(e)
+
+
+def get_node_delegate_stakes_handler(account: Optional[str]):
+    """Handle getting node delegate stakes using RPC."""
+    try:
+        if account is None:
+            from ...utils.prompts import string_prompt
+
+            account = string_prompt("Enter account address")
+
+        try:
+            from ...utils.wallet.core import resolve_coldkey_address
+
+            account = resolve_coldkey_address(account)
+        except ValueError as e:
+            from ...ui.display import print_error
+
+            print_error(str(e))
+            return
+
+        client = get_client()
+
+        with HTCLILoadingContext(
+            f"Fetching node delegate stakes for account {account}..."
+        ):
+            result = client.rpc.wallet.network_get_node_delegate_stakes(account)
+
+        if result.success:
+            display_node_delegate_stakes_rpc(result.data, account)
+        else:
+            from ...ui.display import print_error
+
+            print_error(f"Failed to get node delegate stakes: {result.message}")
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_stake_error(
+            error_msg,
+            None,
+            None,
+            "swap queue update",
+            client if "client" in locals() else None,
+        ):
+            handle_and_display_error(e)
+
+
+def verify_proof_of_stake_handler(
+    subnet_id: Optional[int], peer_id: Optional[str], min_class: Optional[int]
+):
+    """Handle checking proof of stake using RPC."""
+    try:
+        if subnet_id is None:
+            from ...utils.prompts import integer_prompt
+
+            subnet_id = integer_prompt("Enter subnet ID")
+
+        if peer_id is None:
+            from ...utils.prompts import string_prompt
+
+            peer_id = string_prompt("Enter peer ID")
+
+        if min_class is None:
+            from ...utils.prompts import integer_prompt
+
+            min_class = integer_prompt("Enter minimum class (0-3)")
+
+        client = get_client()
+
+        # Convert peer_id to bytes for RPC
+        if isinstance(peer_id, str):
+            # Convert string to bytes
+            peer_id_bytes = peer_id.encode("utf-8")
+        else:
+            # Already bytes
+            peer_id_bytes = peer_id
+
+        with HTCLILoadingContext(f"Verifying proof of stake for peer {peer_id}..."):
+            result = client.rpc.subnet.network_proof_of_stake(
+                subnet_id, peer_id_bytes, min_class
+            )
+
+        if result.success:
+            display_proof_of_stake_rpc(result.data, subnet_id, peer_id, min_class)
+        else:
+            from ...ui.display import print_error
+
+            print_error(f"Failed to verify proof of stake: {result.message}")
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_stake_error(
+            error_msg,
+            None,
+            None,
+            "swap queue update",
+            client if "client" in locals() else None,
+        ):
+            handle_and_display_error(e)
+
+
+# ============================================================================
+# EXTRINSIC HANDLERS - Write Operations
+# ============================================================================
+
+
+def add_stake_handler(
+    subnet_id: Optional[int] = None,
+    subnet_node_id: Optional[int] = None,
+    hotkey_address: Optional[str] = None,
+    stake_amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle adding stake to a node."""
+    try:
+        # STEP 1: Collect parameters via prompts
+        request = prompt_stake_add(
+            subnet_id=subnet_id,
+            node_id=subnet_node_id,
+            hotkey=hotkey_address,  # Pass hotkey_address as hotkey parameter
+            amount=stake_amount,
+        )
+
+        # STEP 2: 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 stake transaction"
+            )
+
+        # STEP 3: Execute via client
+        client = get_client()
+        with HTCLILoadingContext("Adding stake to node..."):
+            response = client.extrinsics.staking.add_stake(request, keypair)
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Stake add failed")
+            if handle_stake_error(
+                error_msg,
+                request.subnet_id,
+                request.subnet_node_id,
+                "add stake",
+                client,
+            ):
+                return
+
+        # STEP 4: Display result
+        display_stake_add_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if "request" in locals() else None
+            node_id_for_error = (
+                request.subnet_node_id if "request" in locals() else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "add stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def remove_stake_handler(
+    subnet_id: Optional[int] = None,
+    hotkey: Optional[str] = None,
+    stake_amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle removing stake from a node."""
+    try:
+        # STEP 1: Resolve coldkey FIRST so we can use it for hotkey disambiguation
+        if coldkey:
+            from ...ui.display import print_error
+            from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+            try:
+                wallet_name, keypair = resolve_coldkey_and_get_keypair(coldkey.strip())
+            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
+            except Exception as e:
+                raise RuntimeError(
+                    f"Unexpected error resolving coldkey '{coldkey}': {str(e)}"
+                ) from e
+        else:
+            wallet_name, keypair = retrieve_wallet_with_validation(
+                wallet_type="coldkey", purpose="sign the unstake transaction"
+            )
+
+        # STEP 2: Collect parameters (with coldkey context for hotkey disambiguation)
+        request = prompt_stake_remove(
+            subnet_id=subnet_id,
+            hotkey=hotkey,
+            amount=stake_amount,
+            coldkey_name=wallet_name,  # Pass coldkey name for hotkey disambiguation
+        )
+
+        # STEP 3: Execute
+        client = get_client()
+        with HTCLILoadingContext("Removing stake from node..."):
+            response = client.extrinsics.staking.remove_stake(request, keypair)
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Stake remove failed")
+            if handle_stake_error(
+                error_msg, request.subnet_id, None, "remove stake", client
+            ):
+                return
+
+        # STEP 4: Display
+        display_stake_remove_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if "request" in locals() else None
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg, subnet_id_for_error, None, "remove stake", client_for_error
+        ):
+            handle_and_display_error(e)
+
+
+def claim_handler(coldkey: Optional[str] = None, yes: bool = False):
+    """Handle claiming unbonded tokens."""
+    try:
+        # STEP 1: Prompt for confirmation (unless --yes flag is set)
+        if not yes:
+            prompt_stake_claim()
+
+        # STEP 2: 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 claim transaction"
+            )
+
+        # STEP 3: Execute
+        client = get_client()
+        with HTCLILoadingContext("Claiming unbonded tokens..."):
+            response = client.extrinsics.staking.claim_unbondings(keypair)
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Claim failed")
+            if handle_stake_error(error_msg, None, None, "claim", client):
+                return
+
+        # STEP 4: Display
+        display_claim_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        client_for_error = None
+        try:
+            client_for_error = client if "client" in locals() else None
+        except NameError:
+            pass
+
+        if not handle_stake_error(error_msg, None, None, "claim", client_for_error):
+            handle_and_display_error(e)
+
+
+def delegate_add_handler(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    stake_amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+    validator_id: Optional[int] = None,
+):
+    """Handle adding delegate stake to a subnet, validator, or specific node.
+
+    Routes to validator delegate if validator_id is provided, node delegate if
+    node_id is provided, otherwise subnet delegate.
+    """
+    try:
+        from ...ui.prompts import confirm_prompt
+
+        if validator_id is not None:
+            request = prompt_validator_delegate_stake_add(
+                validator_id=validator_id,
+                stake_amount=stake_amount,
+            )
+
+            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 validator delegate stake transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Adding delegate stake to validator..."):
+                response = client.extrinsics.staking.add_to_validator_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Validator delegate stake add failed")
+                if handle_stake_error(
+                    error_msg, None, None, "add validator delegate stake", client
+                ):
+                    return
+
+            display_validator_delegate_stake_result(response, operation="add")
+            return
+
+        # Determine if this is node-level or subnet-level delegation
+        is_node_delegation = node_id is not None
+
+        # If no node_id provided via CLI, ask if user wants node-level delegation
+        if not is_node_delegation and subnet_id is not None:
+            want_node = confirm_prompt(
+                "Do you want to delegate to a specific node?", default=False
+            )
+            if want_node:
+                is_node_delegation = True
+
+        if is_node_delegation:
+            # NODE DELEGATE PATH
+            request = prompt_node_delegate_stake_add(
+                subnet_id=subnet_id,
+                subnet_node_id=node_id,
+                stake_amount=stake_amount,
+            )
+
+            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 node delegate stake transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Adding delegate stake to node..."):
+                response = client.extrinsics.staking.add_to_node_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Node delegate stake add failed")
+                if handle_stake_error(
+                    error_msg,
+                    request.subnet_id,
+                    request.subnet_node_id,
+                    "add node delegate stake",
+                    client,
+                ):
+                    return
+
+            display_node_delegate_stake_result(response, operation="add")
+        else:
+            # SUBNET DELEGATE PATH
+            request = prompt_delegate_stake_add(
+                subnet_id=subnet_id,
+                stake_amount=stake_amount,
+            )
+
+            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 delegate stake transaction"
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Adding delegate stake to subnet..."):
+                response = client.extrinsics.staking.add_to_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Delegate stake add failed")
+                if handle_stake_error(
+                    error_msg, request.subnet_id, None, "add delegate stake", client
+                ):
+                    return
+
+            display_delegate_stake_result(response, operation="add")
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if "request" in locals() else None
+            node_id_for_error = (
+                getattr(request, "subnet_node_id", None)
+                if "request" in locals()
+                else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "add delegate stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def delegate_remove_handler(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    shares_to_remove: Optional[int] = None,
+    coldkey: Optional[str] = None,
+    validator_id: Optional[int] = None,
+):
+    """Handle removing delegate stake from a subnet, validator, or specific node.
+
+    Routes to validator delegate if validator_id is provided, node delegate if
+    node_id is provided, otherwise subnet delegate.
+    """
+    try:
+        from ...ui.prompts import confirm_prompt
+
+        if validator_id is not None:
+            request = prompt_validator_delegate_stake_remove(
+                validator_id=validator_id,
+                shares_to_remove=shares_to_remove,
+            )
+
+            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 validator delegate unstake transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Removing delegate stake from validator..."):
+                response = client.extrinsics.staking.remove_validator_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get(
+                    "error", "Validator delegate stake remove failed"
+                )
+                if handle_stake_error(
+                    error_msg, None, None, "remove validator delegate stake", client
+                ):
+                    return
+
+            display_validator_delegate_stake_result(response, operation="remove")
+            return
+
+        # Determine if this is node-level or subnet-level removal
+        is_node_delegation = node_id is not None
+
+        # If no node_id provided via CLI, ask if user wants node-level removal
+        if not is_node_delegation and subnet_id is not None:
+            want_node = confirm_prompt(
+                "Do you want to remove from a specific node?", default=False
+            )
+            if want_node:
+                is_node_delegation = True
+
+        if is_node_delegation:
+            # NODE DELEGATE PATH
+            request = prompt_node_delegate_stake_remove(
+                subnet_id=subnet_id,
+                subnet_node_id=node_id,
+                shares_to_remove=shares_to_remove,
+            )
+
+            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 node delegate unstake transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Removing delegate stake from node..."):
+                response = client.extrinsics.staking.remove_node_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Node delegate stake remove failed")
+                if handle_stake_error(
+                    error_msg,
+                    request.subnet_id,
+                    request.subnet_node_id,
+                    "remove node delegate stake",
+                    client,
+                ):
+                    return
+
+            display_node_delegate_stake_result(response, operation="remove")
+        else:
+            # SUBNET DELEGATE PATH
+            request = prompt_delegate_stake_remove(
+                subnet_id=subnet_id,
+                shares_to_remove=shares_to_remove,
+            )
+
+            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 delegate unstake transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Removing delegate stake from subnet..."):
+                response = client.extrinsics.staking.remove_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Delegate stake remove failed")
+                if handle_stake_error(
+                    error_msg, request.subnet_id, None, "remove delegate stake", client
+                ):
+                    return
+
+            display_delegate_stake_result(response, operation="remove")
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if "request" in locals() else None
+            node_id_for_error = (
+                getattr(request, "subnet_node_id", None)
+                if "request" in locals()
+                else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "remove delegate stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def node_delegate_add_handler(
+    subnet_id: Optional[int] = None,
+    subnet_node_id: Optional[int] = None,
+    stake_amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle adding delegate stake to a specific node."""
+    try:
+        # STEP 1: Collect parameters
+        request = prompt_node_delegate_stake_add(
+            subnet_id=subnet_id,
+            subnet_node_id=subnet_node_id,
+            stake_amount=stake_amount,
+        )
+
+        # STEP 2: Get signing wallet (use coldkey if provided)
+        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 node delegate stake transaction",
+            )
+
+        # STEP 3: Execute
+        client = get_client()
+        with HTCLILoadingContext("Adding delegate stake to node..."):
+            response = client.extrinsics.staking.add_to_node_delegate_stake(
+                request, keypair
+            )
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Node delegate stake add failed")
+            if handle_stake_error(
+                error_msg,
+                request.subnet_id,
+                request.subnet_node_id,
+                "add node delegate stake",
+                client,
+            ):
+                return
+
+        # STEP 4: Display
+        display_node_delegate_stake_result(response, operation="add")
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if "request" in locals() else None
+            node_id_for_error = (
+                request.subnet_node_id if "request" in locals() else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "add node delegate stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def node_delegate_remove_handler(
+    subnet_id: Optional[int] = None,
+    subnet_node_id: Optional[int] = None,
+    shares_to_remove: Optional[int] = None,
+):
+    """Handle removing delegate stake from a specific node."""
+    try:
+        # STEP 1: Collect parameters
+        request = prompt_node_delegate_stake_remove(
+            subnet_id=subnet_id,
+            subnet_node_id=subnet_node_id,
+            shares_to_remove=shares_to_remove,
+        )
+
+        # STEP 2: Get signing wallet
+        wallet_name, keypair = retrieve_wallet_with_validation(
+            wallet_type="coldkey", purpose="sign the node delegate unstake transaction"
+        )
+
+        # STEP 3: Execute
+        client = get_client()
+        with HTCLILoadingContext("Removing delegate stake from node..."):
+            response = client.extrinsics.staking.remove_node_delegate_stake(
+                request, keypair
+            )
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Node delegate stake remove failed")
+            if handle_stake_error(
+                error_msg,
+                request.subnet_id,
+                request.subnet_node_id,
+                "remove node delegate stake",
+                client,
+            ):
+                return
+
+        # STEP 4: Display
+        display_node_delegate_stake_result(response, operation="remove")
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if "request" in locals() else None
+            node_id_for_error = (
+                request.subnet_node_id if "request" in locals() else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "remove node delegate stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def node_delegate_swap_handler(
+    from_subnet_id: Optional[int] = None,
+    from_subnet_node_id: Optional[int] = None,
+    to_subnet_id: Optional[int] = None,
+    to_subnet_node_id: Optional[int] = None,
+    shares_to_swap: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle swapping node delegate shares between nodes."""
+    try:
+        request = prompt_node_delegate_swap(
+            from_subnet_id=from_subnet_id,
+            from_subnet_node_id=from_subnet_node_id,
+            to_subnet_id=to_subnet_id,
+            to_subnet_node_id=to_subnet_node_id,
+            shares_to_swap=shares_to_swap,
+        )
+
+        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 node delegate swap transaction"
+            )
+
+        client = get_client()
+        with HTCLILoadingContext("Submitting node delegate swap..."):
+            response = client.extrinsics.staking.swap_node_delegate_stake(
+                request, keypair
+            )
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Node delegate swap failed")
+            if handle_stake_error(
+                error_msg,
+                request.to_subnet_id,
+                request.to_subnet_node_id,
+                "swap node delegate stake",
+                client,
+            ):
+                return
+
+        display_node_delegate_swap_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = (
+                request.to_subnet_id if "request" in locals() else None
+            )
+            node_id_for_error = (
+                request.to_subnet_node_id if "request" in locals() else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "swap node delegate stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def node_delegate_transfer_handler(
+    subnet_id: Optional[int] = None,
+    subnet_node_id: Optional[int] = None,
+    to_account: Optional[str] = None,
+    shares_to_transfer: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle transferring node delegate shares."""
+    try:
+        request = prompt_node_delegate_transfer(
+            subnet_id=subnet_id,
+            subnet_node_id=subnet_node_id,
+            to_account=to_account,
+            shares_to_transfer=shares_to_transfer,
+        )
+
+        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 node delegate transfer transaction",
+            )
+
+        client = get_client()
+        with HTCLILoadingContext("Transferring node delegate shares..."):
+            response = client.extrinsics.staking.transfer_node_delegate_stake(
+                request, keypair
+            )
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Node delegate transfer failed")
+            if handle_stake_error(
+                error_msg,
+                request.subnet_id,
+                request.subnet_node_id,
+                "transfer node delegate stake",
+                client,
+            ):
+                return
+
+        display_node_delegate_transfer_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if "request" in locals() else None
+            node_id_for_error = (
+                request.subnet_node_id if "request" in locals() else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "transfer node delegate stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def node_delegate_donate_handler(
+    subnet_id: Optional[int] = None,
+    subnet_node_id: Optional[int] = None,
+    amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle donating to node delegate stake pool."""
+    try:
+        request = prompt_node_delegate_donate(
+            subnet_id=subnet_id,
+            subnet_node_id=subnet_node_id,
+            amount=amount,
+        )
+
+        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 node delegate donation transaction",
+            )
+
+        client = get_client()
+        with HTCLILoadingContext("Submitting node delegate donation..."):
+            response = client.extrinsics.staking.donate_node_delegate_stake(
+                request, keypair
+            )
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Node delegate donation failed")
+            if handle_stake_error(
+                error_msg,
+                request.subnet_id,
+                request.subnet_node_id,
+                "donate node delegate stake",
+                client,
+            ):
+                return
+
+        display_node_delegate_donate_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if "request" in locals() else None
+            node_id_for_error = (
+                request.subnet_node_id if "request" in locals() else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "donate node delegate stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def swap_node_to_subnet_handler(
+    from_subnet_id: Optional[int] = None,
+    from_subnet_node_id: Optional[int] = None,
+    to_subnet_id: Optional[int] = None,
+    shares_to_swap: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle swap from node delegate stake to subnet delegate stake."""
+    try:
+        request = prompt_swap_node_to_subnet(
+            from_subnet_id=from_subnet_id,
+            from_subnet_node_id=from_subnet_node_id,
+            to_subnet_id=to_subnet_id,
+            shares_to_swap=shares_to_swap,
+        )
+
+        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 swap transaction"
+            )
+
+        client = get_client()
+        with HTCLILoadingContext("Submitting node → subnet swap..."):
+            response = client.extrinsics.staking.swap_from_node_to_subnet(
+                request, keypair
+            )
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Node to subnet swap failed")
+            if handle_stake_error(
+                error_msg, request.to_subnet_id, None, "swap node to subnet", client
+            ):
+                return
+
+        display_swap_node_to_subnet_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = (
+                request.to_subnet_id if "request" in locals() else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            None,
+            "swap node to subnet",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def swap_subnet_to_node_handler(
+    from_subnet_id: Optional[int] = None,
+    to_subnet_id: Optional[int] = None,
+    to_subnet_node_id: Optional[int] = None,
+    shares_to_swap: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle swap from subnet delegate stake to node delegate stake."""
+    try:
+        request = prompt_swap_subnet_to_node(
+            from_subnet_id=from_subnet_id,
+            to_subnet_id=to_subnet_id,
+            to_subnet_node_id=to_subnet_node_id,
+            shares_to_swap=shares_to_swap,
+        )
+
+        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 swap transaction"
+            )
+
+        client = get_client()
+        with HTCLILoadingContext("Submitting subnet → node swap..."):
+            response = client.extrinsics.staking.swap_from_subnet_to_node(
+                request, keypair
+            )
+
+        # Check for errors in result
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Subnet to node swap failed")
+            if handle_stake_error(
+                error_msg,
+                request.to_subnet_id,
+                request.to_subnet_node_id,
+                "swap subnet to node",
+                client,
+            ):
+                return
+
+        display_swap_subnet_to_node_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = (
+                request.to_subnet_id if "request" in locals() else None
+            )
+            node_id_for_error = (
+                request.to_subnet_node_id if "request" in locals() else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "swap subnet to node",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def swap_validator_to_subnet_handler(
+    from_validator_id: Optional[int] = None,
+    to_subnet_id: Optional[int] = None,
+    shares_to_swap: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle swap from validator delegate stake to subnet delegate stake."""
+    try:
+        request = prompt_swap_validator_to_subnet(
+            from_validator_id=from_validator_id,
+            to_subnet_id=to_subnet_id,
+            shares_to_swap=shares_to_swap,
+        )
+
+        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 validator to subnet swap transaction",
+            )
+
+        client = get_client()
+        with HTCLILoadingContext("Submitting validator → subnet swap..."):
+            response = client.extrinsics.staking.swap_from_validator_to_subnet(
+                request, keypair
+            )
+
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Validator to subnet swap failed")
+            if handle_stake_error(
+                error_msg,
+                request.to_subnet_id,
+                None,
+                "swap validator to subnet",
+                client,
+            ):
+                return
+
+        display_swap_validator_to_subnet_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = (
+                request.to_subnet_id if "request" in locals() else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            None,
+            "swap validator to subnet",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def swap_subnet_to_validator_handler(
+    from_subnet_id: Optional[int] = None,
+    to_validator_id: Optional[int] = None,
+    shares_to_swap: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle swap from subnet delegate stake to validator delegate stake."""
+    try:
+        request = prompt_swap_subnet_to_validator(
+            from_subnet_id=from_subnet_id,
+            to_validator_id=to_validator_id,
+            shares_to_swap=shares_to_swap,
+        )
+
+        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 subnet to validator swap transaction",
+            )
+
+        client = get_client()
+        with HTCLILoadingContext("Submitting subnet → validator swap..."):
+            response = client.extrinsics.staking.swap_from_subnet_to_validator(
+                request, keypair
+            )
+
+        if isinstance(response, dict) and not response.get("success", False):
+            error_msg = response.get("error", "Subnet to validator swap failed")
+            if handle_stake_error(
+                error_msg,
+                request.from_subnet_id,
+                None,
+                "swap subnet to validator",
+                client,
+            ):
+                return
+
+        display_swap_subnet_to_validator_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = (
+                request.from_subnet_id if "request" in locals() else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            None,
+            "swap subnet to validator",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def swap_queue_update_handler(
+    queue_id: Optional[int] = None,
+    new_call_json: Optional[str] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle updating a queued swap entry."""
+    try:
+        request = prompt_swap_queue_update(
+            queue_id=queue_id,
+            new_call_json=new_call_json,
+        )
+
+        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 swap queue update"
+            )
+
+        client = get_client()
+        with HTCLILoadingContext("Updating swap queue entry..."):
+            response = client.extrinsics.staking.update_swap_queue(request, keypair)
+
+        display_swap_queue_update_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        if not handle_stake_error(
+            error_msg,
+            None,
+            None,
+            "swap queue update",
+            client if "client" in locals() else None,
+        ):
+            handle_and_display_error(e)
+
+
+def delegate_swap_handler(
+    from_subnet_id: Optional[int] = None,
+    from_node_id: Optional[int] = None,
+    to_subnet_id: Optional[int] = None,
+    to_node_id: Optional[int] = None,
+    shares: Optional[int] = None,
+    coldkey: Optional[str] = None,
+    from_validator_id: Optional[int] = None,
+    to_validator_id: Optional[int] = None,
+):
+    """Handle swapping delegate stake between subnets, validators, or nodes.
+
+    Routes to validator delegate swap if validator IDs are provided, node delegate
+    swap if node IDs are provided, otherwise subnet delegate swap.
+    """
+    try:
+        from ...ui.prompts import confirm_prompt
+
+        if from_validator_id is not None or to_validator_id is not None:
+            request = prompt_validator_delegate_swap(
+                from_validator_id=from_validator_id,
+                to_validator_id=to_validator_id,
+                shares_to_swap=shares,
+            )
+
+            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 validator delegate swap transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Swapping validator delegate stake..."):
+                response = client.extrinsics.staking.swap_validator_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Validator delegate swap failed")
+                if handle_stake_error(
+                    error_msg, None, None, "swap validator delegate stake", client
+                ):
+                    return
+
+            display_validator_delegate_swap_result(response)
+            return
+
+        # Determine if this is node-level or subnet-level swap
+        is_node_swap = from_node_id is not None or to_node_id is not None
+
+        # If no node IDs provided via CLI, ask if user wants node-level swap
+        if not is_node_swap and from_subnet_id is not None:
+            want_node = confirm_prompt(
+                "Do you want to swap between specific nodes?", default=False
+            )
+            if want_node:
+                is_node_swap = True
+
+        if is_node_swap:
+            # NODE DELEGATE SWAP PATH
+            request = prompt_node_delegate_swap(
+                from_subnet_id=from_subnet_id,
+                from_subnet_node_id=from_node_id,
+                to_subnet_id=to_subnet_id,
+                to_subnet_node_id=to_node_id,
+                shares_to_swap=shares,
+            )
+
+            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 node delegate swap transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Swapping node delegate stake..."):
+                response = client.extrinsics.staking.swap_node_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Node delegate swap failed")
+                if handle_stake_error(
+                    error_msg,
+                    request.to_subnet_id,
+                    request.to_subnet_node_id,
+                    "swap node delegate stake",
+                    client,
+                ):
+                    return
+
+            display_node_delegate_swap_result(response)
+        else:
+            # SUBNET DELEGATE SWAP PATH
+            request = prompt_delegate_swap(
+                from_subnet_id=from_subnet_id,
+                to_subnet_id=to_subnet_id,
+                shares=shares,
+            )
+
+            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 delegate swap transaction"
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Swapping delegate stake between subnets..."):
+                response = client.extrinsics.staking.swap_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Delegate swap failed")
+                if handle_stake_error(
+                    error_msg, request.to_subnet_id, None, "swap delegate stake", client
+                ):
+                    return
+
+            display_delegate_swap_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = (
+                request.to_subnet_id if "request" in locals() else None
+            )
+            node_id_for_error = (
+                getattr(request, "to_subnet_node_id", None)
+                if "request" in locals()
+                else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "swap delegate stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def delegate_transfer_handler(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    to_account: Optional[str] = None,
+    shares: Optional[int] = None,
+    coldkey: Optional[str] = None,
+    validator_id: Optional[int] = None,
+):
+    """Handle transferring delegate stake to another account.
+
+    Routes to validator delegate if validator_id is provided, node delegate if
+    node_id is provided, otherwise subnet delegate.
+    """
+    try:
+        from ...ui.prompts import confirm_prompt
+
+        if validator_id is not None:
+            request = prompt_validator_delegate_transfer(
+                validator_id=validator_id,
+                to_account=to_account,
+                shares_to_transfer=shares,
+            )
+
+            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 validator delegate transfer transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Transferring validator delegate stake..."):
+                response = client.extrinsics.staking.transfer_validator_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Validator delegate transfer failed")
+                if handle_stake_error(
+                    error_msg, None, None, "transfer validator delegate stake", client
+                ):
+                    return
+
+            display_validator_delegate_transfer_result(response)
+            return
+
+        # Determine if this is node-level or subnet-level transfer
+        is_node_transfer = node_id is not None
+
+        # If no node_id provided via CLI, ask if user wants node-level transfer
+        if not is_node_transfer and subnet_id is not None:
+            want_node = confirm_prompt(
+                "Do you want to transfer from a specific node?", default=False
+            )
+            if want_node:
+                is_node_transfer = True
+
+        if is_node_transfer:
+            # NODE DELEGATE TRANSFER PATH
+            request = prompt_node_delegate_transfer(
+                subnet_id=subnet_id,
+                subnet_node_id=node_id,
+                to_account=to_account,
+                shares_to_transfer=shares,
+            )
+
+            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 node delegate transfer transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Transferring node delegate stake..."):
+                response = client.extrinsics.staking.transfer_node_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Node delegate transfer failed")
+                if handle_stake_error(
+                    error_msg,
+                    request.subnet_id,
+                    request.subnet_node_id,
+                    "transfer node delegate stake",
+                    client,
+                ):
+                    return
+
+            display_node_delegate_transfer_result(response)
+        else:
+            # SUBNET DELEGATE TRANSFER PATH
+            request = prompt_delegate_transfer(
+                subnet_id=subnet_id,
+                to_account=to_account,
+                shares=shares,  # For subnet transfer
+            )
+
+            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 delegate transfer transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Transferring delegate stake..."):
+                response = client.extrinsics.staking.transfer_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Delegate transfer failed")
+                if handle_stake_error(
+                    error_msg,
+                    request.subnet_id,
+                    None,
+                    "transfer delegate stake",
+                    client,
+                ):
+                    return
+
+            display_delegate_transfer_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if "request" in locals() else None
+            node_id_for_error = (
+                getattr(request, "subnet_node_id", None)
+                if "request" in locals()
+                else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "transfer delegate stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)
+
+
+def delegate_donate_handler(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+    validator_id: Optional[int] = None,
+):
+    """Handle donating delegate stake to subnet treasury, validator, or node pool.
+
+    Routes to validator delegate if validator_id is provided, node delegate if
+    node_id is provided, otherwise subnet delegate.
+    """
+    try:
+        from ...ui.prompts import confirm_prompt
+
+        if validator_id is not None:
+            request = prompt_validator_delegate_donate(
+                validator_id=validator_id,
+                amount=amount,
+            )
+
+            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 validator delegate donation transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Donating to validator delegate pool..."):
+                response = client.extrinsics.staking.donate_validator_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Validator delegate donation failed")
+                if handle_stake_error(
+                    error_msg, None, None, "donate validator delegate stake", client
+                ):
+                    return
+
+            display_validator_delegate_donate_result(response)
+            return
+
+        # Determine if this is node-level or subnet-level donation
+        is_node_donation = node_id is not None
+
+        # If no node_id provided via CLI, ask if user wants node-level donation
+        if not is_node_donation and subnet_id is not None:
+            want_node = confirm_prompt(
+                "Do you want to donate to a specific node?", default=False
+            )
+            if want_node:
+                is_node_donation = True
+
+        if is_node_donation:
+            # NODE DELEGATE DONATE PATH
+            request = prompt_node_delegate_donate(
+                subnet_id=subnet_id,
+                subnet_node_id=node_id,
+                amount=amount,
+            )
+
+            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 node delegate donation transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Donating to node delegate pool..."):
+                response = client.extrinsics.staking.donate_node_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Node delegate donation failed")
+                if handle_stake_error(
+                    error_msg,
+                    request.subnet_id,
+                    request.subnet_node_id,
+                    "donate node delegate stake",
+                    client,
+                ):
+                    return
+
+            display_node_delegate_donate_result(response)
+        else:
+            # SUBNET DELEGATE DONATE PATH
+            request = prompt_delegate_donate(
+                subnet_id=subnet_id,
+                amount=amount,
+            )
+
+            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 delegate donation transaction",
+                )
+
+            client = get_client()
+            with HTCLILoadingContext("Donating delegate stake to subnet treasury..."):
+                response = client.extrinsics.staking.donate_delegate_stake(
+                    request, keypair
+                )
+
+            if isinstance(response, dict) and not response.get("success", False):
+                error_msg = response.get("error", "Delegate donation failed")
+                if handle_stake_error(
+                    error_msg, request.subnet_id, None, "donate delegate stake", client
+                ):
+                    return
+
+            display_delegate_donate_result(response)
+
+    except Exception as e:
+        error_msg = str(e)
+        subnet_id_for_error = None
+        node_id_for_error = None
+        client_for_error = None
+        try:
+            subnet_id_for_error = request.subnet_id if "request" in locals() else None
+            node_id_for_error = (
+                getattr(request, "subnet_node_id", None)
+                if "request" in locals()
+                else None
+            )
+            client_for_error = client if "client" in locals() else None
+        except (AttributeError, NameError):
+            pass
+
+        if not handle_stake_error(
+            error_msg,
+            subnet_id_for_error,
+            node_id_for_error,
+            "donate delegate stake",
+            client_for_error,
+        ):
+            handle_and_display_error(e)