htcli 1.1.0__py3-none-any.whl

src/htcli/commands/stake/prompts.py

@@ -0,0 +1,1080 @@
+"""
+Stake command prompting logic.
+
+Handles user interaction and input validation for stake operations.
+Uses HTCLI UI components and Pydantic models for proper validation.
+"""
+
+import json
+from typing import Optional
+
+from ...dependencies import get_client
+from ...models.requests import (
+    ClaimUnbondingsRequest,
+    DelegateStakeAddRequest,
+    DelegateStakeDonateRequest,
+    DelegateStakeRemoveRequest,
+    DelegateStakeSwapRequest,
+    DelegateStakeTransferRequest,
+    NodeDelegateStakeAddRequest,
+    NodeDelegateStakeDonateRequest,
+    NodeDelegateStakeRemoveRequest,
+    NodeDelegateStakeSwapRequest,
+    NodeDelegateStakeTransferRequest,
+    StakeAddRequest,
+    StakeRemoveRequest,
+    StakeSwapFromNodeToSubnetRequest,
+    StakeSwapFromSubnetToNodeRequest,
+    StakeSwapFromSubnetToValidatorRequest,
+    StakeSwapFromValidatorToSubnetRequest,
+    StakeSwapQueueUpdateRequest,
+    ValidatorDelegateStakeAddRequest,
+    ValidatorDelegateStakeDonateRequest,
+    ValidatorDelegateStakeRemoveRequest,
+    ValidatorDelegateStakeSwapRequest,
+    ValidatorDelegateStakeTransferRequest,
+)
+from ...ui.colors import info, warning
+from ...ui.display import HTCLIConsole, print_error, print_info
+from ...ui.prompts import HTCLIPrompt, amount_prompt, confirm_prompt
+from ...utils.blockchain.validation import validate_address
+from ...utils.validation import (
+    validate_hotkey_address,
+    validate_node_id_prompt,
+    validate_stake_amount_prompt,
+    validate_subnet_id_prompt,
+)
+
+console = HTCLIConsole()
+prompt = HTCLIPrompt()
+
+
+def prompt_stake_add(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    hotkey: Optional[str] = None,
+    amount: Optional[int] = None,
+) -> StakeAddRequest:
+    """Prompt for stake addition parameters."""
+    # Validate subnet_id if provided
+    if subnet_id is not None:
+        is_valid, error_msg = validate_subnet_id_prompt(subnet_id)
+        if not is_valid:
+            print_error(f"Invalid subnet ID: {error_msg}")
+            subnet_id = None
+
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter the Subnet ID to stake to",
+            min_value=0,
+        )
+
+    # Validate node_id if provided
+    if node_id is not None:
+        is_valid, error_msg = validate_node_id_prompt(node_id)
+        if not is_valid:
+            print_error(f"Invalid node ID: {error_msg}")
+            node_id = None
+
+    # If node_id is provided, fetch hotkey from node_id automatically
+    if node_id is not None:
+        client = get_client()
+        node_info = client.rpc.node.get_subnet_node_info(subnet_id, node_id)
+
+        if node_info is None:
+            raise ValueError(f"Node {node_id} not found in subnet {subnet_id}")
+
+        hotkey = node_info.hotkey
+        print_info(f"Found hotkey {hotkey} for node {node_id} in subnet {subnet_id}")
+    else:
+        # No node_id provided - user must provide hotkey manually
+        # Validate hotkey if provided
+        if hotkey is not None:
+            is_valid, error_msg = validate_hotkey_address(hotkey)
+            if not is_valid:
+                print_error(f"Invalid hotkey address: {error_msg}")
+                hotkey = None
+
+        if hotkey is None:
+            hotkey = prompt.text_prompt(
+                "Enter the hotkey address to stake with",
+            )
+            # Validate address format
+            if not validate_address(hotkey):
+                raise ValueError(f"Invalid hotkey address format: {hotkey}")
+
+        # Try to get node_id from hotkey (optional - stake works even if hotkey not registered as node yet)
+        # Note: subnet_node_id is required by extrinsic but not used in staking logic
+        # We use 0 as default if hotkey is not registered
+        node_id = 0
+        client = get_client()
+        try:
+            result = client.substrate.query(
+                module="Network",
+                storage_function="HotkeySubnetNodeId",
+                params=[subnet_id, hotkey],
+            )
+            if result and result.value is not None:
+                node_id = result.value
+        except Exception:
+            # Hotkey might not be registered yet - that's OK, stake still works
+            # The blockchain will validate that coldkey owns the hotkey
+            pass
+
+    # Validate amount if provided (amount is in TENSOR)
+    if amount is not None:
+        is_valid, error_msg = validate_stake_amount_prompt(amount)
+        if not is_valid:
+            print_error(f"Invalid stake amount: {error_msg}")
+            amount = None
+
+    if amount is None:
+        amount = prompt.integer_prompt(
+            "Enter the stake amount to add",
+            min_value=1,
+        )
+
+    # Convert TENSOR to WEI for the request model (which expects WEI)
+    # amount is in TENSOR (integer), convert to WEI
+    amount_wei = int(amount * 1e18)
+
+    # subnet_node_id is required by extrinsic signature but not used in staking logic
+    # Staking is stored per (hotkey, subnet_id), not per node_id
+    # If node_id is 0, that's fine - the blockchain only validates coldkey owns hotkey
+    return StakeAddRequest(
+        subnet_id=subnet_id,
+        subnet_node_id=node_id or 0,  # Use 0 as default if hotkey not registered yet
+        hotkey=hotkey,
+        stake_amount=amount_wei,
+    )
+
+
+def prompt_stake_remove(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    hotkey: Optional[str] = None,
+    amount: Optional[int] = None,
+    coldkey_name: Optional[str] = None,
+) -> StakeRemoveRequest:
+    """Prompt for stake removal parameters."""
+    client = get_client()
+
+    # Get coldkey address if provided (for hotkey disambiguation)
+    coldkey_address = None
+    if coldkey_name:
+        try:
+            from ...utils.wallet.crypto import get_wallet_info_by_name
+
+            coldkey_info = get_wallet_info_by_name(coldkey_name, is_hotkey=False)
+            coldkey_address = (
+                coldkey_info.get("evm_address")
+                or coldkey_info.get("ss58_address")
+                or coldkey_info.get("address")
+            )
+        except Exception:
+            # Coldkey not found yet, will be resolved later - that's okay
+            pass
+    # Validate subnet_id if provided
+    if subnet_id is not None:
+        is_valid, error_msg = validate_subnet_id_prompt(subnet_id)
+        if not is_valid:
+            print_error(f"Invalid subnet ID: {error_msg}")
+            subnet_id = None
+
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter the Subnet ID to remove stake from",
+            min_value=0,
+        )
+
+    # Validate node_id if provided
+    if node_id is not None:
+        is_valid, error_msg = validate_node_id_prompt(node_id)
+        if not is_valid:
+            print_error(f"Invalid node ID: {error_msg}")
+            node_id = None
+
+    if node_id is None:
+        # Ask if user wants to remove stake from subnet or specific node
+        console.print(info("Remove stake from:"))
+        console.print("  1. Subnet (general subnet staking)")
+        console.print("  2. Specific node in subnet")
+
+        choice = prompt.integer_prompt(
+            "Select option (1-2)",
+            min_value=1,
+            max_value=2,
+        )
+
+        if choice == 2:
+            node_id = prompt.integer_prompt(
+                "Enter the Node ID within the subnet",
+                min_value=0,
+            )
+
+    # Resolve hotkey if provided (handles both wallet names and addresses)
+    if hotkey is not None:
+        hotkey = hotkey.strip()
+        # Check if it's already a valid address
+        if not client.offchain.wallet.validate_ethereum_address(hotkey):
+            # Try to resolve as wallet name with coldkey context
+            try:
+                resolved_hotkey = client.offchain.wallet.resolve_hotkey_address(
+                    hotkey,
+                    owner_coldkey_name=coldkey_name,
+                    owner_address=coldkey_address,
+                )
+                # Verify the resolved address is valid
+                if not client.offchain.wallet.validate_ethereum_address(
+                    resolved_hotkey
+                ):
+                    raise ValueError(
+                        f"Resolved hotkey address is invalid: {resolved_hotkey}"
+                    )
+                hotkey = resolved_hotkey
+            except ValueError as e:
+                # Resolution failed - provide clear error message
+                print_error(f"Failed to resolve hotkey '{hotkey}': {str(e)}")
+                print_error(
+                    "Please provide a valid hotkey wallet name or Ethereum address (0x...)"
+                )
+                hotkey = None
+            except Exception as e:
+                # Unexpected error - re-raise with context
+                raise RuntimeError(
+                    f"Unexpected error resolving hotkey '{hotkey}': {str(e)}"
+                ) from e
+
+    if hotkey is None:
+        hotkey = prompt.text_prompt(
+            "Enter the hotkey address or wallet name to remove stake from",
+        )
+        hotkey = hotkey.strip()
+        # Check if it's already a valid address
+        if not client.offchain.wallet.validate_ethereum_address(hotkey):
+            # Try to resolve as wallet name with coldkey context
+            try:
+                resolved_hotkey = client.offchain.wallet.resolve_hotkey_address(
+                    hotkey,
+                    owner_coldkey_name=coldkey_name,
+                    owner_address=coldkey_address,
+                )
+                # Verify the resolved address is valid
+                if not client.offchain.wallet.validate_ethereum_address(
+                    resolved_hotkey
+                ):
+                    raise ValueError(
+                        f"Resolved hotkey address is invalid: {resolved_hotkey}"
+                    )
+                hotkey = resolved_hotkey
+            except ValueError as e:
+                # Resolution failed - validate as address format
+                if not validate_address(hotkey):
+                    raise ValueError(
+                        f"Invalid hotkey: '{hotkey}' is neither a valid wallet name nor a valid Ethereum address. "
+                        f"Error: {str(e)}"
+                    ) from e
+                # If it passes validate_address but not validate_ethereum_address, something is wrong
+                raise ValueError(f"Invalid hotkey address format: {hotkey}") from e
+            except Exception as e:
+                # Unexpected error - re-raise with context
+                raise RuntimeError(
+                    f"Unexpected error resolving hotkey '{hotkey}': {str(e)}"
+                ) from e
+
+    # Final validation - ensure we have a valid Ethereum address
+    if not client.offchain.wallet.validate_ethereum_address(hotkey):
+        raise ValueError(f"Invalid hotkey address format: {hotkey}")
+
+    # Validate amount if provided (amount is in TENSOR)
+    if amount is not None:
+        is_valid, error_msg = validate_stake_amount_prompt(amount)
+        if not is_valid:
+            print_error(f"Invalid stake amount: {error_msg}")
+            amount = None
+
+    if amount is None:
+        amount = prompt.integer_prompt(
+            "Enter the stake amount to remove",
+            min_value=1,
+        )
+
+    # Convert TENSOR to WEI for the request model (which expects WEI)
+    amount_wei = int(amount * 1e18)
+
+    return StakeRemoveRequest(
+        subnet_id=subnet_id,
+        hotkey=hotkey,
+        stake_amount=amount_wei,
+    )
+
+
+def prompt_stake_claim() -> ClaimUnbondingsRequest:
+    """Prompt for stake claiming parameters."""
+    console.print(info("Claim Unbonded Tokens"))
+    console.print(
+        "This will claim all tokens that have completed the unbonding period.\n"
+    )
+
+    # Confirm action
+    confirmed = confirm_prompt("Proceed with claiming unbonded tokens?", default=True)
+    if not confirmed:
+        raise KeyboardInterrupt("Operation cancelled")
+
+    return ClaimUnbondingsRequest()
+
+
+def prompt_delegate_stake_add(
+    subnet_id: Optional[int] = None,
+    stake_amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+) -> DelegateStakeAddRequest:
+    """Prompt for adding delegate stake to a subnet."""
+    # Validate subnet_id if provided
+    if subnet_id is not None:
+        is_valid, error_msg = validate_subnet_id_prompt(subnet_id)
+        if not is_valid:
+            print_error(f"Invalid subnet ID: {error_msg}")
+            subnet_id = None
+
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter the Subnet ID to delegate stake to",
+            min_value=0,
+        )
+
+    # Validate stake_amount if provided (stake_amount is in TENSOR)
+    if stake_amount is not None:
+        # Convert to float if it's an integer (treat integers as TENSOR)
+        if isinstance(stake_amount, int):
+            stake_amount = float(stake_amount)
+        is_valid, error_msg = validate_stake_amount_prompt(stake_amount)
+        if not is_valid:
+            print_error(f"Invalid stake amount: {error_msg}")
+            stake_amount = None
+
+    if stake_amount is None:
+        from ...ui.prompts import amount_prompt
+
+        stake_amount = amount_prompt(
+            "Enter the amount to delegate",
+            currency="TENSOR",
+            min_amount=0.000001,
+        )
+
+    # Convert TENSOR to WEI for the request model (which expects WEI)
+    stake_amount_wei = int(stake_amount * 1e18)
+
+    return DelegateStakeAddRequest(
+        subnet_id=subnet_id,
+        stake_amount=stake_amount_wei,
+    )
+
+
+def prompt_delegate_stake_remove(
+    subnet_id: Optional[int] = None,
+    shares_to_remove: Optional[int] = None,
+) -> DelegateStakeRemoveRequest:
+    """Prompt for removing delegate stake from a subnet."""
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter the Subnet ID to remove delegate stake from",
+            min_value=0,
+        )
+
+    if shares_to_remove is None:
+        console.print(warning("Note: Enter shares as displayed in 'htcli stake list'."))
+        console.print(
+            info("Check your current shares with: htcli stake list --coldkey <wallet>")
+        )
+        shares_to_remove = prompt.integer_prompt(
+            "Enter the number of shares to remove",
+            min_value=1,
+        )
+
+    # Convert human-readable shares to wei format (multiply by 10^18)
+    # Blockchain stores shares with 18 decimals
+    shares_in_wei = int(shares_to_remove * 10**18)
+
+    return DelegateStakeRemoveRequest(
+        subnet_id=subnet_id,
+        shares_to_be_removed=shares_in_wei,
+    )
+
+
+def prompt_validator_delegate_stake_add(
+    validator_id: Optional[int] = None,
+    stake_amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+) -> ValidatorDelegateStakeAddRequest:
+    """Prompt for adding delegate stake to a validator."""
+    if validator_id is not None and validator_id < 0:
+        print_error("Invalid validator ID: must be non-negative")
+        validator_id = None
+
+    if validator_id is None:
+        validator_id = prompt.integer_prompt(
+            "Enter the Validator ID to delegate to",
+            min_value=0,
+        )
+
+    if stake_amount is not None:
+        if isinstance(stake_amount, int):
+            stake_amount = float(stake_amount)
+        is_valid, error_msg = validate_stake_amount_prompt(stake_amount)
+        if not is_valid:
+            print_error(f"Invalid stake amount: {error_msg}")
+            stake_amount = None
+
+    if stake_amount is None:
+        stake_amount = amount_prompt(
+            "Enter the amount to delegate",
+            currency="TENSOR",
+            min_amount=0.000001,
+        )
+
+    return ValidatorDelegateStakeAddRequest(
+        validator_id=validator_id,
+        delegate_stake_to_be_added=int(stake_amount * 1e18),
+    )
+
+
+def prompt_validator_delegate_stake_remove(
+    validator_id: Optional[int] = None,
+    shares_to_remove: Optional[int] = None,
+) -> ValidatorDelegateStakeRemoveRequest:
+    """Prompt for removing delegate stake from a validator."""
+    if validator_id is not None and validator_id < 0:
+        print_error("Invalid validator ID: must be non-negative")
+        validator_id = None
+
+    if validator_id is None:
+        validator_id = prompt.integer_prompt(
+            "Enter the Validator ID to remove delegate stake from",
+            min_value=0,
+        )
+
+    if shares_to_remove is None:
+        console.print(warning("Note: You must specify shares to remove, not amount."))
+        shares_to_remove = prompt.integer_prompt(
+            "Enter the number of shares to remove",
+            min_value=1,
+        )
+
+    return ValidatorDelegateStakeRemoveRequest(
+        validator_id=validator_id,
+        validator_delegate_stake_shares_to_be_removed=shares_to_remove,
+    )
+
+
+def prompt_validator_delegate_swap(
+    from_validator_id: Optional[int] = None,
+    to_validator_id: Optional[int] = None,
+    shares_to_swap: Optional[int] = None,
+) -> ValidatorDelegateStakeSwapRequest:
+    """Prompt for swapping validator delegate shares between validators."""
+    if from_validator_id is not None and from_validator_id < 0:
+        print_error("Invalid source validator ID: must be non-negative")
+        from_validator_id = None
+    if to_validator_id is not None and to_validator_id < 0:
+        print_error("Invalid destination validator ID: must be non-negative")
+        to_validator_id = None
+
+    if from_validator_id is None:
+        from_validator_id = prompt.integer_prompt(
+            "Enter source validator ID",
+            min_value=0,
+        )
+    if to_validator_id is None:
+        to_validator_id = prompt.integer_prompt(
+            "Enter destination validator ID",
+            min_value=0,
+        )
+    if shares_to_swap is None:
+        shares_to_swap = prompt.integer_prompt(
+            "Enter number of shares to swap",
+            min_value=1,
+        )
+
+    return ValidatorDelegateStakeSwapRequest(
+        from_validator_id=from_validator_id,
+        to_validator_id=to_validator_id,
+        stake_to_be_removed=shares_to_swap,
+    )
+
+
+def prompt_validator_delegate_transfer(
+    validator_id: Optional[int] = None,
+    to_account: Optional[str] = None,
+    shares_to_transfer: Optional[int] = None,
+) -> ValidatorDelegateStakeTransferRequest:
+    """Prompt for transferring validator delegate shares."""
+    if validator_id is not None and validator_id < 0:
+        print_error("Invalid validator ID: must be non-negative")
+        validator_id = None
+
+    if validator_id is None:
+        validator_id = prompt.integer_prompt(
+            "Enter validator ID",
+            min_value=0,
+        )
+    if to_account is None:
+        to_account = prompt.text_prompt("Enter destination account (0x...)")
+    if not validate_address(to_account):
+        raise ValueError("Destination account must be a valid Ethereum address")
+
+    if shares_to_transfer is None:
+        shares_to_transfer = prompt.integer_prompt(
+            "Enter number of shares to transfer",
+            min_value=1,
+        )
+
+    return ValidatorDelegateStakeTransferRequest(
+        validator_id=validator_id,
+        to_account_id=to_account,
+        validator_delegate_stake_shares_to_transfer=shares_to_transfer,
+    )
+
+
+def prompt_validator_delegate_donate(
+    validator_id: Optional[int] = None,
+    amount: Optional[float] = None,
+) -> ValidatorDelegateStakeDonateRequest:
+    """Prompt for donating validator delegate stake."""
+    if validator_id is not None and validator_id < 0:
+        print_error("Invalid validator ID: must be non-negative")
+        validator_id = None
+
+    if validator_id is None:
+        validator_id = prompt.integer_prompt(
+            "Enter validator ID",
+            min_value=0,
+        )
+
+    if amount is not None:
+        if isinstance(amount, int):
+            amount = float(amount)
+        is_valid, error_msg = validate_stake_amount_prompt(amount)
+        if not is_valid:
+            print_error(f"Invalid amount: {error_msg}")
+            amount = None
+
+    if amount is None:
+        amount = amount_prompt(
+            "Enter donation amount",
+            currency="TENSOR",
+            min_amount=0.000001,
+        )
+
+    return ValidatorDelegateStakeDonateRequest(
+        validator_id=validator_id,
+        amount=int(amount * 1e18),
+    )
+
+
+def prompt_node_delegate_stake_add(
+    subnet_id: Optional[int] = None,
+    subnet_node_id: Optional[int] = None,
+    stake_amount: Optional[float] = None,
+    coldkey: Optional[str] = None,
+) -> NodeDelegateStakeAddRequest:
+    """Prompt for adding delegate stake to a specific node."""
+    # Validate subnet_id if provided
+    if subnet_id is not None:
+        is_valid, error_msg = validate_subnet_id_prompt(subnet_id)
+        if not is_valid:
+            print_error(f"Invalid subnet ID: {error_msg}")
+            subnet_id = None
+
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter the Subnet ID",
+            min_value=0,
+        )
+
+    # Validate subnet_node_id if provided
+    if subnet_node_id is not None:
+        is_valid, error_msg = validate_node_id_prompt(subnet_node_id)
+        if not is_valid:
+            print_error(f"Invalid node ID: {error_msg}")
+            subnet_node_id = None
+
+    if subnet_node_id is None:
+        subnet_node_id = prompt.integer_prompt(
+            "Enter the Node ID to delegate to",
+            min_value=0,
+        )
+
+    # Validate stake_amount if provided (stake_amount is in TENSOR)
+    if stake_amount is not None:
+        # Convert to float if it's an integer (treat integers as TENSOR)
+        if isinstance(stake_amount, int):
+            stake_amount = float(stake_amount)
+        is_valid, error_msg = validate_stake_amount_prompt(stake_amount)
+        if not is_valid:
+            print_error(f"Invalid stake amount: {error_msg}")
+            stake_amount = None
+
+    if stake_amount is None:
+        from ...ui.prompts import amount_prompt
+
+        stake_amount = amount_prompt(
+            "Enter the amount to delegate",
+            currency="TENSOR",
+            min_amount=0.000001,
+        )
+
+    # Convert TENSOR to WEI for the request model (which expects WEI)
+    stake_amount_wei = int(stake_amount * 1e18)
+
+    return NodeDelegateStakeAddRequest(
+        subnet_id=subnet_id,
+        subnet_node_id=subnet_node_id,
+        node_delegate_stake_to_be_added=stake_amount_wei,
+    )
+
+
+def prompt_node_delegate_stake_remove(
+    subnet_id: Optional[int] = None,
+    subnet_node_id: Optional[int] = None,
+    shares_to_remove: Optional[int] = None,
+) -> NodeDelegateStakeRemoveRequest:
+    """Prompt for removing delegate stake from a specific node."""
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter the Subnet ID",
+            min_value=0,
+        )
+
+    if subnet_node_id is None:
+        subnet_node_id = prompt.integer_prompt(
+            "Enter the Node ID to remove delegate stake from",
+            min_value=0,
+        )
+
+    if shares_to_remove is None:
+        console.print(warning("Note: You must specify shares to remove, not amount."))
+        console.print(
+            info(
+                "Check your current shares with: htcli stake list --coldkey <your coldkey address>"
+            )
+        )
+        shares_to_remove = prompt.integer_prompt(
+            "Enter the number of shares to remove",
+            min_value=1,
+        )
+
+    return NodeDelegateStakeRemoveRequest(
+        subnet_id=subnet_id,
+        subnet_node_id=subnet_node_id,
+        node_delegate_stake_shares_to_be_removed=shares_to_remove,
+    )
+
+
+def prompt_node_delegate_swap(
+    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,
+) -> NodeDelegateStakeSwapRequest:
+    """Prompt for swapping node delegate shares between nodes."""
+    if from_subnet_id is None:
+        from_subnet_id = prompt.integer_prompt(
+            "Enter source subnet ID",
+            min_value=0,
+        )
+    if from_subnet_node_id is None:
+        from_subnet_node_id = prompt.integer_prompt(
+            "Enter source node ID",
+            min_value=0,
+        )
+    if to_subnet_id is None:
+        to_subnet_id = prompt.integer_prompt(
+            "Enter destination subnet ID",
+            min_value=0,
+        )
+    if to_subnet_node_id is None:
+        to_subnet_node_id = prompt.integer_prompt(
+            "Enter destination node ID",
+            min_value=0,
+        )
+    if shares_to_swap is None:
+        shares_to_swap = prompt.integer_prompt(
+            "Enter number of shares to swap",
+            min_value=1,
+        )
+
+    return NodeDelegateStakeSwapRequest(
+        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,
+        node_delegate_stake_shares_to_swap=shares_to_swap,
+    )
+
+
+def prompt_node_delegate_transfer(
+    subnet_id: Optional[int] = None,
+    subnet_node_id: Optional[int] = None,
+    to_account: Optional[str] = None,
+    shares_to_transfer: Optional[int] = None,
+) -> NodeDelegateStakeTransferRequest:
+    """Prompt for transferring node delegate shares."""
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter subnet ID",
+            min_value=0,
+        )
+    if subnet_node_id is None:
+        subnet_node_id = prompt.integer_prompt(
+            "Enter node ID",
+            min_value=0,
+        )
+    if to_account is None:
+        to_account = prompt.text_prompt("Enter destination account (0x...)")
+    if not validate_address(to_account):
+        raise ValueError("Destination account must be a valid Ethereum address")
+
+    if shares_to_transfer is None:
+        shares_to_transfer = prompt.integer_prompt(
+            "Enter number of shares to transfer",
+            min_value=1,
+        )
+
+    return NodeDelegateStakeTransferRequest(
+        subnet_id=subnet_id,
+        subnet_node_id=subnet_node_id,
+        to_account_id=to_account,
+        node_delegate_stake_shares_to_transfer=shares_to_transfer,
+    )
+
+
+def prompt_node_delegate_donate(
+    subnet_id: Optional[int] = None,
+    subnet_node_id: Optional[int] = None,
+    amount: Optional[float] = None,
+) -> NodeDelegateStakeDonateRequest:
+    """Prompt for donating node delegate stake."""
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter subnet ID",
+            min_value=0,
+        )
+    if subnet_node_id is None:
+        subnet_node_id = prompt.integer_prompt(
+            "Enter node ID",
+            min_value=0,
+        )
+    # Validate amount if provided (amount is in TENSOR)
+    if amount is not None:
+        # Convert to float if it's an integer (treat integers as TENSOR)
+        if isinstance(amount, int):
+            amount = float(amount)
+        is_valid, error_msg = validate_stake_amount_prompt(amount)
+        if not is_valid:
+            print_error(f"Invalid amount: {error_msg}")
+            amount = None
+
+    if amount is None:
+        amount = amount_prompt(
+            "Enter donation amount",
+            currency="TENSOR",
+            min_amount=0.000001,
+        )
+
+    # Convert TENSOR to WEI for the request model (which expects WEI)
+    amount_wei = int(amount * 1e18)
+
+    return NodeDelegateStakeDonateRequest(
+        subnet_id=subnet_id,
+        subnet_node_id=subnet_node_id,
+        amount=amount_wei,
+    )
+
+
+def prompt_swap_node_to_subnet(
+    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,
+) -> StakeSwapFromNodeToSubnetRequest:
+    """Prompt for swapping node delegate shares into subnet shares."""
+    if from_subnet_id is None:
+        from_subnet_id = prompt.integer_prompt(
+            "Enter source subnet ID",
+            min_value=0,
+        )
+    if from_subnet_node_id is None:
+        from_subnet_node_id = prompt.integer_prompt(
+            "Enter source node ID",
+            min_value=0,
+        )
+    if to_subnet_id is None:
+        to_subnet_id = prompt.integer_prompt(
+            "Enter destination subnet ID",
+            min_value=0,
+        )
+    if shares_to_swap is None:
+        shares_to_swap = prompt.integer_prompt(
+            "Enter number of shares to swap",
+            min_value=1,
+        )
+
+    return StakeSwapFromNodeToSubnetRequest(
+        from_subnet_id=from_subnet_id,
+        from_subnet_node_id=from_subnet_node_id,
+        to_subnet_id=to_subnet_id,
+        node_delegate_stake_shares_to_swap=shares_to_swap,
+    )
+
+
+def prompt_swap_subnet_to_node(
+    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,
+) -> StakeSwapFromSubnetToNodeRequest:
+    """Prompt for swapping subnet delegate shares into node delegate shares."""
+    if from_subnet_id is None:
+        from_subnet_id = prompt.integer_prompt(
+            "Enter source subnet ID",
+            min_value=0,
+        )
+    if to_subnet_id is None:
+        to_subnet_id = prompt.integer_prompt(
+            "Enter destination subnet ID",
+            min_value=0,
+        )
+    if to_subnet_node_id is None:
+        to_subnet_node_id = prompt.integer_prompt(
+            "Enter destination node ID",
+            min_value=0,
+        )
+    if shares_to_swap is None:
+        shares_to_swap = prompt.integer_prompt(
+            "Enter number of shares to swap",
+            min_value=1,
+        )
+
+    return StakeSwapFromSubnetToNodeRequest(
+        from_subnet_id=from_subnet_id,
+        to_subnet_id=to_subnet_id,
+        to_subnet_node_id=to_subnet_node_id,
+        delegate_stake_shares_to_swap=shares_to_swap,
+    )
+
+
+def prompt_swap_validator_to_subnet(
+    from_validator_id: Optional[int] = None,
+    to_subnet_id: Optional[int] = None,
+    shares_to_swap: Optional[int] = None,
+) -> StakeSwapFromValidatorToSubnetRequest:
+    """Prompt for swapping validator delegate shares into subnet shares."""
+    if from_validator_id is not None and from_validator_id < 0:
+        print_error("Invalid source validator ID: must be non-negative")
+        from_validator_id = None
+    if from_validator_id is None:
+        from_validator_id = prompt.integer_prompt(
+            "Enter source validator ID",
+            min_value=0,
+        )
+    if to_subnet_id is None:
+        to_subnet_id = prompt.integer_prompt(
+            "Enter destination subnet ID",
+            min_value=0,
+        )
+    if shares_to_swap is None:
+        shares_to_swap = prompt.integer_prompt(
+            "Enter number of shares to swap",
+            min_value=1,
+        )
+
+    return StakeSwapFromValidatorToSubnetRequest(
+        from_validator_id=from_validator_id,
+        to_subnet_id=to_subnet_id,
+        node_delegate_stake_shares_to_swap=shares_to_swap,
+    )
+
+
+def prompt_swap_subnet_to_validator(
+    from_subnet_id: Optional[int] = None,
+    to_validator_id: Optional[int] = None,
+    shares_to_swap: Optional[int] = None,
+) -> StakeSwapFromSubnetToValidatorRequest:
+    """Prompt for swapping subnet delegate shares into validator shares."""
+    if from_subnet_id is None:
+        from_subnet_id = prompt.integer_prompt(
+            "Enter source subnet ID",
+            min_value=0,
+        )
+    if to_validator_id is not None and to_validator_id < 0:
+        print_error("Invalid destination validator ID: must be non-negative")
+        to_validator_id = None
+    if to_validator_id is None:
+        to_validator_id = prompt.integer_prompt(
+            "Enter destination validator ID",
+            min_value=0,
+        )
+    if shares_to_swap is None:
+        shares_to_swap = prompt.integer_prompt(
+            "Enter number of shares to swap",
+            min_value=1,
+        )
+
+    return StakeSwapFromSubnetToValidatorRequest(
+        from_subnet_id=from_subnet_id,
+        to_validator_id=to_validator_id,
+        subnet_delegate_stake_shares_to_swap=shares_to_swap,
+    )
+
+
+def prompt_swap_queue_update(
+    queue_id: Optional[int] = None,
+    new_call_json: Optional[str] = None,
+) -> StakeSwapQueueUpdateRequest:
+    """Prompt for updating a swap queue entry."""
+    if queue_id is None:
+        queue_id = prompt.integer_prompt(
+            "Enter queue entry ID",
+            min_value=0,
+        )
+
+    if not new_call_json:
+        console.print(
+            info(
+                "Provide the new call payload as JSON. Example:\n"
+                '{"type": "SwapToNodeDelegateStake", "to_subnet_id": 1, "to_subnet_node_id": 3}'
+            )
+        )
+        new_call_json = prompt.text_prompt("Enter new call JSON")
+
+    try:
+        parsed = json.loads(new_call_json)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Invalid JSON: {exc.msg}") from exc
+
+    return StakeSwapQueueUpdateRequest(
+        queue_id=queue_id,
+        new_call=parsed,
+    )
+
+
+def prompt_delegate_swap(
+    from_subnet_id: Optional[int] = None,
+    to_subnet_id: Optional[int] = None,
+    shares: Optional[int] = None,
+) -> DelegateStakeSwapRequest:
+    """Prompt for swapping delegate stake between subnets."""
+    console.print(info("Swap Delegate Stake Between Subnets"))
+    console.print(
+        "Move your delegate stake from one subnet to another. Note: Swapping uses SHARES, not TENSOR amount.\\n"
+    )
+
+    if from_subnet_id is None:
+        from_subnet_id = prompt.integer_prompt(
+            "Enter source subnet ID",
+            min_value=0,
+        )
+    if to_subnet_id is None:
+        to_subnet_id = prompt.integer_prompt(
+            "Enter destination subnet ID",
+            min_value=0,
+        )
+
+    if shares is None:
+        shares = prompt.integer_prompt(
+            "Enter shares to swap",
+            min_value=1,
+        )
+
+    return DelegateStakeSwapRequest(
+        from_subnet_id=from_subnet_id,
+        to_subnet_id=to_subnet_id,
+        delegate_stake_shares_to_swap=shares,
+    )
+
+
+def prompt_delegate_transfer(
+    subnet_id: Optional[int] = None,
+    to_account: Optional[str] = None,
+    shares: Optional[int] = None,
+) -> DelegateStakeTransferRequest:
+    """Prompt for transferring delegate stake to another account."""
+    console.print(info("Transfer Delegate Stake"))
+    console.print("Transfer your delegate stake to another account.\n")
+
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter subnet ID",
+            min_value=0,
+        )
+
+    if to_account is None:
+        to_account = prompt.text_prompt("Enter destination account (0x...)")
+    if not validate_address(to_account):
+        raise ValueError("Destination account must be a valid Ethereum address")
+
+    if shares is None:
+        shares = prompt.integer_prompt(
+            "Enter shares to transfer",
+            min_value=1,
+        )
+
+    # The from_account will be the signer's address
+    # We set a placeholder here that will be replaced during submission
+    return DelegateStakeTransferRequest(
+        subnet_id=subnet_id,
+        from_account="0x0000000000000000000000000000000000000000",  # Placeholder
+        to_account=to_account,
+        delegate_stake_shares_to_transfer=shares,
+    )
+
+
+def prompt_delegate_donate(
+    subnet_id: Optional[int] = None,
+    amount: Optional[float] = None,
+) -> DelegateStakeDonateRequest:
+    """Prompt for donating delegate stake to subnet treasury."""
+    console.print(info("Donate Delegate Stake"))
+    console.print("Donate tokens to the subnet treasury.\n")
+    console.print(
+        warning("⚠️  This is a one-way transfer. Donated funds cannot be recovered.\n")
+    )
+
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter subnet ID",
+            min_value=0,
+        )
+
+    # Validate amount if provided (amount is in TENSOR)
+    if amount is not None:
+        if isinstance(amount, int):
+            amount = float(amount)
+        is_valid, error_msg = validate_stake_amount_prompt(amount)
+        if not is_valid:
+            print_error(f"Invalid amount: {error_msg}")
+            amount = None
+
+    if amount is None:
+        amount = amount_prompt(
+            "Enter donation amount",
+            currency="TENSOR",
+            min_amount=0.000001,
+        )
+
+    # Confirm donation
+    confirmed = confirm_prompt(
+        f"Confirm donation of {amount:.4f} TENSOR to subnet {subnet_id}?", default=False
+    )
+    if not confirmed:
+        raise KeyboardInterrupt("Operation cancelled")
+
+    # Convert TENSOR to WEI
+    amount_wei = int(amount * 1e18)
+
+    return DelegateStakeDonateRequest(
+        subnet_id=subnet_id,
+        stake_amount=amount_wei,
+    )