htcli 1.1.0__py3-none-any.whl

src/htcli/utils/network/subnet.py

@@ -0,0 +1,344 @@
+"""
+Subnet management and registry utilities.
+Handles subnet manifest operations and network-specific functionality.
+"""
+
+import json
+from pathlib import Path
+from time import time
+from typing import Any, Optional
+
+from ...utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_subnet_registry_path() -> Path:
+    """Get the path to the subnet registry file."""
+    home = Path.home()
+    registry_dir = home / ".htcli" / "registry"
+    registry_dir.mkdir(parents=True, exist_ok=True)
+    return registry_dir / "subnets.json"
+
+
+def load_subnet_registry() -> dict[str, Any]:
+    """
+    Load the subnet registry from file.
+
+    Returns:
+        Dictionary containing subnet registry data
+    """
+    registry_path = get_subnet_registry_path()
+
+    if not registry_path.exists():
+        return {"subnets": {}, "metadata": {"version": "1.0"}}
+
+    try:
+        with open(registry_path) as f:
+            return json.load(f)
+    except (OSError, json.JSONDecodeError) as e:
+        logger.error(f"Failed to load subnet registry: {e}")
+        return {"subnets": {}, "metadata": {"version": "1.0"}}
+
+
+def save_subnet_registry(registry_data: dict[str, Any]) -> bool:
+    """
+    Save the subnet registry to file.
+
+    Args:
+        registry_data: Registry data to save
+
+    Returns:
+        True if saved successfully, False otherwise
+    """
+    registry_path = get_subnet_registry_path()
+
+    try:
+        with open(registry_path, "w") as f:
+            json.dump(registry_data, f, indent=2)
+        return True
+    except OSError as e:
+        logger.error(f"Failed to save subnet registry: {e}")
+        return False
+
+
+def add_subnet_to_registry(
+    subnet_id: int, subnet_data: dict[str, Any], owner_address: Optional[str] = None
+) -> bool:
+    """
+    Add a subnet to the local registry.
+
+    Args:
+        subnet_id: Subnet ID
+        subnet_data: Subnet information
+        owner_address: Optional owner address
+
+    Returns:
+        True if added successfully, False otherwise
+    """
+    try:
+        registry = load_subnet_registry()
+
+        subnet_entry = {
+            "id": subnet_id,
+            "name": subnet_data.get("name", f"Subnet {subnet_id}"),
+            "description": subnet_data.get("description", ""),
+            "owner": owner_address or subnet_data.get("owner", ""),
+            "status": subnet_data.get("status", "unknown"),
+            "created_at": subnet_data.get("created_at"),
+            "updated_at": subnet_data.get("updated_at"),
+            "metadata": subnet_data.get("metadata", {}),
+        }
+
+        registry["subnets"][str(subnet_id)] = subnet_entry
+
+        return save_subnet_registry(registry)
+
+    except Exception as e:
+        logger.error(f"Failed to add subnet {subnet_id} to registry: {e}")
+        return False
+
+
+def get_subnet_from_registry(subnet_id: int) -> Optional[dict[str, Any]]:
+    """
+    Get subnet information from the local registry.
+
+    Args:
+        subnet_id: Subnet ID to retrieve
+
+    Returns:
+        Subnet information or None if not found
+    """
+    try:
+        registry = load_subnet_registry()
+        return registry["subnets"].get(str(subnet_id))
+    except Exception as e:
+        logger.error(f"Failed to get subnet {subnet_id} from registry: {e}")
+        return None
+
+
+def remove_subnet_from_registry(subnet_id: int) -> bool:
+    """
+    Remove a subnet from the local registry.
+
+    Args:
+        subnet_id: Subnet ID to remove
+
+    Returns:
+        True if removed successfully, False otherwise
+    """
+    try:
+        registry = load_subnet_registry()
+
+        if str(subnet_id) in registry["subnets"]:
+            del registry["subnets"][str(subnet_id)]
+            return save_subnet_registry(registry)
+
+        return False  # Subnet not found
+
+    except Exception as e:
+        logger.error(f"Failed to remove subnet {subnet_id} from registry: {e}")
+        return False
+
+
+def list_registered_subnets(owner_filter: Optional[str] = None) -> list[dict[str, Any]]:
+    """
+    List all registered subnets.
+
+    Args:
+        owner_filter: Optional owner address to filter by
+
+    Returns:
+        List of subnet information dictionaries
+    """
+    try:
+        registry = load_subnet_registry()
+        subnets = []
+
+        for subnet_data in registry["subnets"].values():
+            if owner_filter and subnet_data.get("owner") != owner_filter:
+                continue
+
+            subnets.append(subnet_data)
+
+        # Sort by subnet ID
+        return sorted(subnets, key=lambda x: x.get("id", 0))
+
+    except Exception as e:
+        logger.error(f"Failed to list registered subnets: {e}")
+        return []
+
+
+def validate_subnet_manifest(manifest: dict[str, Any]) -> tuple[bool, list[str]]:
+    """
+    Validate a subnet manifest structure.
+
+    Args:
+        manifest: Subnet manifest to validate
+
+    Returns:
+        Tuple of (is_valid, error_messages)
+    """
+    errors = []
+
+    # Required fields
+    required_fields = ["name", "description", "version"]
+    for field in required_fields:
+        if field not in manifest:
+            errors.append(f"Missing required field: {field}")
+
+    # Validate name
+    name = manifest.get("name", "")
+    if not name or not isinstance(name, str) or len(name) > 100:
+        errors.append("Name must be a non-empty string with max 100 characters")
+
+    # Validate description
+    description = manifest.get("description", "")
+    if not description or not isinstance(description, str) or len(description) > 500:
+        errors.append("Description must be a non-empty string with max 500 characters")
+
+    # Validate version
+    version = manifest.get("version", "")
+    if not version or not isinstance(version, str):
+        errors.append("Version must be a non-empty string")
+
+    # Validate optional fields
+    if "tags" in manifest:
+        tags = manifest["tags"]
+        if not isinstance(tags, list) or any(not isinstance(tag, str) for tag in tags):
+            errors.append("Tags must be a list of strings")
+
+    if "repository" in manifest:
+        repo = manifest["repository"]
+        if not isinstance(repo, str) or not repo.startswith(
+            ("http://", "https://", "git://")
+        ):
+            errors.append("Repository must be a valid URL")
+
+    # Validate configuration if present
+    if "config" in manifest:
+        config = manifest["config"]
+        if not isinstance(config, dict):
+            errors.append("Config must be a dictionary")
+        else:
+            # Validate specific config fields
+            if "min_stake" in config:
+                min_stake = config["min_stake"]
+                if not isinstance(min_stake, (int, float)) or min_stake < 0:
+                    errors.append("min_stake must be a non-negative number")
+
+            if "max_nodes" in config:
+                max_nodes = config["max_nodes"]
+                if not isinstance(max_nodes, int) or max_nodes < 1:
+                    errors.append("max_nodes must be a positive integer")
+
+    return len(errors) == 0, errors
+
+
+def create_subnet_manifest(
+    name: str,
+    description: str,
+    version: str = "1.0.0",
+    tags: Optional[list[str]] = None,
+    repository: Optional[str] = None,
+    config: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    """
+    Create a subnet manifest with the provided information.
+
+    Args:
+        name: Subnet name
+        description: Subnet description
+        version: Subnet version
+        tags: Optional tags
+        repository: Optional repository URL
+        config: Optional configuration
+
+    Returns:
+        Subnet manifest dictionary
+    """
+    manifest = {
+        "name": name,
+        "description": description,
+        "version": version,
+        "created_at": str(int(time.time()) if "time" in globals() else 0),
+    }
+
+    if tags:
+        manifest["tags"] = tags
+
+    if repository:
+        manifest["repository"] = repository
+
+    if config:
+        manifest["config"] = config
+
+    return manifest
+
+
+def update_subnet_registry_entry(subnet_id: int, updates: dict[str, Any]) -> bool:
+    """
+    Update a subnet registry entry with new information.
+
+    Args:
+        subnet_id: Subnet ID to update
+        updates: Dictionary of fields to update
+
+    Returns:
+        True if updated successfully, False otherwise
+    """
+    try:
+        registry = load_subnet_registry()
+
+        if str(subnet_id) not in registry["subnets"]:
+            return False  # Subnet not found
+
+        subnet_entry = registry["subnets"][str(subnet_id)]
+
+        # Update allowed fields
+        allowed_fields = ["name", "description", "status", "metadata", "updated_at"]
+        for field, value in updates.items():
+            if field in allowed_fields:
+                subnet_entry[field] = value
+
+        return save_subnet_registry(registry)
+
+    except Exception as e:
+        logger.error(f"Failed to update subnet {subnet_id} in registry: {e}")
+        return False
+
+
+def get_subnet_statistics() -> dict[str, Any]:
+    """
+    Get statistics about registered subnets.
+
+    Returns:
+        Statistics dictionary
+    """
+    try:
+        registry = load_subnet_registry()
+        subnets = registry["subnets"]
+
+        # Count by status
+        status_counts = {}
+        owner_counts = {}
+
+        for subnet in subnets.values():
+            status = subnet.get("status", "unknown")
+            status_counts[status] = status_counts.get(status, 0) + 1
+
+            owner = subnet.get("owner", "unknown")
+            if owner != "unknown":
+                owner_counts[owner] = owner_counts.get(owner, 0) + 1
+
+        return {
+            "total_subnets": len(subnets),
+            "status_breakdown": status_counts,
+            "top_owners": dict(
+                sorted(owner_counts.items(), key=lambda x: x[1], reverse=True)[:10]
+            ),
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to get subnet statistics: {e}")
+        return {"total_subnets": 0, "status_breakdown": {}, "top_owners": {}}

src/htcli/utils/prompts.py

@@ -0,0 +1,27 @@
+"""
+Utility functions for prompting user input.
+"""
+
+from typing import Optional
+
+from rich.prompt import Confirm, IntPrompt, Prompt
+
+
+def string_prompt(message: str, default: Optional[str] = None) -> str:
+    """Prompt for a string input."""
+    return Prompt.ask(message, default=default)
+
+
+def integer_prompt(message: str, default: Optional[int] = None) -> int:
+    """Prompt for an integer input."""
+    return IntPrompt.ask(message, default=default)
+
+
+def confirm_prompt(message: str, default: bool = False) -> bool:
+    """Prompt for a yes/no confirmation."""
+    return Confirm.ask(message, default=default)
+
+
+def choice_prompt(message: str, choices: list, default: Optional[str] = None) -> str:
+    """Prompt for a choice from a list of options."""
+    return Prompt.ask(message, choices=choices, default=default)

src/htcli/utils/scale_codec.py

@@ -0,0 +1,155 @@
+"""
+SCALE codec utilities for HTCLI.
+
+This module provides SCALE encoding/decoding utilities following the mesh.substrate patterns.
+It uses the centralized type registry from blockchain.type_registry for consistency.
+"""
+
+from enum import Enum
+from typing import Optional, Union
+
+from scalecodec import ScaleBytes
+
+from .blockchain.type_registry import get_rpc_runtime_config
+
+
+class ChainDataType(Enum):
+    """
+    Enum for chain data types.
+    """
+
+    SubnetData = 1
+    SubnetInfo = 2
+    SubnetNode = 3
+    RewardsData = 4
+    SubnetNodeInfo = 5
+    ConsensusSubmissionData = 6
+    SubnetNodeConsensusData = 7
+    ConsensusData = 8
+    AllSubnetBootnodes = 9
+    SubnetNodeStakeInfo = 10
+    DelegateStakeInfo = 11
+    NodeDelegateStakeInfo = 12
+
+
+def from_scale_encoding(
+    input_data: Union[list[int], bytes, ScaleBytes],
+    type_name: ChainDataType,
+    is_vec: bool = False,
+    is_option: bool = False,
+    use_legacy: bool = False,
+) -> Optional[dict]:
+    """
+    Returns the decoded data from the SCALE encoded input.
+
+    Args:
+        input_data: The SCALE encoded input (List[int], bytes, or ScaleBytes)
+        type_name: The ChainDataType enum
+        is_vec: Whether the input is a Vec
+        is_option: Whether the input is an Option
+        use_legacy: Whether to use the legacy type registry (for backward compatibility)
+
+    Returns:
+        Optional[Dict]: The decoded data
+    """
+    type_string = type_name.name
+    if is_option:
+        type_string = f"Option<{type_string}>"
+    if is_vec:
+        type_string = f"Vec<{type_string}>"
+
+    return from_scale_encoding_using_type_string(
+        input_data, type_string, use_legacy=use_legacy
+    )
+
+
+def from_scale_encoding_using_type_string(
+    input_data: Union[list[int], bytes, ScaleBytes],
+    type_string: str,
+    use_legacy: bool = False,
+) -> Optional[dict]:
+    """
+    Returns the decoded data from the SCALE encoded input using the type string.
+
+    Args:
+        input_data: The SCALE encoded input (List[int], bytes, or ScaleBytes)
+        type_string: The type string (e.g., "SubnetInfo", "Vec<SubnetNodeInfo>")
+        use_legacy: Whether to use the legacy type registry (for backward compatibility)
+
+    Returns:
+        Optional[Dict]: The decoded data
+    """
+    if isinstance(input_data, ScaleBytes):
+        as_scale_bytes = input_data
+    else:
+        if isinstance(input_data, list) and all(isinstance(i, int) for i in input_data):
+            vec_u8 = input_data
+            as_bytes = bytes(vec_u8)
+        elif isinstance(input_data, bytes):
+            as_bytes = input_data
+        else:
+            raise TypeError("input_data must be a List[int], bytes, or ScaleBytes")
+
+        as_scale_bytes = ScaleBytes(as_bytes)
+
+    # Use the centralized type registry configuration
+    rpc_runtime_config = get_rpc_runtime_config(use_legacy=use_legacy)
+
+    obj = rpc_runtime_config.create_scale_object(type_string, data=as_scale_bytes)
+
+    return obj.decode()
+
+
+def decode_hex_string(hex_str: Union[str, list[int], bytes]) -> str:
+    """
+    Decodes a hex string (e.g., '0x...') or list of ints to a UTF-8 string.
+
+    Args:
+        hex_str: Hex string, list of ints, or bytes to decode
+
+    Returns:
+        Decoded UTF-8 string
+    """
+    if not hex_str:
+        return ""
+
+    # Handle different input types
+    if isinstance(hex_str, (list, tuple)):
+        try:
+            return bytes(hex_str).decode("utf-8")
+        except (UnicodeDecodeError, ValueError):
+            return str(hex_str)
+    elif isinstance(hex_str, bytes):
+        try:
+            return hex_str.decode("utf-8")
+        except (UnicodeDecodeError, ValueError):
+            return str(hex_str)
+    elif isinstance(hex_str, str):
+        # Handle hex string
+        if hex_str.startswith("0x"):
+            try:
+                return bytes.fromhex(hex_str[2:]).decode("utf-8")
+            except (UnicodeDecodeError, ValueError):
+                return hex_str
+        else:
+            return hex_str
+
+    return str(hex_str)
+
+
+def format_balance(balance: int) -> str:
+    """
+    Format balance from planck units to TENSOR with proper formatting.
+
+    Args:
+        balance: Balance in planck units
+
+    Returns:
+        Formatted balance string
+    """
+    if balance is None:
+        return "0.000000 TENSOR"
+
+    # Convert from planck (1e18) to TENSOR
+    tensor_amount = balance / (10**18)
+    return f"{tensor_amount:.6f} TENSOR"

src/htcli/utils/validation/__init__.py

@@ -0,0 +1,57 @@
+"""
+Validation utilities for prompt functions.
+
+This module provides reusable validation functions extracted from Pydantic models
+for use in interactive prompting scenarios.
+"""
+
+from .prompt_validators import (
+    validate_hotkey_address,
+    validate_node_id,
+    validate_retry_attempts,
+    validate_rpc_url,
+    validate_stake_amount,
+    validate_subnet_bootnodes,
+    validate_subnet_delegate_stake_percentage,
+    validate_subnet_initial_coldkeys,
+    validate_subnet_max_registered_nodes,
+    validate_subnet_max_stake,
+    validate_subnet_min_stake,
+    validate_subnet_name,
+    validate_subnet_repo,
+    validate_subnet_id,
+    validate_timeout,
+    validate_wallet_name,
+)
+
+# Export with aliases for backward compatibility
+validate_node_id_prompt = validate_node_id
+validate_rpc_url_prompt = validate_rpc_url
+validate_stake_amount_prompt = validate_stake_amount
+validate_subnet_id_prompt = validate_subnet_id
+validate_wallet_name_prompt = validate_wallet_name
+
+__all__ = [
+    "validate_subnet_name",
+    "validate_subnet_repo",
+    "validate_subnet_min_stake",
+    "validate_subnet_max_stake",
+    "validate_subnet_delegate_stake_percentage",
+    "validate_subnet_max_registered_nodes",
+    "validate_subnet_bootnodes",
+    "validate_subnet_initial_coldkeys",
+    "validate_hotkey_address",
+    "validate_wallet_name",
+    "validate_wallet_name_prompt",
+    "validate_subnet_id",
+    "validate_subnet_id_prompt",
+    "validate_node_id",
+    "validate_node_id_prompt",
+    "validate_stake_amount",
+    "validate_stake_amount_prompt",
+    "validate_rpc_url",
+    "validate_rpc_url_prompt",
+    "validate_timeout",
+    "validate_retry_attempts",
+]
+