htcli 1.1.0__py3-none-any.whl

src/htcli/commands/__init__.py

@@ -0,0 +1,31 @@
+"""
+HTCLI Commands Module.
+
+This module contains all command implementations organized by domain.
+Each command is a folder with its own entry point, prompts, handlers, and display logic.
+"""
+
+# Import all command apps for main.py
+from .chain import app as chain_app
+from .config import app as config_app
+from .consensus import app as consensus_app
+from .governance import app as governance_app
+from .node import app as node_app
+from .overwatch import app as overwatch_app
+from .stake import app as stake_app
+from .subnet import app as subnet_app
+from .validator import app as validator_app
+from .wallet import app as wallet_app
+
+__all__ = [
+    "wallet_app",
+    "subnet_app",
+    "stake_app",
+    "chain_app",
+    "node_app",
+    "config_app",
+    "overwatch_app",
+    "consensus_app",
+    "governance_app",
+    "validator_app",
+]

src/htcli/commands/chain/__init__.py

@@ -0,0 +1,66 @@
+"""
+Chain command module.
+
+Provides blockchain information and network statistics.
+"""
+
+import typer
+
+from .handlers import (
+    chain_info_handler,
+    chain_ping_handler,
+    chain_stats_handler,
+    get_account_handler,
+    get_block_handler,
+    get_transaction_handler,
+    registration_cost_handler,
+)
+
+app = typer.Typer(name="chain", help="Chain operations")
+
+
+@app.command("info")
+def chain_info():
+    """Get comprehensive chain information."""
+    chain_info_handler()
+
+
+@app.command("ping")
+def chain_ping():
+    """Ping the configured chain endpoint and show node health."""
+    chain_ping_handler()
+
+
+@app.command("stats")
+def chain_stats():
+    """Get network statistics."""
+    chain_stats_handler()
+
+
+@app.command("cost")
+def registration_cost():
+    """Query current subnet registration cost."""
+    registration_cost_handler()
+
+
+@app.command("block")
+def block_info(block_number: int = typer.Argument(..., help="Block number to query")):
+    """Get block details for a specific block number."""
+    get_block_handler(block_number)
+
+
+@app.command("tx")
+def transaction_info(
+    tx_hash: str = typer.Argument(..., help="Transaction hash to query"),
+):
+    """Get basic transaction details for a specific hash."""
+    get_transaction_handler(tx_hash)
+
+
+@app.command("account")
+def account_info(address: str = typer.Argument(..., help="Account address to query")):
+    """Get basic account information."""
+    get_account_handler(address)
+
+
+__all__ = ["app"]

src/htcli/commands/chain/display.py

@@ -0,0 +1,204 @@
+"""
+Chain command display functions.
+
+Handles formatting and displaying blockchain information and statistics.
+"""
+
+from typing import Optional
+
+from ...ui.components import HTCLIPanel, HTCLITable
+from ...ui.display import HTCLIConsole
+
+console = HTCLIConsole()
+
+
+def display_chain_info(chain_data: dict):
+    """Display chain information in a structured table."""
+    table = HTCLITable(
+        title="[bold blue]⛓️  Chain Information[/bold blue]",
+        border_style="blue",
+        header_style="bold cyan",
+    )
+    table.add_column("Property", style="bold white", width=25)
+    table.add_column("Value", style="bright_white", width=50)
+
+    # Add chain data
+    table.add_row("Chain Name", str(chain_data.get("chain_name", "Unknown")))
+
+    # Format block number safely
+    block_number = chain_data.get("block_number")
+    block_display = f"{block_number:,}" if block_number is not None else "N/A"
+    table.add_row("Current Block", block_display)
+
+    # Format epoch number safely
+    current_epoch = chain_data.get("current_epoch")
+    epoch_display = f"{current_epoch:,}" if current_epoch is not None else "N/A"
+    table.add_row("Current Epoch", epoch_display)
+
+    table.add_row("Runtime Version", str(chain_data.get("runtime_version", "Unknown")))
+    table.add_row("Token Decimals", str(chain_data.get("token_decimals", 18)))
+
+    table.render()
+
+
+def display_chain_stats(stats_data: dict):
+    """Display network statistics in a panel."""
+    block_number = stats_data.get("block_number")
+    current_epoch = stats_data.get("current_epoch")
+    total_subnets = stats_data.get("total_subnets", 0)
+    active_subnets = stats_data.get("active_subnets", 0)
+    total_nodes = stats_data.get("total_nodes", 0)
+    active_nodes = stats_data.get("active_nodes", 0)
+    registration_cost = stats_data.get("registration_cost")
+
+    # Format safely
+    block_display = f"{block_number:,}" if block_number is not None else "N/A"
+    epoch_display = f"{current_epoch:,}" if current_epoch is not None else "N/A"
+
+    cost_display = (
+        f"{registration_cost / 1e18:,.2f} TENSOR" if registration_cost else "N/A"
+    )
+
+    content = f"""[htcli.accent]Network Statistics[/htcli.accent]
+
+[htcli.value]Block Number:[/htcli.value] {block_display}
+[htcli.value]Current Epoch:[/htcli.value] {epoch_display}
+
+[htcli.accent]Subnets[/htcli.accent]
+[htcli.value]Total Subnets:[/htcli.value] {total_subnets}
+[htcli.success]Active Subnets:[/htcli.success] {active_subnets}
+
+[htcli.accent]Nodes[/htcli.accent]
+[htcli.value]Total Nodes:[/htcli.value] {total_nodes}
+[htcli.success]Active Nodes:[/htcli.success] {active_nodes}
+
+[htcli.accent]Costs[/htcli.accent]
+[htcli.value]Subnet Registration:[/htcli.value] {cost_display}
+"""
+
+    panel = HTCLIPanel(
+        content,
+        title="📊 Network Statistics",
+        border_style="htcli.info",
+        highlight=True,
+    )
+    panel.render()
+
+
+def display_chain_ping(ping_data: dict):
+    """Display node ping and health information."""
+    latency = ping_data.get("latency_ms")
+    latency_display = f"{latency:,.2f} ms" if latency is not None else "N/A"
+    is_syncing = ping_data.get("is_syncing")
+    syncing_display = "Unknown" if is_syncing is None else str(is_syncing)
+    should_have_peers = ping_data.get("should_have_peers")
+    should_have_peers_display = (
+        "Unknown" if should_have_peers is None else str(should_have_peers)
+    )
+
+    content = f"""[htcli.accent]Node Health[/htcli.accent]
+
+[htcli.value]Endpoint:[/htcli.value] {ping_data.get("endpoint", "Unknown")}
+[htcli.value]Latency:[/htcli.value] {latency_display}
+[htcli.value]Peers:[/htcli.value] {ping_data.get("peers", "Unknown")}
+[htcli.value]Syncing:[/htcli.value] {syncing_display}
+[htcli.value]Should Have Peers:[/htcli.value] {should_have_peers_display}
+"""
+
+    panel = HTCLIPanel(
+        content,
+        title="Node Ping",
+        border_style="htcli.success",
+        highlight=True,
+    )
+    panel.render()
+
+
+def display_registration_cost(
+    current_cost: Optional[int],
+    block_number: Optional[int],
+    current_epoch: Optional[int],
+):
+    """Display subnet registration cost information."""
+    if current_cost is None:
+        console.print("[htcli.error]❌ Failed to query registration cost[/]")
+        return
+
+    cost_tensor = current_cost / 1e18
+
+    # Format safely
+    block_display = f"{block_number:,}" if block_number is not None else "N/A"
+    epoch_display = f"{current_epoch:,}" if current_epoch is not None else "N/A"
+
+    content = f"""[htcli.accent]Subnet Registration Cost[/htcli.accent]
+
+[htcli.value]Current Cost:[/htcli.value] {cost_tensor:,.2f} TENSOR
+[htcli.value]In Wei:[/htcli.value] {current_cost:,}
+
+[htcli.value]Current Block:[/htcli.value] {block_display}
+[htcli.value]Current Epoch:[/htcli.value] {epoch_display}
+
+[htcli.info]💡 Cost Information:[/htcli.info]
+• The cost decreases over time using exponential decay
+• Cost increases immediately after each new subnet registration (typically doubles)
+• Recommended: Set --max-cost to at least {cost_tensor * 1.1:,.2f} TENSOR (10% buffer)
+
+[htcli.accent]Example Usage:[/htcli.accent]
+htcli subnet register --name "My Subnet" --max-cost {cost_tensor * 1.1:,.2f} ...
+"""
+
+    panel = HTCLIPanel(
+        content,
+        title="💰 Subnet Registration Cost",
+        border_style="htcli.warning",
+        highlight=True,
+    )
+    panel.render()
+
+
+def display_block_info(block_data: dict):
+    """Display block details in a compact table."""
+    table = HTCLITable(
+        title="[bold blue]🧱 Block Information[/bold blue]",
+        border_style="blue",
+        header_style="bold cyan",
+    )
+    table.add_column("Property", style="bold white", width=25)
+    table.add_column("Value", style="bright_white", width=60)
+
+    table.add_row("Block Number", str(block_data.get("number", "N/A")))
+    table.add_row("Block Hash", str(block_data.get("hash", "N/A")))
+    table.add_row("Parent Hash", str(block_data.get("parent_hash", "N/A")))
+    table.add_row("State Root", str(block_data.get("state_root", "N/A")))
+    table.add_row("Extrinsics Root", str(block_data.get("extrinsics_root", "N/A")))
+    table.add_row("Extrinsics Count", str(block_data.get("extrinsics_count", "N/A")))
+    table.render()
+
+
+def display_transaction_info(tx_hash: str):
+    """Display a simple transaction lookup result."""
+    panel = HTCLIPanel(
+        f"[htcli.value]Transaction Hash:[/htcli.value] {tx_hash}\n\n"
+        "[htcli.info]Transaction lookup is not fully implemented yet.[/htcli.info]",
+        title="🧾 Transaction Lookup",
+        border_style="htcli.info",
+        highlight=True,
+    )
+    panel.render()
+
+
+def display_account_info(address: str, balance: Optional[int]):
+    """Display account details."""
+    balance_display = (
+        f"{balance / 1e18:,.4f} TENSOR ({balance} wei)"
+        if balance is not None
+        else "Unavailable"
+    )
+    panel = HTCLIPanel(
+        f"[htcli.value]Account:[/htcli.value] {address}\n"
+        f"[htcli.value]Balance:[/htcli.value] {balance_display}",
+        title="👤 Account Information",
+        border_style="htcli.success",
+        highlight=True,
+    )
+    panel.render()

src/htcli/commands/chain/handlers.py

@@ -0,0 +1,260 @@
+"""
+Chain command handlers.
+
+Handlers for blockchain information and statistics.
+"""
+
+import re
+
+from ...dependencies import get_client
+from ...errors.base import AddressValidationError, HTCLIError
+from ...errors.handlers import handle_and_display_error
+from ...ui.components import HTCLILoadingContext
+from .display import (
+    display_account_info,
+    display_block_info,
+    display_chain_info,
+    display_chain_ping,
+    display_chain_stats,
+    display_registration_cost,
+)
+
+
+def chain_info_handler():
+    """Handle chain information display."""
+    try:
+        client = get_client()
+
+        with HTCLILoadingContext("Fetching chain information..."):
+            # Gather chain data
+            block_number = client.rpc.chain.get_block_number()
+            current_epoch = client.rpc.chain.get_current_epoch()
+
+            # Try to get additional chain properties
+            try:
+                chain_properties = (
+                    client.substrate.properties if client.substrate else {}
+                )
+                runtime_version = (
+                    client.substrate.runtime_version if client.substrate else "Unknown"
+                )
+            except Exception:
+                chain_properties = {}
+                runtime_version = "Unknown"
+
+        # Prepare chain data
+        chain_data = {
+            "block_number": block_number,
+            "current_epoch": current_epoch,
+            "chain_name": chain_properties.get("tokenSymbol", "Unknown"),
+            "runtime_version": runtime_version,
+            "token_decimals": chain_properties.get("tokenDecimals", 18),
+        }
+
+        # Display
+        display_chain_info(chain_data)
+
+    except RuntimeError as e:
+        # Handle connection errors specifically
+        from ...ui.display import print_error
+
+        error_str = str(e).lower()
+        if "connect" in error_str or "blockchain" in error_str:
+            print_error(f"Blockchain Connection Error: {str(e)}")
+        else:
+            print_error(f"Error: {str(e)}")
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def chain_ping_handler():
+    """Handle chain node ping."""
+    try:
+        client = get_client()
+        endpoint = getattr(getattr(client, "config", None), "network", None)
+        endpoint_value = getattr(endpoint, "endpoint", "Unknown")
+
+        with HTCLILoadingContext("Pinging chain endpoint..."):
+            result = client.rpc.chain.ping()
+
+        if not result.get("success"):
+            raise RuntimeError(result.get("message", "Failed to ping chain endpoint"))
+
+        ping_data = result.get("data", {})
+        ping_data["endpoint"] = endpoint_value
+        display_chain_ping(ping_data)
+
+    except RuntimeError as e:
+        from ...ui.display import print_error
+
+        error_str = str(e).lower()
+        if "connect" in error_str or "blockchain" in error_str:
+            print_error(f"Blockchain Connection Error: {str(e)}")
+        else:
+            print_error(f"Error: {str(e)}")
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def chain_stats_handler():
+    """Handle network statistics display."""
+    try:
+        client = get_client()
+
+        with HTCLILoadingContext("Fetching network statistics..."):
+            # Get block and epoch
+            block_number = client.rpc.chain.get_block_number()
+            current_epoch = client.rpc.chain.get_current_epoch()
+
+            # Get subnet data
+            all_subnets = client.rpc.subnet.get_all_subnets_info()
+            total_subnets = len(all_subnets) if all_subnets else 0
+            # Active subnets are those with state == "Active" (not just having active nodes)
+            active_subnets = (
+                sum(
+                    1
+                    for s in all_subnets
+                    if hasattr(s, "state")
+                    and (
+                        (
+                            hasattr(s.state, "value")
+                            and s.state.value.lower() == "active"
+                        )
+                        or (isinstance(s.state, str) and s.state.lower() == "active")
+                    )
+                )
+                if all_subnets
+                else 0
+            )
+
+            # Get node data
+            all_nodes = client.rpc.node.get_all_subnet_nodes_info()
+            total_nodes = len(all_nodes) if all_nodes else 0
+
+            # Count active nodes (classification is not Registered)
+            active_nodes = 0
+            if all_nodes:
+                for node in all_nodes:
+                    if hasattr(node, "classification"):
+                        classification = node.classification
+                        if isinstance(classification, dict):
+                            node_class = classification.get("node_class", "Registered")
+                        else:
+                            node_class = str(classification)
+
+                        # Active means not in Registered state
+                        if node_class != "Registered":
+                            active_nodes += 1
+
+            # Get registration cost
+            registration_cost = client.rpc.chain.get_subnet_registration_cost()
+
+        # Prepare stats data
+        stats_data = {
+            "block_number": block_number,
+            "current_epoch": current_epoch,
+            "total_subnets": total_subnets,
+            "active_subnets": active_subnets,
+            "total_nodes": total_nodes,
+            "active_nodes": active_nodes,
+            "registration_cost": registration_cost,
+        }
+
+        # Display
+        display_chain_stats(stats_data)
+
+    except RuntimeError as e:
+        # Handle connection errors specifically
+        from ...ui.display import print_error
+
+        error_str = str(e).lower()
+        if "connect" in error_str or "blockchain" in error_str:
+            print_error(f"Blockchain Connection Error: {str(e)}")
+        else:
+            print_error(f"Error: {str(e)}")
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def registration_cost_handler():
+    """Handle subnet registration cost query."""
+    try:
+        client = get_client()
+
+        with HTCLILoadingContext("Querying subnet registration cost..."):
+            current_cost = client.rpc.chain.get_subnet_registration_cost()
+            block_number = client.rpc.chain.get_block_number()
+            current_epoch = client.rpc.chain.get_current_epoch()
+
+        # Display - provide helpful message if cost is None
+        if current_cost is None:
+            from ...ui.display import print_error, print_info
+
+            print_error("Failed to query registration cost from blockchain.")
+            print_info(
+                "This may indicate a connection issue or the storage values are not set yet."
+            )
+        else:
+            display_registration_cost(current_cost, block_number, current_epoch)
+
+    except RuntimeError as e:
+        # Handle connection errors specifically
+        from ...ui.display import print_error
+
+        error_str = str(e).lower()
+        if "connect" in error_str or "blockchain" in error_str:
+            print_error(f"Blockchain Connection Error: {str(e)}")
+        else:
+            print_error(f"Error: {str(e)}")
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def get_block_handler(block_number: int):
+    """Handle block lookup by block number."""
+    try:
+        if block_number < 0:
+            raise HTCLIError("Invalid block number: must be a positive integer")
+
+        client = get_client()
+
+        with HTCLILoadingContext("Fetching block information..."):
+            result = client.rpc.chain.get_block_info(block_number)
+
+        if not result.get("success"):
+            raise RuntimeError(result.get("message", "Failed to fetch block info"))
+
+        display_block_info(result.get("data", {}))
+
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def get_transaction_handler(tx_hash: str):
+    """Handle transaction lookup by hash."""
+    try:
+        if not re.fullmatch(r"0x[a-fA-F0-9]{64}", tx_hash):
+            raise HTCLIError("Invalid transaction hash format")
+
+        raise HTCLIError("Transaction lookup is not implemented yet")
+    except Exception as e:
+        handle_and_display_error(e)
+
+
+def get_account_handler(address: str):
+    """Handle account lookup by address."""
+    try:
+        if not re.fullmatch(
+            r"(0x[a-fA-F0-9]{40}|[1-9A-HJ-NP-Za-km-z]{32,64})", address
+        ):
+            raise AddressValidationError("Invalid address format")
+
+        client = get_client()
+
+        with HTCLILoadingContext("Fetching account information..."):
+            balance = client.rpc.chain.get_account_balance(address)
+
+        display_account_info(address, balance)
+
+    except Exception as e:
+        handle_and_display_error(e)