htcli 1.1.0__py3-none-any.whl

src/htcli/utils/blockchain/validation.py

@@ -0,0 +1,179 @@
+"""
+Blockchain validation utilities with EVM/ECDSA focus.
+Validates addresses, amounts, and other blockchain-related inputs.
+"""
+
+import re
+from pathlib import Path
+from typing import Optional, Union
+
+
+def validate_address(address: str) -> bool:
+    """Validate an EVM/Ethereum address format."""
+    if not address:
+        return False
+    if address.startswith("0x") and len(address) == 42:
+        try:
+            int(address[2:], 16)
+            return True
+        except ValueError:
+            return False
+    return False
+
+
+def validate_ethereum_address(address: str) -> bool:
+    """Validate Ethereum address format (alias for validate_address)."""
+    return validate_address(address)
+
+
+def validate_hotkey_address(address: str) -> bool:
+    """Validate hotkey address - should be Bytes20 format for EVM compatibility."""
+    return validate_ethereum_address(address)
+
+
+def validate_amount(amount: Union[str, float, int]) -> bool:
+    """Validate a token amount."""
+    try:
+        if isinstance(amount, str):
+            amount = float(amount)
+        return isinstance(amount, (int, float)) and amount > 0
+    except (ValueError, TypeError):
+        return False
+
+
+def validate_subnet_id(subnet_id: Union[str, int]) -> bool:
+    """Validate a subnet ID."""
+    try:
+        if isinstance(subnet_id, str):
+            subnet_id = int(subnet_id)
+        return isinstance(subnet_id, int) and subnet_id >= 0
+    except (ValueError, TypeError):
+        return False
+
+
+def validate_node_id(node_id: Union[str, int]) -> bool:
+    """Validate a node ID."""
+    try:
+        if isinstance(node_id, str):
+            node_id = int(node_id)
+        return isinstance(node_id, int) and node_id >= 0
+    except (ValueError, TypeError):
+        return False
+
+
+def validate_peer_id(peer_id: str) -> bool:
+    """Validate a peer ID format."""
+    if not peer_id or not isinstance(peer_id, str):
+        return False
+    valid_prefixes = ["12D3KooW", "Qm", "1"]
+    return any(peer_id.startswith(prefix) for prefix in valid_prefixes)
+
+
+def validate_key_type(key_type: str) -> bool:
+    """Validate cryptographic key type."""
+    valid_types = ["ecdsa", "secp256k1", "sr25519", "ed25519"]
+    return key_type.lower() in valid_types
+
+
+def validate_password(password: Optional[str]) -> bool:
+    """Validate password strength."""
+    if password is None:
+        return True
+    if not isinstance(password, str) or len(password) < 8:
+        return False
+    return True
+
+
+def validate_file_path(file_path: str) -> bool:
+    """Validate file path format and accessibility."""
+    try:
+        path = Path(file_path)
+        if not str(path):
+            return False
+        parent = path.parent
+        return parent.exists() or parent == Path(".")
+    except Exception:
+        return False
+
+
+def validate_wallet_name(wallet_name: str) -> bool:
+    """Validate wallet name format."""
+    if not wallet_name or not isinstance(wallet_name, str):
+        return False
+    pattern = r"^[a-zA-Z0-9_-]+$"
+    if not re.match(pattern, wallet_name):
+        return False
+    if len(wallet_name) < 1 or len(wallet_name) > 64:
+        return False
+    if wallet_name.startswith(("-", "_")) or wallet_name.endswith(("-", "_")):
+        return False
+    return True
+
+
+def validate_network_url(url: str) -> bool:
+    """Validate network URL format."""
+    if not url or not isinstance(url, str):
+        return False
+    valid_schemes = ["ws://", "wss://", "http://", "https://"]
+    return any(url.startswith(scheme) for scheme in valid_schemes)
+
+
+def validate_hex_string(hex_str: str, expected_length: Optional[int] = None) -> bool:
+    """Validate hexadecimal string format."""
+    if not hex_str or not isinstance(hex_str, str):
+        return False
+    if hex_str.startswith("0x"):
+        hex_str = hex_str[2:]
+    try:
+        int(hex_str, 16)
+    except ValueError:
+        return False
+    if expected_length is not None:
+        return len(hex_str) == expected_length
+    return True
+
+
+def validate_mnemonic(mnemonic: str) -> bool:
+    """Validate mnemonic phrase format."""
+    if not mnemonic or not isinstance(mnemonic, str):
+        return False
+    words = mnemonic.strip().split()
+    valid_lengths = [12, 15, 18, 21, 24]
+    if len(words) not in valid_lengths:
+        return False
+    for word in words:
+        if not re.match(r"^[a-z]+$", word):
+            return False
+    return True
+
+
+def validate_tensor_amount(amount: Union[str, float, int]) -> bool:
+    """Validate TENSOR token amount."""
+    try:
+        from .formatting import TensorAmount
+
+        tensor_amount = TensorAmount(amount)
+        return tensor_amount.is_valid()
+    except (ValueError, TypeError):
+        return False
+
+
+def detect_address_type(address: str) -> tuple[str, str, bool]:
+    """Detect the type and format of an address."""
+    if not address:
+        return "unknown", "Invalid", False
+    if address.startswith("0x"):
+        if len(address) == 42:
+            return "ecdsa", "EVM/ECDSA (20-byte)", True
+        else:
+            return (
+                "invalid_evm",
+                f"Invalid EVM (expected 42 chars, got {len(address)})",
+                False,
+            )
+    elif len(address) > 40 and address[0].isdigit():
+        return "ss58", "SS58/Substrate (32-byte)", False
+    elif len(address) < 20:
+        return "unknown", "Too Short", False
+    else:
+        return "unknown", "Unknown Format", False