htcli 1.1.0__py3-none-any.whl

src/htcli/__init__.py

@@ -0,0 +1,5 @@
+"""
+Hypertensor CLI - A command-line interface for the Hypertensor blockchain.
+"""
+
+__version__ = "1.1.0"

src/htcli/client/__init__.py

@@ -0,0 +1,338 @@
+"""
+Clean client structure for Hypertensor CLI using 3-layer architecture.
+The client only manages connections and exposes the 3 layers directly.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from substrateinterface import SubstrateInterface
+
+# Import logging
+from ..utils.logging import get_logger
+from .extrinsics import (
+    ConsensusExtrinsics,
+    GovernanceExtrinsics,
+    IdentityExtrinsics,
+    NodeExtrinsics,
+    OverwatchExtrinsics,
+    StakingExtrinsics,
+    SubnetExtrinsics,
+    ValidatorExtrinsics,
+    WalletExtrinsics,
+)
+from .offchain import BackupManager, ConfigManager, WalletManager
+from .rpc import (
+    ChainRpcClient,
+    OverwatchRpcClient,
+    StakingRpcClient,
+    SubnetNodeRpcClient,
+    SubnetRpcClient,
+    WalletRpcClient,
+)
+
+logger = get_logger(__name__)
+
+
+class RPCLayer:
+    """Container for RPC (read-only) operations."""
+
+    def __init__(self, substrate):
+        self.chain = ChainRpcClient(substrate)
+        self.subnet = SubnetRpcClient(substrate)
+        self.wallet = WalletRpcClient(substrate)
+        self.node = SubnetNodeRpcClient(substrate)
+        self.staking = StakingRpcClient(substrate)
+        self.overwatch = OverwatchRpcClient(substrate)
+        self.identity = IdentityExtrinsics(substrate)
+
+
+class ExtrinsicsLayer:
+    """Container for Extrinsics (state-changing) operations."""
+
+    def __init__(self, substrate):
+        self.subnet = SubnetExtrinsics(substrate)
+        self.wallet = WalletExtrinsics(substrate)
+        self.node = NodeExtrinsics(substrate)
+        self.governance = GovernanceExtrinsics(substrate)
+        self.identity = IdentityExtrinsics(substrate)
+        self.staking = StakingExtrinsics(substrate)
+        self.overwatch = OverwatchExtrinsics(substrate)
+        self.consensus = ConsensusExtrinsics(substrate)
+        self.validator = ValidatorExtrinsics(substrate)
+
+
+class OffchainLayer:
+    """Container for Off-chain (local) operations."""
+
+    def __init__(self, config=None):
+        # Get wallet path from config if available
+        wallet_dir = None
+        if config and config.wallet and config.wallet.path:
+            wallet_dir = str(Path(config.wallet.path).expanduser())
+        self.wallet = WalletManager(wallet_dir=wallet_dir)
+        self.config = ConfigManager()
+        self.backup = BackupManager()
+
+
+class HypertensorClient:
+    """
+    Minimal client that manages blockchain connection and exposes 3-layer architecture.
+
+    Usage:
+        client.rpc.chain.get_network_stats()
+        client.extrinsics.wallet.add_to_stake(request, keypair)
+        client.offchain.keystore.get_or_create_wallet_session(wallet_name)
+    """
+
+    def __init__(self, config):
+        self.config = config
+        self.substrate = None
+        self.ws_connection = None
+
+        # The 3 layers - initialized only after successful connection
+        # Initialize offchain immediately (doesn't need blockchain connection)
+        self.offchain = OffchainLayer(config=config)
+        self.rpc = None  # Will be initialized in connect()
+        self.extrinsics = None  # Will be initialized in connect()
+
+    def connect(
+        self, rpc_url: Optional[str] = None, force_reconnect: bool = False
+    ) -> bool:
+        """Connect to the Hypertensor blockchain and initialize the 3 layers."""
+        try:
+            # Close existing connection if force reconnecting
+            if force_reconnect and self.substrate:
+                try:
+                    self.substrate.close()
+                except Exception:
+                    pass  # Ignore errors during close
+                self.substrate = None
+                self.rpc = None
+                self.extrinsics = None
+
+            url = rpc_url or self.config.network.endpoint
+            logger.info(f"Attempting to connect to blockchain at {url}")
+
+            # Create direct blockchain connection
+            logger.info("Creating direct blockchain connection")
+            # SubstrateInterface handles WebSocket connections internally
+            # We'll create it with the URL and let it manage the connection
+            try:
+                # Load custom type registry for encoding/decoding
+                from scalecodec.type_registry import load_type_registry_preset
+
+                from ..utils.blockchain.type_registry import CUSTOM_RPC_TYPE_REGISTRY
+
+                # Merge custom types with legacy preset
+                type_registry = load_type_registry_preset("legacy")
+                type_registry.update(CUSTOM_RPC_TYPE_REGISTRY)
+
+                # Try with use_remote_preset for faster metadata loading
+                self.substrate = SubstrateInterface(
+                    url=url,
+                    use_remote_preset=True,  # Use remote metadata preset for faster init
+                    type_registry=type_registry,  # Add custom type registry
+                )
+            except Exception as init_error:
+                logger.warning(
+                    f"Connection with remote preset failed: {init_error}, trying without preset..."
+                )
+                # Fallback to basic connection without remote preset
+                try:
+                    from scalecodec.type_registry import load_type_registry_preset
+
+                    from ..utils.blockchain.type_registry import (
+                        CUSTOM_RPC_TYPE_REGISTRY,
+                    )
+
+                    type_registry = load_type_registry_preset("legacy")
+                    type_registry.update(CUSTOM_RPC_TYPE_REGISTRY)
+
+                    self.substrate = SubstrateInterface(
+                        url=url,
+                        type_registry=type_registry,  # Add custom type registry
+                    )
+                except Exception as fallback_error:
+                    logger.error(
+                        f"Connection failed even without preset: {fallback_error}"
+                    )
+                    raise
+
+            # Initialize runtime metadata (required for queries to work)
+            # This must be done before any queries to ensure metadata is loaded
+            # Add timeout to prevent hanging indefinitely
+            try:
+                import signal
+
+                timeout_seconds = self.config.network.timeout or 30
+
+                def timeout_handler(signum, frame):
+                    raise TimeoutError(
+                        f"Runtime initialization timed out after {timeout_seconds}s"
+                    )
+
+                # Set timeout (Unix only - Windows will skip this)
+                try:
+                    old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+                    signal.alarm(timeout_seconds)
+                except (AttributeError, ValueError):
+                    # Windows doesn't support SIGALRM, skip timeout
+                    old_handler = None
+
+                try:
+                    self.substrate.init_runtime()
+                    logger.debug("Runtime metadata initialized successfully")
+                finally:
+                    # Cancel timeout
+                    if old_handler is not None:
+                        try:
+                            signal.alarm(0)
+                            signal.signal(signal.SIGALRM, old_handler)
+                        except (AttributeError, ValueError):
+                            pass
+            except TimeoutError as timeout_error:
+                logger.error(f"Runtime initialization timed out: {timeout_error}")
+                raise Exception(
+                    f"Cannot connect: metadata initialization timed out after {timeout_seconds}s. "
+                    f"This usually means the connection is very slow or the endpoint is unreachable."
+                ) from timeout_error
+            except Exception as meta_error:
+                logger.error(f"Failed to initialize runtime metadata: {meta_error}")
+                # Don't continue if metadata init fails - queries won't work
+                raise Exception(
+                    f"Cannot connect: metadata initialization failed: {meta_error}"
+                ) from meta_error
+
+            # Test the connection with a simple query to verify metadata is loaded
+            try:
+                # Try a simple query to ensure metadata is working
+                _ = self.substrate.query(
+                    "System", "Account", ["0x0000000000000000000000000000000000000000"]
+                )
+                chain_properties = self.substrate.properties
+                logger.info(f"Connected to blockchain at {url}")
+                logger.info(f"Chain: {chain_properties.get('tokenSymbol', 'Unknown')}")
+                logger.debug("Connection test query successful - metadata is loaded")
+            except Exception as test_error:
+                logger.error(f"Connection test failed: {test_error}")
+                # If test query fails, connection is not usable
+                raise Exception(
+                    f"Cannot connect: test query failed: {test_error}"
+                ) from test_error
+
+            # Initialize the 3 layers only if connection successful
+            if self.substrate:
+                self.rpc = RPCLayer(self.substrate)
+                self.extrinsics = ExtrinsicsLayer(self.substrate)
+                self.offchain = OffchainLayer(config=self.config)
+                return True
+            else:
+                logger.error("Substrate connection not established")
+                return False
+
+        except Exception as e:
+            logger.error(f"Failed to connect to blockchain: {e}")
+            logger.error("Connection details:")
+            logger.error(f"  URL: {url}")
+            logger.error(f"  Timeout: {self.config.network.timeout}s")
+            logger.error(f"  Network type: {self.config.network.network_type}")
+
+            # Provide helpful error message for network issues
+            if "Temporary failure in name resolution" in str(e):
+                logger.error("\n💡 Network connection issue detected:")
+                logger.error("   The blockchain endpoint is unreachable.")
+                logger.error("   This could be due to:")
+                logger.error("   • Network connectivity issues")
+                logger.error("   • DNS resolution problems")
+                logger.error("   • The endpoint being temporarily down")
+                logger.error("\n   Try:")
+                logger.error("   • Check your internet connection")
+                logger.error("   • Try a different network")
+                logger.error("   • Contact the network administrator")
+
+            # Don't initialize layers with None - they should be None until connected
+            # This prevents trying to use RPC clients without a valid connection
+            self.rpc = None
+            self.extrinsics = None
+            self.offchain = OffchainLayer(
+                config=self.config
+            )  # Offchain doesn't need blockchain
+            return False
+
+    def is_connected(self) -> bool:
+        """
+        Lightweight check if client appears connected to blockchain.
+
+        This does NOT perform expensive queries - it only checks connection state.
+        For actual verification, use verify_connection() which does a query.
+        """
+        if not self.substrate or not self.rpc or not self.extrinsics:
+            return False
+
+        try:
+            # Check WebSocket connection status if available
+            # SubstrateInterface uses websockets which can timeout
+            if hasattr(self.substrate, "websocket") and self.substrate.websocket:
+                if hasattr(self.substrate.websocket, "connected"):
+                    if not self.substrate.websocket.connected:
+                        logger.debug(
+                            "WebSocket connection check failed - not connected"
+                        )
+                        return False
+                elif hasattr(self.substrate.websocket, "sock"):
+                    # Alternative check: see if socket exists
+                    if self.substrate.websocket.sock is None:
+                        logger.debug("WebSocket socket check failed - no socket")
+                        return False
+
+            # Lightweight check: just verify properties exist (no network call)
+            # This is much faster than a query
+            try:
+                _ = self.substrate.properties
+                return True
+            except Exception:
+                return False
+        except (AttributeError, Exception) as e:
+            # Connection appears dead
+            logger.debug(f"Lightweight connection check failed: {e}")
+            return False
+
+    def verify_connection(self) -> bool:
+        """
+        Perform an actual query to verify the connection is working.
+        This is more expensive but more reliable than is_connected().
+        Use this when you need to be certain the connection works.
+        """
+        if not self.is_connected():
+            return False
+
+        try:
+            # Do a lightweight query to verify connection actually works
+            _ = self.substrate.query(
+                "System", "Account", ["0x0000000000000000000000000000000000000000"]
+            )
+            return True
+        except Exception as query_error:
+            logger.debug(f"Connection verification query failed: {query_error}")
+            return False
+
+    def disconnect(self):
+        """Disconnect from blockchain."""
+        if self.substrate:
+            try:
+                self.substrate.close()
+            except Exception:
+                pass  # Ignore errors during disconnect
+        if self.ws_connection:
+            try:
+                self.ws_connection.close()
+            except Exception:
+                pass  # Ignore errors during disconnect
+        # Reset layers
+        self.rpc = None
+        self.extrinsics = None
+        self.substrate = None
+
+
+__all__ = ["HypertensorClient"]

src/htcli/client/extrinsics/__init__.py

@@ -0,0 +1,26 @@
+"""
+Extrinsics module for blockchain state-changing operations.
+Contains clients for submitting transactions that modify blockchain state.
+"""
+
+from .consensus import ConsensusExtrinsics
+from .governance import GovernanceExtrinsics
+from .identity import IdentityExtrinsics
+from .node import NodeExtrinsics
+from .overwatch import OverwatchExtrinsics
+from .staking import StakingExtrinsics
+from .subnet import SubnetExtrinsics
+from .validator import ValidatorExtrinsics
+from .wallet import WalletExtrinsics
+
+__all__ = [
+    "SubnetExtrinsics",
+    "WalletExtrinsics",
+    "NodeExtrinsics",
+    "StakingExtrinsics",
+    "IdentityExtrinsics",
+    "GovernanceExtrinsics",
+    "OverwatchExtrinsics",
+    "ConsensusExtrinsics",
+    "ValidatorExtrinsics",
+]