htcli 1.1.0__py3-none-any.whl

src/htcli/utils/__init__.py

@@ -0,0 +1,76 @@
+"""
+HTCLI Utilities - Domain-based organization.
+
+This module provides utilities organized by domain:
+- wallet: Wallet creation, management, and authentication
+- blockchain: EVM address validation, formatting, and ownership
+- network: Subnet management and network operations
+- legacy: Deprecated utilities (use UI system instead)
+"""
+
+# Import from domain-specific modules
+from .blockchain import *
+from .network import *
+from .wallet import *
+
+# Legacy imports for backwards compatibility
+# NOTE: These will be removed in a future version
+# Use the new UI system instead:
+#   - colors -> ui.colors
+#   - formatting -> ui.display
+#   - interactive -> ui.prompts
+
+__all__ = [
+    # Wallet utilities
+    "create_wallet",
+    "import_wallet",
+    "get_keypair_from_wallet",
+    "get_available_wallets",
+    "display_available_wallets",
+    "prompt_for_wallet_selection",
+    "create_wallet_if_needed",
+    "create_new_wallet",
+    "get_wallet_for_subnet_operation",
+    "generate_coldkey_pair",
+    "generate_hotkey_pair",
+    "get_wallet_info_by_name",
+    "get_wallet_with_retry",
+    "list_keys",
+    "wallet_name_exists",
+    "encrypt_private_key",
+    "decrypt_private_key",
+    "generate_mnemonic",
+    "create_keypair_from_mnemonic",
+    "get_secure_password",
+    "get_unlock_password",
+    "prompt_for_password",
+    "generate_password_hash",
+    "verify_password",
+    # Blockchain utilities
+    "validate_address",
+    "validate_ethereum_address",
+    "validate_amount",
+    "validate_subnet_id",
+    "validate_node_id",
+    "validate_peer_id",
+    "validate_key_type",
+    "validate_password",
+    "validate_file_path",
+    "validate_wallet_name",
+    "TensorAmount",
+    "format_tensor_balance",
+    "format_balance",
+    "format_address",
+    "format_hash",
+    "format_amount",
+    "get_user_addresses",
+    "user_owns_subnet",
+    "require_user_keys",
+    "show_mine_filter_info",
+    # Network utilities
+    "add_subnet_to_registry",
+    "get_subnet_from_registry",
+    "remove_subnet_from_registry",
+    "list_registered_subnets",
+    "validate_subnet_manifest",
+]

src/htcli/utils/blockchain/__init__.py

@@ -0,0 +1,75 @@
+"""Blockchain utilities for htcli."""
+
+from .peer_id import (
+    TEST_PEER_IDS,
+    decode_peer_id,
+    encode_peer_id,
+    generate_test_peer_id,
+    get_test_peer_id,
+    validate_peer_id_format,
+)
+from .validation import (
+    validate_address,
+    validate_amount,
+    validate_ethereum_address,
+    validate_hotkey_address,
+    validate_key_type,
+    validate_network_url,
+    validate_node_id,
+    validate_peer_id,
+    validate_subnet_id,
+)
+
+# Conditional import of type_registry (requires scalecodec)
+try:
+    from .type_registry import (
+        CUSTOM_RPC_TYPE_REGISTRY,
+        decode_option_subnet_info,
+        decode_option_subnet_node_info,
+        decode_vec_delegate_stake_info,
+        decode_vec_node_delegate_stake_info,
+        decode_vec_subnet_info,
+        decode_vec_subnet_node_info,
+        decode_vec_subnet_node_stake_info,
+        get_rpc_runtime_config,
+    )
+
+    _HAS_TYPE_REGISTRY = True
+except ImportError:
+    _HAS_TYPE_REGISTRY = False
+
+__all__ = [
+    # Peer ID utilities
+    "encode_peer_id",
+    "decode_peer_id",
+    "validate_peer_id_format",
+    "generate_test_peer_id",
+    "get_test_peer_id",
+    "TEST_PEER_IDS",
+    # Validation utilities
+    "validate_address",
+    "validate_ethereum_address",
+    "validate_hotkey_address",
+    "validate_amount",
+    "validate_subnet_id",
+    "validate_node_id",
+    "validate_peer_id",
+    "validate_key_type",
+    "validate_network_url",
+]
+
+# Add type registry exports if available
+if _HAS_TYPE_REGISTRY:
+    __all__.extend(
+        [
+            "get_rpc_runtime_config",
+            "CUSTOM_RPC_TYPE_REGISTRY",
+            "decode_option_subnet_info",
+            "decode_vec_subnet_info",
+            "decode_option_subnet_node_info",
+            "decode_vec_subnet_node_info",
+            "decode_vec_subnet_node_stake_info",
+            "decode_vec_delegate_stake_info",
+            "decode_vec_node_delegate_stake_info",
+        ]
+    )

src/htcli/utils/blockchain/formatting.py

@@ -0,0 +1,368 @@
+"""
+Blockchain formatting utilities.
+Handles TENSOR amounts, addresses, and other blockchain data formatting.
+Uses Decimal for precise 18-decimal TENSOR calculations.
+"""
+
+from decimal import Decimal, getcontext
+from typing import Optional, Union
+
+from web3 import Web3
+
+# Configure decimal context for TENSOR precision (18 decimals + extra for calculations)
+getcontext().prec = 28  # Extra precision for intermediate calculations
+
+# TENSOR token precision constants
+TENSOR_DECIMALS = 18
+TENSOR_UNIT = Decimal("1e18")
+
+
+def to_checksum_address(address: Optional[str]) -> Optional[str]:
+    """
+    Convert an Ethereum-style address to EIP-55 checksummed format.
+
+    This function ensures addresses returned from RPC calls are properly
+    checksummed for display, providing the mixed-case checksum encoding
+    that helps detect typos when copying addresses.
+
+    Args:
+        address: Hex address string (with or without 0x prefix), or None
+
+    Returns:
+        EIP-55 checksummed address string, or None if input is None/invalid
+
+    Example:
+        >>> to_checksum_address("0xbbcdfe56402109104dca757b0b644035ac3fd321")
+        '0xBbCdFE56402109104dcA757B0B644035Ac3Fd321'
+    """
+    if not address:
+        return None
+
+    try:
+        # Ensure address has 0x prefix
+        if not address.startswith("0x"):
+            address = "0x" + address
+
+        # Use web3 to convert to checksummed format
+        return Web3.to_checksum_address(address)
+    except Exception:
+        # If checksum conversion fails (e.g., invalid address), return original
+        return address
+
+
+class TensorAmount:
+    """
+    Precise TENSOR amount handling using Decimal for 18-decimal precision.
+    Handles TENSOR calculations with full precision automatically.
+    """
+
+    def __init__(self, value: Union[str, int, float, Decimal]):
+        """Initialize with precise decimal representation."""
+        self.amount = Decimal(str(value))
+
+    @property
+    def tensor(self) -> Decimal:
+        """Get amount in TENSOR units."""
+        return self.amount
+
+    @property
+    def wei(self) -> int:
+        """Get amount in smallest unit (wei equivalent)."""
+        return int(self.amount * TENSOR_UNIT)
+
+    @classmethod
+    def from_wei(cls, wei_amount: int) -> "TensorAmount":
+        """Create from smallest unit amount."""
+        return cls(Decimal(wei_amount) / TENSOR_UNIT)
+
+    def __str__(self) -> str:
+        """String representation with appropriate precision."""
+        return str(self.amount)
+
+    def __float__(self) -> float:
+        """Float conversion."""
+        return float(self.amount)
+
+    def is_valid(self) -> bool:
+        """Validate TENSOR amount is within acceptable range."""
+        return (
+            Decimal("0") < self.amount <= Decimal("1000000000")
+        )  # 1 billion TENSOR max
+
+
+def format_tensor_balance(balance: Union[str, int, float, TensorAmount]) -> str:
+    """
+    Format a TENSOR balance for display with proper precision.
+
+    Args:
+        balance: TENSOR balance amount
+
+    Returns:
+        Formatted TENSOR balance string (number only)
+    """
+    try:
+        if isinstance(balance, TensorAmount):
+            amount = balance.tensor
+        else:
+            amount = TensorAmount(balance).tensor
+
+        # Format with appropriate decimal places based on magnitude
+        if amount >= 1_000_000:
+            return f"{amount:,.6f}"
+        elif amount >= 1:
+            return f"{amount:.9f}"
+        else:
+            return f"{amount:.18f}".rstrip("0").rstrip(".") if amount > 0 else "0"
+
+    except (ValueError, TypeError):
+        return "Invalid"
+
+
+def format_balance(balance: Union[str, int, float], currency: str = "TENSOR") -> str:
+    """
+    Format a balance amount for display.
+
+    Args:
+        balance: Balance amount
+        currency: Currency symbol
+
+    Returns:
+        Formatted balance string
+    """
+    if currency == "TENSOR":
+        return format_tensor_balance(balance)
+
+    try:
+        if isinstance(balance, str):
+            balance = float(balance)
+
+        # Format with appropriate decimal places
+        if balance >= 1_000_000:
+            return f"{balance:,.2f} {currency}"
+        elif balance >= 1:
+            return f"{balance:.6f} {currency}"
+        else:
+            return f"{balance:.9f} {currency}"
+
+    except (ValueError, TypeError):
+        return f"Invalid {currency}"
+
+
+def format_address(address: str, truncate: bool = True) -> str:
+    """
+    Format an EVM address for display.
+
+    Args:
+        address: EVM address to format
+        truncate: Whether to truncate for display
+
+    Returns:
+        Formatted address string
+    """
+    if not address:
+        return "Unknown Address"
+
+    # Ensure proper EVM format
+    if not address.startswith("0x"):
+        address = f"0x{address}"
+
+    if truncate and len(address) > 10:
+        # Remove 0x prefix if present for calculation
+        clean_address = address[2:]
+
+        if len(clean_address) > 10:
+            return f"0x{clean_address[:5]}...{clean_address[-5:]}"
+
+    return address
+
+
+def format_hash(hash_value: str, truncate: bool = True) -> str:
+    """
+    Format a transaction or block hash for display.
+
+    Args:
+        hash_value: Hash value to format
+        truncate: Whether to truncate for display
+
+    Returns:
+        Formatted hash string
+    """
+    if not hash_value:
+        return "Unknown Hash"
+
+    # Ensure proper hex format
+    if not hash_value.startswith("0x"):
+        hash_value = f"0x{hash_value}"
+
+    if truncate and len(hash_value) > 20:
+        return f"{hash_value[:10]}...{hash_value[-8:]}"
+
+    return hash_value
+
+
+def format_amount(
+    amount: Union[str, int, float], currency: str = "TENSOR", precision: int = 6
+) -> str:
+    """
+    Format a token amount for display.
+
+    Args:
+        amount: Amount to format
+        currency: Currency symbol
+        precision: Decimal precision
+
+    Returns:
+        Formatted amount string
+    """
+    try:
+        if isinstance(amount, str):
+            amount = float(amount)
+
+        # Remove trailing zeros
+        formatted = f"{amount:.{precision}f}".rstrip("0").rstrip(".")
+
+        return f"{formatted} {currency}"
+
+    except (ValueError, TypeError):
+        return f"Invalid {currency}"
+
+
+def format_percentage(value: Union[str, int, float], precision: int = 2) -> str:
+    """
+    Format a percentage value for display.
+
+    Args:
+        value: Percentage value
+        precision: Decimal precision
+
+    Returns:
+        Formatted percentage string
+    """
+    try:
+        if isinstance(value, str):
+            value = float(value)
+
+        return f"{value:.{precision}f}%"
+
+    except (ValueError, TypeError):
+        return "Invalid %"
+
+
+def format_large_number(number: Union[str, int, float], precision: int = 2) -> str:
+    """
+    Format large numbers with K, M, B suffixes.
+
+    Args:
+        number: Number to format
+        precision: Decimal precision
+
+    Returns:
+        Formatted number string with suffix
+    """
+    try:
+        if isinstance(number, str):
+            number = float(number)
+
+        if number >= 1_000_000_000:
+            return f"{number / 1_000_000_000:.{precision}f}B"
+        elif number >= 1_000_000:
+            return f"{number / 1_000_000:.{precision}f}M"
+        elif number >= 1_000:
+            return f"{number / 1_000:.{precision}f}K"
+        else:
+            return f"{number:.{precision}f}"
+
+    except (ValueError, TypeError):
+        return "Invalid"
+
+
+def format_duration(seconds: Union[str, int, float]) -> str:
+    """
+    Format duration in seconds to human-readable format.
+
+    Args:
+        seconds: Duration in seconds
+
+    Returns:
+        Formatted duration string
+    """
+    try:
+        if isinstance(seconds, str):
+            seconds = float(seconds)
+
+        seconds = int(seconds)
+
+        if seconds < 60:
+            return f"{seconds}s"
+        elif seconds < 3600:
+            minutes = seconds // 60
+            remaining_seconds = seconds % 60
+            return (
+                f"{minutes}m {remaining_seconds}s"
+                if remaining_seconds
+                else f"{minutes}m"
+            )
+        elif seconds < 86400:
+            hours = seconds // 3600
+            remaining_minutes = (seconds % 3600) // 60
+            return (
+                f"{hours}h {remaining_minutes}m" if remaining_minutes else f"{hours}h"
+            )
+        else:
+            days = seconds // 86400
+            remaining_hours = (seconds % 86400) // 3600
+            return f"{days}d {remaining_hours}h" if remaining_hours else f"{days}d"
+
+    except (ValueError, TypeError):
+        return "Invalid duration"
+
+
+def format_gas_price(gas_price: Union[str, int, float], unit: str = "gwei") -> str:
+    """
+    Format gas price for display.
+
+    Args:
+        gas_price: Gas price value
+        unit: Unit (gwei, wei, etc.)
+
+    Returns:
+        Formatted gas price string
+    """
+    try:
+        if isinstance(gas_price, str):
+            gas_price = float(gas_price)
+
+        if unit.lower() == "gwei":
+            return f"{gas_price:.2f} gwei"
+        elif unit.lower() == "wei":
+            return f"{gas_price:,.0f} wei"
+        else:
+            return f"{gas_price} {unit}"
+
+    except (ValueError, TypeError):
+        return f"Invalid {unit}"
+
+
+def format_network_status(status: str) -> str:
+    """
+    Format network status with appropriate styling.
+
+    Args:
+        status: Network status
+
+    Returns:
+        Formatted status string
+    """
+    status = status.lower()
+
+    status_map = {
+        "active": "🟢 Active",
+        "inactive": "🔴 Inactive",
+        "pending": "🟡 Pending",
+        "syncing": "🔄 Syncing",
+        "error": "❌ Error",
+        "connected": "🟢 Connected",
+        "disconnected": "🔴 Disconnected",
+    }
+
+    return status_map.get(status, f"⚪ {status.title()}")