htcli 1.1.0__py3-none-any.whl

src/htcli/commands/consensus/__init__.py

@@ -0,0 +1,61 @@
+from typing import Optional
+from textwrap import dedent
+
+import typer
+
+from .handlers import propose_attestation_handler, attest_handler
+
+app = typer.Typer(name="consensus", help="Consensus operations")
+
+
+PROPOSE_HELP = dedent(
+    """\
+    Propose an attestation on a subnet.
+
+    Validators use this command to submit a proposal (arbitrary data) for consensus.
+    Requires a registered hotkey.
+
+    \b
+    Example:
+      htcli consensus propose --wallet my-hotkey --subnet 1 --data "0x1234..."
+    """
+)
+
+ATTEST_HELP = dedent(
+    """\
+    Attest to an existing proposal.
+
+    Validators use this command to vote for a proposal by its hash.
+    Requires a registered hotkey.
+
+    \b
+    Example:
+      htcli consensus attest --wallet my-hotkey --subnet 1 --hash "0xabcd..."
+    """
+)
+
+
+@app.command("propose", help=PROPOSE_HELP)
+def propose(
+    wallet: str = typer.Option(..., "--wallet", "-w", help="Wallet name (hotkey)"),
+    subnet_id: int = typer.Option(..., "--subnet", "-s", help="Subnet ID"),
+    data: str = typer.Option(..., "--data", "-d", help="Data to propose"),
+    password: Optional[str] = typer.Option(
+        None, "--password", "-p", help="Wallet password"
+    ),
+):
+    """Propose an attestation on a subnet."""
+    propose_attestation_handler(wallet, subnet_id, data, password)
+
+
+@app.command("attest", help=ATTEST_HELP)
+def attest(
+    wallet: str = typer.Option(..., "--wallet", "-w", help="Wallet name (hotkey)"),
+    subnet_id: int = typer.Option(..., "--subnet", "-s", help="Subnet ID"),
+    proposal_hash: str = typer.Option(..., "--hash", "-h", help="Proposal hash"),
+    password: Optional[str] = typer.Option(
+        None, "--password", "-p", help="Wallet password"
+    ),
+):
+    """Attest to an existing proposal."""
+    attest_handler(wallet, subnet_id, proposal_hash, password)

src/htcli/commands/consensus/handlers.py

@@ -0,0 +1,100 @@
+"""
+Consensus command handlers.
+"""
+
+from typing import Optional
+
+from rich.console import Console
+
+from ...dependencies import get_client
+from ...models.requests.consensus import AttestRequest, ProposeAttestationRequest
+from ...ui.components.spinners import HTCLISpinner
+from ...ui.display import print_error, print_info, print_success
+from ...ui.prompts import confirm_prompt
+from ...utils.wallet.core import _get_keypair_with_password_retry
+
+console = Console()
+
+
+def propose_attestation_handler(
+    wallet_name: str,
+    subnet_id: int,
+    data: str,
+    password: Optional[str] = None,
+):
+    """Handle propose attestation command."""
+    try:
+        client = get_client()
+        if not client.connect():
+            return
+
+        # Get keypair
+        print_info(f"🔐 Unlocking wallet '{wallet_name}'...", emoji=False)
+        wallet_manager = client.offchain.wallet
+        # Assuming validators sign with hotkeys for consensus
+        wallet_info = wallet_manager.get_wallet_info(wallet_name, is_hotkey=True)
+        _, keypair = _get_keypair_with_password_retry(
+            client, wallet_name, wallet_info["data"], 3, password
+        )
+
+        # Confirm
+        if not confirm_prompt(
+            f"Propose attestation for subnet {subnet_id}?", default=True
+        ):
+            return
+
+        # Submit
+        with HTCLISpinner("Submitting proposal..."):
+            request = ProposeAttestationRequest(subnet_id=subnet_id, data=data)
+            response = client.extrinsics.consensus.propose_attestation(request, keypair)
+
+        if response["success"]:
+            print_success("✅ Proposal submitted successfully!")
+            console.print(f"  • Block Hash: {response.get('block_hash')}")
+        else:
+            print_error(f"Proposal failed: {response.get('error')}")
+
+    except Exception as e:
+        print_error(f"Error: {str(e)}")
+
+
+def attest_handler(
+    wallet_name: str,
+    subnet_id: int,
+    proposal_hash: str,
+    password: Optional[str] = None,
+):
+    """Handle attest command."""
+    try:
+        client = get_client()
+        if not client.connect():
+            return
+
+        # Get keypair
+        print_info(f"🔐 Unlocking wallet '{wallet_name}'...", emoji=False)
+        wallet_manager = client.offchain.wallet
+        # Assuming validators sign with hotkeys for consensus
+        wallet_info = wallet_manager.get_wallet_info(wallet_name, is_hotkey=True)
+        _, keypair = _get_keypair_with_password_retry(
+            client, wallet_name, wallet_info["data"], 3, password
+        )
+
+        # Confirm
+        if not confirm_prompt(
+            f"Attest to proposal {proposal_hash} on subnet {subnet_id}?", default=True
+        ):
+            return
+
+        # Submit
+        with HTCLISpinner("Submitting attestation..."):
+            request = AttestRequest(subnet_id=subnet_id, proposal_hash=proposal_hash)
+            response = client.extrinsics.consensus.attest(request, keypair)
+
+        if response["success"]:
+            print_success("✅ Attestation submitted successfully!")
+            console.print(f"  • Block Hash: {response.get('block_hash')}")
+        else:
+            print_error(f"Attestation failed: {response.get('error')}")
+
+    except Exception as e:
+        print_error(f"Error: {str(e)}")

src/htcli/commands/governance/__init__.py

@@ -0,0 +1,49 @@
+from typing import Optional
+from textwrap import dedent
+
+import typer
+
+from .handlers import set_parameter_handler
+
+app = typer.Typer(name="governance", help="Governance operations")
+
+
+SET_PARAM_HELP = dedent(
+    """\
+    Update a network governance parameter.
+
+    Requires administrative privileges (sudo/root key).
+
+    \b
+    Available Parameters:
+      - min_registration_cost
+      - target_registrations_per_interval
+      - max_registrations_per_interval
+      - adjustment_alpha
+      - target_max_subnet_nodes
+      - tx_rate_limit
+      - min_delegate_stake_percentage
+      - max_delegate_stake_percentage
+      - min_max_registered_nodes
+      - max_max_registered_nodes
+      - network_min_stake_balance
+      - network_max_stake_balance
+
+    \b
+    Example:
+      htcli governance set-param --wallet root --param min_registration_cost --value 1000
+    """
+)
+
+
+@app.command("set-param", help=SET_PARAM_HELP)
+def set_param(
+    wallet: str = typer.Option(..., "--wallet", "-w", help="Governance wallet name"),
+    parameter: str = typer.Option(..., "--param", "-p", help="Parameter name"),
+    value: int = typer.Option(..., "--value", "-v", help="New value"),
+    password: Optional[str] = typer.Option(
+        None, "--password", "-pw", help="Wallet password"
+    ),
+):
+    """Update a network governance parameter."""
+    set_parameter_handler(wallet, parameter, value, password)

src/htcli/commands/governance/handlers.py

@@ -0,0 +1,81 @@
+"""
+Governance command handlers.
+"""
+
+from typing import Optional
+
+from rich.console import Console
+
+from ...dependencies import get_client
+from ...models.requests.governance import GovernanceParameterUpdateRequest
+from ...ui.components.spinners import HTCLISpinner
+from ...ui.display import print_error, print_info, print_success
+from ...ui.prompts import confirm_prompt
+from ...utils.wallet.core import _get_keypair_with_password_retry
+
+console = Console()
+
+
+def set_parameter_handler(
+    wallet_name: str,
+    parameter: str,
+    value: int,
+    password: Optional[str] = None,
+):
+    """Handle parameter setting command."""
+    try:
+        # Map parameter names to client method names before attempting wallet unlock
+        method_name_map = {
+            "min_registration_cost": "set_min_registration_cost",
+            "target_registrations_per_interval": "set_target_registrations_per_interval",
+            "max_registrations_per_interval": "set_max_registrations_per_interval",
+            "adjustment_alpha": "set_adjustment_alpha",
+            "target_max_subnet_nodes": "set_target_max_subnet_nodes",
+            "tx_rate_limit": "set_tx_rate_limit",
+            "min_delegate_stake_percentage": "set_min_delegate_stake_percentage",
+            "max_delegate_stake_percentage": "set_max_delegate_stake_percentage",
+            "min_max_registered_nodes": "set_min_max_registered_nodes",
+            "max_max_registered_nodes": "set_max_max_registered_nodes",
+            "network_min_stake_balance": "set_network_min_stake_balance",
+            "network_max_stake_balance": "set_network_max_stake_balance",
+        }
+
+        if parameter not in method_name_map:
+            print_error(f"Unknown parameter: {parameter}")
+            console.print("Available parameters:")
+            for p in method_name_map.keys():
+                console.print(f"  • {p}")
+            return
+
+        client = get_client()
+        if not client.connect():
+            return
+
+        # Get keypair (must be governance)
+        print_info(f"🔐 Unlocking governance wallet '{wallet_name}'...", emoji=False)
+        wallet_manager = client.offchain.wallet
+        # Assuming governance keys are coldkeys
+        wallet_info = wallet_manager.get_wallet_info(wallet_name, is_hotkey=False)
+        _, keypair = _get_keypair_with_password_retry(
+            client, wallet_name, wallet_info["data"], 3, password
+        )
+
+        method = getattr(client.extrinsics.governance, method_name_map[parameter])
+
+        # Confirm
+        if not confirm_prompt(f"Set {parameter} to {value}?", default=False):
+            return
+
+        # Submit
+        with HTCLISpinner(f"Setting {parameter}..."):
+            request = GovernanceParameterUpdateRequest(value=value)
+            response = method(request, keypair)
+
+        if response["success"]:
+            print_success(f"✅ {parameter} set successfully!")
+            console.print(f"  • Block Hash: {response.get('block_hash')}")
+        else:
+            print_error(f"Failed to set parameter: {response.get('error')}")
+
+    except Exception as e:
+        print_error(f"Error: {str(e)}")

src/htcli/commands/node/__init__.py

@@ -0,0 +1,304 @@
+"""
+Node command module - placeholder implementation.
+"""
+
+from textwrap import dedent
+from typing import Optional
+
+import typer
+
+from ..subnet import handlers as subnet_handlers
+from . import handlers as node_handlers
+
+app = typer.Typer(name="node", help="Node operations")
+
+
+UPDATE_NODE_HELP = dedent(
+    """\
+    Update node configuration.
+
+    This command allows updating various properties of a registered node.
+    You can update multiple fields in a single call. Any provided field will be
+    updated sequentially and a consolidated summary will be displayed.
+
+    \b
+    Examples:
+      htcli node update --subnet-id 1 --node-id 5 --delegate-rate 10
+      htcli node update --subnet-id 1 --node-id 5 --peer-id "new-peer-id"
+    """
+)
+
+
+@app.command("register")
+def register_node(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", help="Subnet ID to register on"
+    ),
+    validator_id: Optional[int] = typer.Option(
+        None, "--validator-id", help="Validator ID that owns the node"
+    ),
+    hotkey: Optional[str] = typer.Option(
+        None, "--hotkey", help="Hotkey address for the node"
+    ),
+    stake: Optional[float] = typer.Option(
+        None, "--stake", help="Initial stake amount (TENSOR)"
+    ),
+    peer_id: Optional[str] = typer.Option(
+        None, "--peer-id", help="Peer ID (auto-generated if not provided)"
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Coldkey wallet name or address to sign the registration extrinsic",
+    ),
+):
+    """Register a new node on a subnet."""
+    node_handlers.register_node_handler(
+        subnet_id=subnet_id,
+        validator_id=validator_id,
+        hotkey=hotkey,
+        stake_amount=stake,
+        peer_id=peer_id,
+        coldkey=coldkey,
+    )
+
+
+@app.command("list")
+def list_nodes(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The unique ID (UID) of the subnet."
+    ),
+    live: bool = typer.Option(
+        False,
+        "--live",
+        help="Enable live updates when supported.",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None, "--coldkey", help="Coldkey wallet name or address to list nodes for"
+    ),
+):
+    """List all nodes registered to a specific subnet using RPC. Use --coldkey to filter by coldkey."""
+    _ = live
+    subnet_handlers.get_subnet_nodes_handler(subnet_id, coldkey)
+
+
+@app.command("all")
+def get_all_nodes(
+    live: bool = typer.Option(
+        False,
+        "--live",
+        help="Enable live updates when supported.",
+    ),
+):
+    """Get all nodes across all subnets using RPC."""
+    _ = live
+    node_handlers.get_all_nodes_handler()
+
+
+@app.command("status")
+def get_node_status(
+    subnet_id: Optional[int] = typer.Argument(
+        None,
+        help="The subnet ID",
+    ),
+    node_id: Optional[int] = typer.Argument(
+        None,
+        help="The node ID within the subnet",
+    ),
+):
+    """Get the status for a specific node."""
+    subnet_handlers.get_node_status_handler(subnet_id, node_id)
+
+
+@app.command("info")
+def get_node_info(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The subnet ID"
+    ),
+    node_id: Optional[int] = typer.Option(
+        None, "--node-id", "--nodeid", help="The node ID"
+    ),
+):
+    """Get detailed information about a specific node using RPC."""
+    node_handlers.get_node_info_handler(subnet_id, node_id)
+
+
+@app.command("overwatch-commits", context_settings={"allow_extra_args": True})
+def get_overwatch_commits(
+    ctx: typer.Context,
+    epoch: Optional[int] = typer.Option(None, "--epoch", "-e", help="The epoch number"),
+    overwatch_node_id: Optional[int] = typer.Option(
+        None, "--node-id", "-n", help="The overwatch node ID"
+    ),
+):
+    """Get overwatch commits for a specific node and epoch using RPC."""
+    if epoch is None and len(ctx.args) > 0:
+        try:
+            epoch = int(ctx.args[0])
+        except ValueError:
+            pass
+    if overwatch_node_id is None and len(ctx.args) > 1:
+        try:
+            overwatch_node_id = int(ctx.args[1])
+        except ValueError:
+            pass
+    node_handlers.get_overwatch_commits_handler(epoch, overwatch_node_id)
+
+
+@app.command("overwatch-reveals", context_settings={"allow_extra_args": True})
+def get_overwatch_reveals(
+    ctx: typer.Context,
+    epoch: Optional[int] = typer.Option(None, "--epoch", "-e", help="The epoch number"),
+    overwatch_node_id: Optional[int] = typer.Option(
+        None, "--node-id", "-n", help="The overwatch node ID"
+    ),
+):
+    """Get overwatch reveals for a specific node and epoch using RPC."""
+    if epoch is None and len(ctx.args) > 0:
+        try:
+            epoch = int(ctx.args[0])
+        except ValueError:
+            pass
+    if overwatch_node_id is None and len(ctx.args) > 1:
+        try:
+            overwatch_node_id = int(ctx.args[1])
+        except ValueError:
+            pass
+    node_handlers.get_overwatch_reveals_handler(epoch, overwatch_node_id)
+
+
+@app.command("remove")
+def remove_node(
+    subnet_id: Optional[int] = typer.Option(
+        None,
+        "--subnet-id",
+        help="Subnet ID of the node to remove",
+    ),
+    node_id: Optional[int] = typer.Option(
+        None,
+        "--node-id",
+        help="Node ID to remove",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Coldkey wallet name or address to sign the removal extrinsic",
+    ),
+):
+    """Remove a node from a subnet."""
+    node_handlers.remove_node_handler(
+        subnet_id=subnet_id, node_id=node_id, coldkey=coldkey
+    )
+
+
+@app.command("activate")
+def activate_node(
+    subnet_id: Optional[int] = typer.Option(
+        None,
+        "--subnet-id",
+        help="Subnet ID of the node to activate",
+    ),
+    node_id: Optional[int] = typer.Option(
+        None,
+        "--node-id",
+        help="Node ID to activate",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Coldkey wallet name or address to sign the activation extrinsic",
+    ),
+):
+    """Activate a registered node on a subnet."""
+    node_handlers.activate_node_handler(
+        subnet_id=subnet_id, node_id=node_id, coldkey=coldkey
+    )
+
+
+@app.command("deactivate")
+def deactivate_node(
+    subnet_id: Optional[int] = typer.Option(
+        None,
+        "--subnet-id",
+        help="Subnet ID of the node to deactivate",
+    ),
+    node_id: Optional[int] = typer.Option(
+        None,
+        "--node-id",
+        help="Node ID to deactivate",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Coldkey wallet name or address to sign the deactivation extrinsic",
+    ),
+):
+    """Deactivate a node on a subnet."""
+    node_handlers.deactivate_node_handler(
+        subnet_id=subnet_id, node_id=node_id, coldkey=coldkey
+    )
+
+
+@app.command("update", help=UPDATE_NODE_HELP)
+def update_node(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", help="Subnet ID of the node"
+    ),
+    node_id: Optional[int] = typer.Option(None, "--node-id", help="Node ID to update"),
+    peer_id: Optional[str] = typer.Option(
+        None,
+        "--peer-id",
+        help="New primary peer ID for the node",
+    ),
+    bootnode: Optional[str] = typer.Option(
+        None,
+        "--bootnode",
+        help="New bootnode multiaddress for the node (empty string to clear)",
+    ),
+    bootnode_peer_id: Optional[str] = typer.Option(
+        None,
+        "--bootnode-peer-id",
+        help="New bootnode peer ID",
+    ),
+    client_peer_id: Optional[str] = typer.Option(
+        None,
+        "--client-peer-id",
+        help="New client peer ID",
+    ),
+    delegate_rate: Optional[int] = typer.Option(
+        None,
+        "--delegate-rate",
+        help="New delegate reward rate (0-100 as percent, or 1e18-format value)",
+    ),
+    unique: Optional[str] = typer.Option(
+        None,
+        "--unique",
+        help="New unique metadata value (empty string to clear)",
+    ),
+    non_unique: Optional[str] = typer.Option(
+        None,
+        "--non-unique",
+        help="New non-unique metadata value (empty string to clear)",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Coldkey wallet name or address to sign the update transaction",
+    ),
+):
+    """Update node configuration."""
+    node_handlers.update_node_handler(
+        subnet_id=subnet_id,
+        node_id=node_id,
+        peer_id=peer_id,
+        bootnode=bootnode,
+        bootnode_peer_id=bootnode_peer_id,
+        client_peer_id=client_peer_id,
+        delegate_reward_rate=delegate_rate,
+        unique=unique,
+        non_unique=non_unique,
+        coldkey=coldkey,
+    )
+
+
+__all__ = ["app"]