htcli 1.1.0__py3-none-any.whl

src/htcli/utils/validation/prompt_validators.py

@@ -0,0 +1,267 @@
+"""
+Prompt validation functions extracted from Pydantic models.
+
+These validators return (bool, Optional[str]) tuples:
+- bool: True if valid, False if invalid
+- Optional[str]: Error message if invalid, None if valid
+"""
+
+from typing import Optional, Union
+
+
+def validate_subnet_name(name: Union[str, None]) -> tuple[bool, Optional[str]]:
+    """Validate subnet name."""
+    if name is None:
+        return False, "Subnet name cannot be None"
+    if not name or not name.strip():
+        return False, "Subnet name cannot be empty"
+    if len(name.strip()) > 1024:
+        return False, "Subnet name must be 1024 characters or less"
+    return True, None
+
+
+def validate_subnet_repo(repo: Union[str, None]) -> tuple[bool, Optional[str]]:
+    """Validate repository URL."""
+    import re
+    
+    if repo is None:
+        return False, "Repository URL cannot be None"
+    if not repo or not repo.strip():
+        return False, "Repository URL cannot be empty"
+    if len(repo.strip()) > 1024:
+        return False, "Repository URL must be 1024 characters or less"
+    
+    # Validate URL format - must be http:// or https://
+    repo_stripped = repo.strip()
+    if not re.match(r"^https?://[^\s/$.?#].[^\s]*$", repo_stripped):
+        return False, "Repository URL must be a valid HTTP/HTTPS URL (e.g., https://github.com/user/repo)"
+    
+    return True, None
+
+
+def validate_subnet_min_stake(min_stake: Union[int, None]) -> tuple[bool, Optional[str]]:
+    """Validate minimum stake (in wei).
+    
+    Requirements:
+    - Must be at least 100 TENSOR (100 * 1e18 wei)
+    """
+    MIN_TENSOR = 100
+    MIN_WEI = int(MIN_TENSOR * 1e18)  # 100 TENSOR
+    
+    if min_stake is None:
+        return False, "Minimum stake cannot be None"
+    if min_stake < 0:
+        return False, "min_stake cannot be negative"
+    if min_stake < MIN_WEI:
+        return False, f"min_stake must be at least {MIN_TENSOR} TENSOR (got {min_stake / 1e18:.4f} TENSOR)"
+    return True, None
+
+
+def validate_subnet_max_stake(
+    max_stake: Union[int, None], min_stake: Optional[int] = None
+) -> tuple[bool, Optional[str]]:
+    """Validate maximum stake (in wei).
+    
+    Requirements:
+    - Must be at most 1000 TENSOR (1000 * 1e18 wei)
+    - Must be greater than or equal to min_stake
+    """
+    MAX_TENSOR = 1000
+    MAX_WEI = int(MAX_TENSOR * 1e18)  # 1000 TENSOR
+    
+    if max_stake is None:
+        return False, "Maximum stake cannot be None"
+    if max_stake < 0:
+        return False, "max_stake cannot be negative"
+    if max_stake > MAX_WEI:
+        return False, f"max_stake must be at most {MAX_TENSOR} TENSOR (got {max_stake / 1e18:.4f} TENSOR)"
+    if min_stake is not None and max_stake < min_stake:
+        return False, f"max_stake must be greater than or equal to min_stake (min: {min_stake / 1e18:.4f} TENSOR, max: {max_stake / 1e18:.4f} TENSOR)"
+    return True, None
+
+
+def validate_subnet_delegate_stake_percentage(
+    percentage: Union[int, None]
+) -> tuple[bool, Optional[str]]:
+    """Validate delegate stake percentage (in wei format)."""
+    if percentage is None:
+        return False, "Delegate stake percentage cannot be None"
+    MIN_ALLOWED = 50_000_000_000_000_000  # 5%
+    MAX_ALLOWED = 950_000_000_000_000_000  # 95%
+    if percentage < MIN_ALLOWED or percentage > MAX_ALLOWED:
+        return False, f"delegate_stake_percentage must be between {MIN_ALLOWED / 1e16:.0f}% and {MAX_ALLOWED / 1e16:.0f}%"
+    return True, None
+
+
+def validate_subnet_max_registered_nodes(
+    max_nodes: Union[int, None]
+) -> tuple[bool, Optional[str]]:
+    """Validate maximum registered nodes."""
+    if max_nodes is None:
+        return False, "Maximum registered nodes cannot be None"
+    if max_nodes < 1 or max_nodes > 64:
+        return False, "max_registered_nodes must be between 1 and 64"
+    return True, None
+
+
+def validate_subnet_bootnodes(bootnodes: Union[set, list, None]) -> tuple[bool, Optional[str]]:
+    """Validate bootnodes."""
+    if bootnodes is None:
+        return True, None  # Bootnodes are optional
+    if bootnodes and len(bootnodes) > 32:
+        return False, "Too many bootnodes (maximum 32)"
+    return True, None
+
+
+def validate_subnet_initial_coldkeys(
+    coldkeys: Union[dict, list, None]
+) -> tuple[bool, Optional[str]]:
+    """Validate initial coldkeys."""
+    if coldkeys is None:
+        return True, None  # Initial coldkeys are optional
+    if isinstance(coldkeys, dict):
+        if coldkeys and len(coldkeys) > 0 and len(coldkeys) < 3:
+            return False, "If providing initial coldkeys, provide at least 3 for meaningful consensus"
+        # Validate max_registrations values
+        for address, max_regs in coldkeys.items():
+            if max_regs < 1:
+                return False, f"max_registrations for {address} must be >= 1, got {max_regs}"
+    elif isinstance(coldkeys, list):
+        if coldkeys and len(coldkeys) > 0 and len(coldkeys) < 3:
+            return False, "If providing initial coldkeys, provide at least 3 for meaningful consensus"
+    return True, None
+
+
+def validate_hotkey_address(address: Union[str, None]) -> tuple[bool, Optional[str]]:
+    """Validate hotkey address (Ethereum format)."""
+    if address is None:
+        return False, "Hotkey address cannot be None"
+    if not address or len(address) != 42 or not address.startswith("0x"):
+        return False, "Hotkey must be a valid Ethereum address (0x + 40 hex characters)"
+    # Check hex characters
+    hex_part = address[2:]
+    if not all(c in "0123456789abcdefABCDEF" for c in hex_part):
+        return False, "Hotkey address contains invalid hex characters"
+    return True, None
+
+
+def validate_wallet_name(name: Union[str, None]) -> tuple[bool, Optional[str]]:
+    """Validate wallet name."""
+    if name is None:
+        return False, "Wallet name cannot be None"
+    if not name or not name.strip():
+        return False, "Wallet name cannot be empty"
+    if len(name.strip()) > 50:
+        return False, "Wallet name must be 50 characters or less"
+    # Should be alphanumeric with hyphens and underscores
+    import re
+    if not re.match(r"^[a-zA-Z0-9_-]+$", name.strip()):
+        return False, "Wallet name must contain only alphanumeric characters, hyphens, and underscores"
+    return True, None
+
+
+def validate_subnet_id(subnet_id: Union[int, str, None]) -> tuple[bool, Optional[str]]:
+    """Validate subnet ID."""
+    if subnet_id is None:
+        return False, "Subnet ID cannot be None"
+    try:
+        if isinstance(subnet_id, str):
+            subnet_id = int(subnet_id)
+        if subnet_id < 0:
+            return False, "Subnet ID must be non-negative"
+        return True, None
+    except (ValueError, TypeError):
+        return False, "Subnet ID must be a valid integer"
+
+
+def validate_node_id(node_id: Union[int, str, None]) -> tuple[bool, Optional[str]]:
+    """Validate node ID."""
+    if node_id is None:
+        return False, "Node ID cannot be None"
+    try:
+        if isinstance(node_id, str):
+            node_id = int(node_id)
+        if node_id < 0:
+            return False, "Node ID must be non-negative"
+        return True, None
+    except (ValueError, TypeError):
+        return False, "Node ID must be a valid integer"
+
+
+def validate_stake_amount(amount: Union[int, float, str, None]) -> tuple[bool, Optional[str]]:
+    """Validate stake amount.
+    
+    All amounts are treated as TENSOR and converted to WEI for validation.
+    Integers, floats, and strings are all assumed to be in TENSOR units.
+    """
+    if amount is None:
+        return False, "Stake amount cannot be None"
+    try:
+        # Convert to float first to handle all input types
+        if isinstance(amount, str):
+            amount_float = float(amount)
+        elif isinstance(amount, int):
+            # Integers are treated as TENSOR (e.g., 80 = 80 TENSOR)
+            amount_float = float(amount)
+        elif isinstance(amount, float):
+            amount_float = amount
+        else:
+            return False, "Stake amount must be a valid number"
+        
+        # Convert TENSOR to WEI for validation
+        amount_wei = int(amount_float * 1e18)
+        
+        if amount_wei <= 0:
+            return False, "Stake amount must be positive"
+        if amount_wei < 1e15:  # 0.001 TENSOR minimum
+            return False, "Stake amount too small (minimum 0.001 TENSOR)"
+        return True, None
+    except (ValueError, TypeError):
+        return False, "Stake amount must be a valid number"
+
+
+def validate_rpc_url(url: Union[str, None]) -> tuple[bool, Optional[str]]:
+    """Validate RPC URL."""
+    if url is None:
+        return False, "RPC URL cannot be None"
+    if not url or not url.strip():
+        return False, "RPC URL cannot be empty"
+    import re
+    if not re.match(r"^(ws|wss|http|https)://", url.strip()):
+        return False, "RPC URL must start with ws://, wss://, http://, or https://"
+    if len(url.strip()) < 10:
+        return False, "RPC URL is too short"
+    return True, None
+
+
+def validate_timeout(timeout: Union[int, str, None]) -> tuple[bool, Optional[str]]:
+    """Validate timeout value."""
+    if timeout is None:
+        return False, "Timeout cannot be None"
+    try:
+        if isinstance(timeout, str):
+            timeout = int(timeout)
+        if timeout < 1:
+            return False, "Timeout must be at least 1 second"
+        if timeout > 3600:
+            return False, "Timeout must be at most 3600 seconds (1 hour)"
+        return True, None
+    except (ValueError, TypeError):
+        return False, "Timeout must be a valid integer"
+
+
+def validate_retry_attempts(attempts: Union[int, str, None]) -> tuple[bool, Optional[str]]:
+    """Validate retry attempts."""
+    if attempts is None:
+        return False, "Retry attempts cannot be None"
+    try:
+        if isinstance(attempts, str):
+            attempts = int(attempts)
+        if attempts < 0:
+            return False, "Retry attempts must be non-negative"
+        if attempts > 100:
+            return False, "Retry attempts must be at most 100"
+        return True, None
+    except (ValueError, TypeError):
+        return False, "Retry attempts must be a valid integer"
+

src/htcli/utils/wallet/__init__.py

@@ -0,0 +1,65 @@
+"""
+Wallet utilities for the Hypertensor CLI.
+Handles wallet creation, management, authentication, and cryptographic operations.
+"""
+
+from .core import (
+    create_keypair_from_mnemonic,
+    generate_mnemonic,
+    prompt_for_wallet_and_keypair,
+    prompt_for_wallet_selection,
+    retrieve_wallet_with_validation,
+)
+from .crypto import (
+    KeypairInfo,
+    decrypt_private_key,
+    delete_coldkey_and_hotkeys,
+    delete_keypair,
+    encrypt_private_key,
+    generate_coldkey_pair,
+    generate_hotkey_pair,
+    get_wallet_directory,
+    get_wallet_info_by_name,
+    import_hotkey_from_mnemonic,
+    import_hotkey_from_private_key,
+    import_keypair,
+    import_keypair_from_mnemonic,
+    import_preseeded_wallet,
+    list_keys,
+    load_keypair,
+    update_coldkey,
+    update_hotkey,
+    wallet_name_exists,
+)
+
+__all__ = [
+    # Wallet creation and import operations
+    "generate_coldkey_pair",
+    "generate_hotkey_pair",
+    "import_keypair",
+    "import_keypair_from_mnemonic",
+    "import_hotkey_from_private_key",
+    "import_hotkey_from_mnemonic",
+    "import_preseeded_wallet",
+    # Wallet management
+    "get_wallet_info_by_name",
+    "list_keys",
+    "wallet_name_exists",
+    "load_keypair",
+    "delete_keypair",
+    "delete_coldkey_and_hotkeys",
+    "update_coldkey",
+    "update_hotkey",
+    # Cryptographic operations
+    "encrypt_private_key",
+    "decrypt_private_key",
+    # Core utilities
+    "generate_mnemonic",
+    "create_keypair_from_mnemonic",
+    "prompt_for_wallet_selection",
+    "prompt_for_wallet_and_keypair",
+    "retrieve_wallet_with_validation",
+    # Utilities
+    "get_wallet_directory",
+    "KeypairInfo",
+]

src/htcli/utils/wallet/auth.py

@@ -0,0 +1,151 @@
+import sys
+import termios
+import tty
+from typing import Optional
+
+from rich.console import Console
+from rich.prompt import Prompt
+from substrateinterface import Keypair
+
+from .crypto import get_wallet_info_by_name, load_keypair
+
+# Use a single console instance for consistent output
+_console = Console()
+
+
+def _clear_line():
+    """Clear the current line using ANSI escape codes."""
+    # Use carriage return and clear to end of line
+    sys.stdout.write("\r\033[K")
+    sys.stdout.flush()
+
+
+def get_secure_password(prompt_message: str, min_length: int = 8) -> str:
+    """Get a secure password from the user."""
+    console = Console()
+    while True:
+        password = Prompt.ask(prompt_message, password=True)
+        # Clear the prompt line after input
+        _clear_line()
+        if (
+            len(password) >= min_length
+            and any(char.isdigit() for char in password)
+            and any(char.isalpha() for char in password)
+        ):
+            return password
+        else:
+            console.print(
+                f"[red]Password must be at least {min_length} characters long and contain both letters and numbers.[/red]"
+            )
+
+
+def get_unlock_password(
+    wallet_name: str, prompt_message: str, max_attempts: int = 3, silent: bool = False
+) -> str:
+    """Get password to unlock a wallet with retry attempts."""
+    for attempt in range(max_attempts):
+        # Clear any previous output before showing prompt
+        _clear_line()
+        password = Prompt.ask(prompt_message, password=True)
+        # Clear the prompt line immediately after input
+        _clear_line()
+        if password:
+            return password
+        else:
+            if not silent:
+                _console.print(
+                    f"[red]Password cannot be empty. {max_attempts - attempt - 1} attempts remaining.[/red]"
+                )
+                # Clear the error message after a brief moment
+                import time
+
+                time.sleep(0.1)
+                sys.stdout.write("\033[1A\033[K")
+                sys.stdout.flush()
+    raise ValueError("Failed to get password after multiple attempts.")
+
+
+def get_wallet_with_retry(
+    name: str,
+    max_attempts: int = 3,
+    silent: bool = False,
+    is_hotkey: Optional[bool] = None,
+    owner_address: Optional[str] = None,
+) -> tuple[Keypair, dict]:
+    """Get wallet with password retry attempts.
+
+    Args:
+        name: Wallet name
+        max_attempts: Maximum password attempts
+        silent: If True, suppress intermediate error messages (only show final failure)
+        is_hotkey: Optional hint to specify if this is a hotkey (True) or coldkey (False)
+        owner_address: Optional coldkey address for hotkey disambiguation
+    """
+    wallet_info = get_wallet_info_by_name(
+        name, is_hotkey=is_hotkey, owner_address=owner_address
+    )
+    # Extract actual values from wallet_info
+    actual_is_hotkey = wallet_info.get("is_hotkey", False)
+    actual_owner_address = wallet_info.get("owner_address")
+
+    if not wallet_info.get("is_encrypted", True):
+        return (
+            load_keypair(
+                name,
+                None,
+                is_hotkey=actual_is_hotkey,
+                owner_address=actual_owner_address,
+            ),
+            wallet_info,
+        )
+    attempts = 0
+    while attempts < max_attempts:
+        try:
+            attempts += 1
+            password = get_unlock_password(
+                name, f"Enter password for wallet '{name}'", silent=silent
+            )
+            # Password line is already cleared by get_unlock_password
+            keypair = load_keypair(
+                name,
+                password,
+                is_hotkey=actual_is_hotkey,
+                owner_address=actual_owner_address,
+            )
+            # Clear line after successful unlock
+            _clear_line()
+            return keypair, wallet_info
+        except ValueError as e:
+            if "Invalid password" in str(e):
+                # Clear line after invalid password - don't show error messages if silent
+                _clear_line()
+                if not silent and attempts < max_attempts:
+                    # Only show error if not silent and not on final attempt
+                    remaining = max_attempts - attempts
+                    _console.print(
+                        f"[red]❌ Error: Invalid password. {remaining} attempts remaining.[/red]"
+                    )
+                    # Clear the error after a brief moment
+                    import time
+
+                    time.sleep(0.15)
+                    sys.stdout.write("\033[1A\033[K")  # Move up and clear error line
+                    sys.stdout.flush()
+            else:
+                raise
+        except Exception as e:
+            # Clear line after error
+            _clear_line()
+            if not silent and attempts < max_attempts:
+                remaining = max_attempts - attempts
+                _console.print(
+                    f"[red]❌ Error: {str(e)}. {remaining} attempts remaining.[/red]"
+                )
+                import time
+
+                time.sleep(0.15)
+                sys.stdout.write("\033[1A\033[K")
+                sys.stdout.flush()
+            elif attempts >= max_attempts:
+                raise Exception(f"Failed to load wallet '{name}': {str(e)}") from e
+    raise Exception(f"Failed to unlock wallet '{name}' after {max_attempts} attempts")