htcli 1.1.0__py3-none-any.whl

src/htcli/commands/node/prompts.py

@@ -0,0 +1,346 @@
+"""
+Node command prompting logic.
+
+Handles user interaction and input validation for node operations.
+Uses HTCLI UI components and Pydantic models for proper validation.
+"""
+
+import secrets
+from typing import Optional
+
+from ...dependencies import get_client
+from ...models.requests import SubnetNodeRegisterRequest
+from ...ui.colors import info
+from ...ui.display import HTCLIConsole, print_error
+from ...ui.prompts import HTCLIPrompt, confirm_prompt
+from ...utils.blockchain import generate_test_peer_id
+from ...utils.blockchain.peer_id import validate_peer_id_format
+from ...utils.validation import validate_stake_amount_prompt, validate_subnet_id_prompt
+from ...utils.wallet.crypto import format_address_display
+
+console = HTCLIConsole()
+prompt = HTCLIPrompt()
+
+DELEGATE_RATE_SCALE = 10**18
+MIN_SCALED_DELEGATE_RATE = 10**12
+
+
+def normalize_delegate_reward_rate(value: int) -> int:
+    """Normalize CLI delegate reward rate input to the chain's 1e18 scale."""
+    if value < 0:
+        raise ValueError("Delegate reward rate must be non-negative")
+    if value <= 100:
+        return int(value * DELEGATE_RATE_SCALE / 100)
+    if MIN_SCALED_DELEGATE_RATE <= value <= DELEGATE_RATE_SCALE:
+        return value
+    raise ValueError(
+        "Delegate reward rate must be 0-100 percent or a 1e18-format value"
+    )
+
+
+def prompt_node_register(
+    subnet_id: Optional[int] = None,
+    validator_id: Optional[int] = None,
+    hotkey: Optional[str] = None,
+    stake_amount: Optional[float] = None,
+    peer_id: Optional[str] = None,
+    bootnode_peer_id: Optional[str] = None,
+    client_peer_id: Optional[str] = None,
+    coldkey_name: Optional[str] = None,
+) -> SubnetNodeRegisterRequest:
+    """Collect node registration parameters from user."""
+
+    console.print(info("Node Registration"))
+    console.print("Register a new node on an existing subnet.\n")
+
+    # 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
+
+    # Get subnet ID
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter the Subnet ID to register on",
+            min_value=0,
+        )
+
+    # Validate validator_id if provided
+    if validator_id is not None and (
+        not isinstance(validator_id, int) or validator_id < 0
+    ):
+        print_error("Invalid validator ID: must be a non-negative integer")
+        validator_id = None
+
+    # Get validator ID
+    if validator_id is None:
+        validator_id = prompt.integer_prompt(
+            "Enter the Validator ID that owns this node",
+            min_value=0,
+        )
+
+    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
+
+    # Get hotkey - try to resolve first (handles both wallet names and addresses)
+    # Use coldkey context for disambiguation if provided
+    if hotkey is not None:
+        try:
+            # Try to resolve the hotkey address with coldkey context for disambiguation
+            hotkey = client.offchain.wallet.resolve_hotkey_address(
+                hotkey,
+                owner_coldkey_name=coldkey_name,
+                owner_address=coldkey_address,
+            )
+            console.print(f"[htcli.success]✅ Using hotkey: {format_address_display(hotkey, truncate=False)}[/]")
+        except (ValueError, Exception) as e:
+            print_error(f"Invalid hotkey: {str(e)}")
+            hotkey = None
+
+    # Get hotkey if not provided or resolution failed
+    if hotkey is None:
+        from ...utils import retrieve_wallet_with_validation
+        from ...utils.wallet.crypto import get_wallet_info_by_name
+
+        console.print(info("\nHotkey Selection (used for node operations):"))
+        hotkey_wallet, hotkey_keypair = retrieve_wallet_with_validation(
+            wallet_type="hotkey", purpose="register the node"
+        )
+        # For ECDSA keys, compute EVM address directly from the keypair's public key
+        # This is more reliable than looking up wallet info with potentially mismatched owner params
+        # (the selected hotkey might have a different owner than the coldkey_name passed to this function)
+        from ...utils.wallet.crypto import public_key_to_evm_address
+
+        if hotkey_keypair is not None and hotkey_keypair.crypto_type == 2:  # ECDSA
+            # Compute EVM address directly from public key - same logic as save_hotkey
+            hotkey = public_key_to_evm_address(hotkey_keypair.public_key)
+        elif hotkey_keypair is not None:
+            # For other key types, use ss58_address
+            hotkey = hotkey_keypair.ss58_address
+        else:
+            # Fallback: try to get wallet info without owner disambiguation
+            # (the hotkey we just selected/created may have a different owner)
+            hotkey_wallet_info = get_wallet_info_by_name(
+                hotkey_wallet,
+                is_hotkey=True,
+            )
+            hotkey = hotkey_wallet_info.get("evm_address") or hotkey_wallet_info.get("address") or hotkey_wallet_info.get("ss58_address")
+
+        if not hotkey:
+            raise ValueError(f"Could not determine address for hotkey wallet '{hotkey_wallet}'")
+        console.print(f"[htcli.success]✅ Using hotkey: {format_address_display(hotkey, truncate=False)}[/]")
+
+    # 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
+
+    # Get stake amount
+    if stake_amount is None:
+        from ...ui.prompts import amount_prompt
+
+        stake_amount = amount_prompt(
+            "Enter stake amount",
+            currency="TENSOR",
+            min_amount=1.0,  # Minimum 1 TENSOR
+        )
+
+    # Auto-generate peer IDs if not provided
+    if peer_id is None or bootnode_peer_id is None or client_peer_id is None:
+        auto_generate = confirm_prompt("Auto-generate peer IDs?", default=True)
+
+        if auto_generate:
+            generated_peer_ids: set[str] = set()
+
+            def next_peer_id(current: Optional[str]) -> str:
+                if current:
+                    generated_peer_ids.add(current)
+                    return current
+                while True:
+                    seed = secrets.randbits(32)
+                    candidate = generate_test_peer_id(seed)
+                    if candidate not in generated_peer_ids:
+                        generated_peer_ids.add(candidate)
+                        return candidate
+
+            if peer_id is None:
+                peer_id = next_peer_id(peer_id)
+                console.print(f"[htcli.info]Generated peer_id: {peer_id[:50]}...[/]")
+            else:
+                generated_peer_ids.add(peer_id)
+
+            if bootnode_peer_id is None:
+                bootnode_peer_id = next_peer_id(bootnode_peer_id)
+                console.print(
+                    f"[htcli.info]Generated bootnode_peer_id: {bootnode_peer_id[:50]}...[/]"
+                )
+            else:
+                generated_peer_ids.add(bootnode_peer_id)
+
+            if client_peer_id is None:
+                client_peer_id = next_peer_id(client_peer_id)
+                console.print(
+                    f"[htcli.info]Generated client_peer_id: {client_peer_id[:50]}...[/]"
+                )
+        else:
+            # Manual entry
+            if peer_id is None:
+                peer_id = prompt.text_prompt("Enter peer_id")
+            if bootnode_peer_id is None:
+                bootnode_peer_id = prompt.text_prompt("Enter bootnode_peer_id")
+            if client_peer_id is None:
+                client_peer_id = prompt.text_prompt("Enter client_peer_id")
+
+    # Convert TENSOR to WEI for the request model (which expects WEI)
+    stake_amount_wei = int(stake_amount * 1e18)
+
+    # Set max_burn_amount (use stake amount as default, also in WEI)
+    max_burn_amount = stake_amount_wei
+
+    return SubnetNodeRegisterRequest(
+        subnet_id=subnet_id,
+        validator_id=validator_id,
+        hotkey=hotkey,
+        peer_id=peer_id,
+        bootnode_peer_id=bootnode_peer_id,
+        client_peer_id=client_peer_id,
+        stake_to_be_added=stake_amount_wei,
+        max_burn_amount=max_burn_amount,
+    )
+
+
+def prompt_node_peer_id_update(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+    peer_id: Optional[str] = None,
+    peer_id_type: str = "peer_id",  # "bootnode_peer_id" or "client_peer_id"
+) -> tuple[int, int, str]:
+    """
+    Collect parameters for node peer ID update.
+
+    Args:
+        subnet_id: Optional subnet ID
+        node_id: Optional node ID
+        peer_id: Optional new peer ID
+        peer_id_type: Type of peer ID being updated ("bootnode_peer_id" or "client_peer_id")
+
+    Returns:
+        Tuple of (subnet_id, node_id, peer_id)
+    """
+    console.print(info(f"Node {peer_id_type.replace('_', ' ').title()} Update"))
+    console.print(f"Update a node's {peer_id_type.replace('_', ' ')}.\n")
+
+    # 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
+
+    # Get subnet ID
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter the Subnet ID",
+            min_value=0,
+        )
+
+    # Validate node_id if provided
+    if node_id is not None:
+        if not isinstance(node_id, int) or node_id < 0:
+            print_error("Invalid node ID: must be a non-negative integer")
+            node_id = None
+
+    # Get node ID
+    if node_id is None:
+        node_id = prompt.integer_prompt(
+            "Enter the Node ID",
+            min_value=0,
+        )
+
+    # Validate peer_id if provided
+    if peer_id is not None:
+        if not peer_id or not isinstance(peer_id, str):
+            print_error("Invalid peer ID: must be a non-empty string")
+            peer_id = None
+        elif not validate_peer_id_format(peer_id):
+            print_error(
+                "Invalid peer ID format: must be a valid base58-encoded multihash "
+                "(e.g., starting with 'Qm', '12D3KooW', or '1')"
+            )
+            peer_id = None
+
+    # Get peer ID
+    if peer_id is None:
+        peer_id_label = peer_id_type.replace("_", " ").title()
+        peer_id = prompt.text_prompt(
+            f"Enter the new {peer_id_label}",
+            validator=lambda x: (
+                True if validate_peer_id_format(x) else "Invalid peer ID format. Must be a valid base58-encoded multihash."
+            ),
+        )
+
+    return subnet_id, node_id, peer_id
+
+
+def prompt_node_remove(
+    subnet_id: Optional[int] = None,
+    node_id: Optional[int] = None,
+) -> tuple[int, int]:
+    """
+    Collect parameters for node removal.
+
+    Args:
+        subnet_id: Optional subnet ID
+        node_id: Optional node ID
+
+    Returns:
+        Tuple of (subnet_id, node_id)
+    """
+    console.print(info("Node Removal"))
+    console.print("Remove a node from a subnet.\n")
+
+    # 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
+
+    # Get subnet ID
+    if subnet_id is None:
+        subnet_id = prompt.integer_prompt(
+            "Enter the Subnet ID",
+            min_value=0,
+        )
+
+    # Validate node_id if provided
+    if node_id is not None:
+        if not isinstance(node_id, int) or node_id < 0:
+            print_error("Invalid node ID: must be a non-negative integer")
+            node_id = None
+
+    # Get node ID
+    if node_id is None:
+        node_id = prompt.integer_prompt(
+            "Enter the Node ID",
+            min_value=0,
+        )
+
+    return subnet_id, node_id

src/htcli/commands/overwatch/__init__.py

@@ -0,0 +1,219 @@
+"""
+Overwatch command module for managing overwatch nodes.
+"""
+
+from typing import Optional
+from textwrap import dedent
+
+import typer
+
+from .handlers import (
+    add_overwatch_stake_handler,
+    check_overwatch_qualification_handler,
+    list_overwatch_nodes_handler,
+    register_overwatch_node_handler,
+    remove_overwatch_node_handler,
+    remove_overwatch_stake_handler,
+    set_overwatch_peer_id_handler,
+    get_overwatch_node_info_handler,
+)
+
+app = typer.Typer(name="overwatch", help="Overwatch node operations")
+
+
+CHECK_QUALIFICATION_HELP = dedent(
+    """\
+    Check if a coldkey can register an overwatch node.
+
+    This command checks all qualification requirements including:
+
+    \b
+    - Overwatch epochs started
+    - Network capacity available
+    - Coldkey age requirement
+    - Reputation score
+    - Subnet diversification ratio
+    - Average attestation rate
+    - Minimum stake balance
+
+    If --hotkey is provided, also validates:
+
+    \b
+    - Hotkey != coldkey
+    - Hotkey has no existing owner
+    - Hotkey not already registered
+
+    \b
+    Example:
+      htcli overwatch check-qualification --coldkey my-coldkey
+    """
+)
+
+REGISTER_HELP = dedent(
+    """\
+    Register a new overwatch node.
+
+    Requires meeting all qualification criteria (see check-qualification).
+
+    \b
+    Example:
+      htcli overwatch register --coldkey my-coldkey --hotkey my-hotkey --stake 1000
+    """
+)
+
+
+@app.command("check-qualification", help=CHECK_QUALIFICATION_HELP)
+def check_overwatch_qualification(
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="Coldkey wallet name or address to check qualification for",
+    ),
+    hotkey: Optional[str] = typer.Option(
+        None,
+        "--hotkey",
+        "-h",
+        help="Optional hotkey to validate (checks if hotkey can be used for registration)",
+    ),
+):
+    """Check if a coldkey can register an overwatch node."""
+    check_overwatch_qualification_handler(coldkey=coldkey, hotkey=hotkey)
+
+
+@app.command("register", help=REGISTER_HELP)
+def register_overwatch_node(
+    hotkey: Optional[str] = typer.Option(
+        None, "--hotkey", "-h", help="Hotkey address or name for the overwatch node"
+    ),
+    stake: Optional[float] = typer.Option(
+        None, "--stake", "-s", help="Initial stake amount (TENSOR)"
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="Coldkey wallet name or address to sign the registration",
+    ),
+):
+    """Register a new overwatch node."""
+    register_overwatch_node_handler(
+        hotkey=hotkey,
+        stake_amount=stake,
+        coldkey=coldkey,
+    )
+
+
+@app.command("remove")
+def remove_overwatch_node(
+    node_id: Optional[int] = typer.Option(
+        None, "--node-id", "-n", help="Overwatch node ID to remove"
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="Coldkey wallet name or address to sign the removal",
+    ),
+):
+    """Remove your overwatch node."""
+    remove_overwatch_node_handler(
+        overwatch_node_id=node_id,
+        coldkey=coldkey,
+    )
+
+
+@app.command("list")
+def list_overwatch_nodes():
+    """List all overwatch nodes."""
+    list_overwatch_nodes_handler()
+
+
+@app.command("info")
+def get_overwatch_node_info(
+    node_id: Optional[int] = typer.Option(
+        None, "--node-id", "-n", help="Overwatch node ID to get info for"
+    ),
+):
+    """Get detailed information about an overwatch node."""
+    get_overwatch_node_info_handler(overwatch_node_id=node_id)
+
+
+@app.command("set-peer-id")
+def set_overwatch_peer_id(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "-s", help="Subnet ID to set peer ID for"
+    ),
+    node_id: Optional[int] = typer.Option(
+        None, "--node-id", "-n", help="Overwatch node ID"
+    ),
+    peer_id: Optional[str] = typer.Option(
+        None, "--peer-id", "-p", help="Peer ID for the subnet"
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="Coldkey wallet name or address to sign the transaction",
+    ),
+):
+    """Set peer ID for an overwatch node on a specific subnet."""
+    set_overwatch_peer_id_handler(
+        subnet_id=subnet_id,
+        overwatch_node_id=node_id,
+        peer_id=peer_id,
+        coldkey=coldkey,
+    )
+
+
+@app.command("add-stake")
+def add_overwatch_stake(
+    node_id: Optional[int] = typer.Option(
+        None, "--node-id", "-n", help="Overwatch node ID"
+    ),
+    hotkey: Optional[str] = typer.Option(
+        None, "--hotkey", "-h", help="Hotkey of the overwatch node"
+    ),
+    amount: Optional[float] = typer.Option(
+        None, "--amount", "-a", help="Amount to stake (TENSOR)"
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="Coldkey wallet name or address to sign the transaction",
+    ),
+):
+    """Add stake to an overwatch node."""
+    add_overwatch_stake_handler(
+        overwatch_node_id=node_id,
+        hotkey=hotkey,
+        stake_amount=amount,
+        coldkey=coldkey,
+    )
+
+
+@app.command("remove-stake")
+def remove_overwatch_stake(
+    hotkey: Optional[str] = typer.Option(
+        None, "--hotkey", "-h", help="Hotkey of the overwatch node"
+    ),
+    amount: Optional[float] = typer.Option(
+        None, "--amount", "-a", help="Amount to unstake (TENSOR)"
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="Coldkey wallet name or address to sign the transaction",
+    ),
+):
+    """Remove stake from an overwatch node."""
+    remove_overwatch_stake_handler(
+        hotkey=hotkey,
+        stake_amount=amount,
+        coldkey=coldkey,
+    )
+
+
+__all__ = ["app"]