htcli 1.1.0__py3-none-any.whl

src/htcli/commands/subnet/__init__.py

@@ -0,0 +1,639 @@
+from typing import Optional
+from textwrap import dedent
+
+import typer
+
+from .handlers import (
+    activate_subnet_handler,  # New RPC-based handlers
+    check_activation_handler,
+    get_bootnodes_handler,
+    get_node_staking_handler,
+    get_node_status_handler,
+    get_subnet_handler,
+    get_subnet_info_handler,
+    get_subnet_nodes_handler,
+    list_nodes_handler,
+    list_subnets_handler,
+    owner_accept_handler,
+    owner_add_bootnode_access_handler,
+    owner_clear_emergency_validator_set_handler,
+    owner_remove_bootnode_access_handler,
+    owner_add_bootnode_handler,
+    owner_remove_bootnode_handler,
+    owner_remove_handler,
+    owner_set_emergency_validator_set_handler,
+    owner_transfer_handler,
+    owner_update_handler,
+    owner_update_name_handler,
+    owner_update_repo_handler,
+    pause_subnet_handler,
+    register_subnet_handler,
+    registration_cost_handler,
+    unpause_subnet_handler,
+)
+
+app = typer.Typer(
+    name="subnet",
+    help="""
+    Commands for interacting with and managing subnets on the Hypertensor network.
+
+    View subnet details, register new subnets, and perform administrative actions.
+    """,
+    no_args_is_help=False,
+)
+
+
+LIST_SUBNETS_HELP = dedent(
+    """\
+    List subnets on the network.
+
+    \b
+    Options:
+      --all      List all subnets (including paused/inactive).
+      --active   List only active subnets.
+      --coldkey  Filter subnets owned by a specific coldkey.
+
+    \b
+    Example:
+      htcli subnet list --all
+    """
+)
+
+REGISTER_SUBNET_HELP = dedent(
+    """\
+    Register a new subnet on the network.
+
+    \b
+    Note:
+      Configuration fields (churn_limit, queue_epochs, max_registered_nodes, etc.)
+      are not part of registration and must be set separately after registration
+      using owner update commands such as:
+      htcli subnet update --churn-limit ...
+    """
+)
+
+
+@app.callback(invoke_without_command=True)
+def subnet_main(ctx: typer.Context):
+    """Subnet operations."""
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(code=0)
+
+
+@app.command("list", help=LIST_SUBNETS_HELP)
+def list_subnets(
+    all_subnets: bool = typer.Option(
+        False, "--all", help="List all subnets on the network"
+    ),
+    active_only: bool = typer.Option(
+        False, "--active", help="Show only active subnets."
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None, "--coldkey", "-c", help="Filter subnets by coldkey address or wallet name"
+    ),
+):
+    """List subnets on the network."""
+    # from ...ui.display import print_error
+    # from ...ui.prompts import HTCLIPrompt
+
+    # If no mode specified, default to all subnets
+    if not all_subnets:
+        all_subnets = True
+
+    # # If no mode specified, ask user for choice
+    # if not all_subnets and not coldkey:
+    #     try:
+    #         prompt = HTCLIPrompt()
+    #         mode = prompt.select(
+    #             "What would you like to list?",
+    #             choices=[
+    #                 ("all", "All subnets"),
+    #                 ("coldkey", "Subnets for a particular coldkey"),
+    #             ],
+    #             default="all",
+    #         )
+    #         if mode == "all":
+    #             all_subnets = True
+    #         else:
+    #             # Show available wallets and let user select
+    #             from ...utils.wallet.crypto import list_keys
+
+    #             wallets = list_keys()
+    #             if not wallets:
+    #                 print_error("No wallets found. Please create a wallet first.")
+    #                 raise typer.Abort()
+    #             # Extract coldkeys only (exclude hotkeys)
+    #             coldkey_list = [w for w in wallets if not w.get("is_hotkey", False)]
+
+    #             if not coldkey_list:
+    #                 print_error("No coldkeys found.")
+    #                 raise typer.Abort()
+
+    #             # Format wallet choices for display
+    #             coldkey_choices = []
+    #             for wallet in coldkey_list:
+    #                 name = wallet.get("name", "Unknown")
+    #                 address = wallet.get("ss58_address") or wallet.get(
+    #                     "address", "Unknown"
+    #                 )
+    #                 # Format address like MetaMask style: 0x + first 5 + ... + last 5
+    #                 if address and len(address) > 10:
+    #                     if address.startswith("0x"):
+    #                         clean_address = address[2:]
+    #                         if len(clean_address) > 10:
+    #                             formatted_address = (
+    #                                 f"0x{clean_address[:5]}...{clean_address[-5:]}"
+    #                             )
+    #                         else:
+    #                             formatted_address = address
+    #                     else:
+    #                         if len(address) > 10:
+    #                             formatted_address = f"{address[:6]}...{address[-6:]}"
+    #                         else:
+    #                             formatted_address = address
+    #                 else:
+    #                     formatted_address = address
+    #                 display = f"{name} ({formatted_address})"
+    #                 coldkey_choices.append((address, display))
+
+    #             selected_coldkey = prompt.select(
+    #                 "Select a wallet (coldkey)",
+    #                 choices=coldkey_choices,
+    #             )
+    #             # Normalize Ethereum addresses to lowercase
+    #             coldkey = (
+    #                 selected_coldkey.lower()
+    #                 if selected_coldkey.startswith("0x")
+    #                 else selected_coldkey
+    #             )
+    #     except (KeyboardInterrupt, EOFError):
+    #         print_error("Operation cancelled")
+    #         raise typer.Abort()
+    #     except typer.Abort:
+    #         raise
+    #     except Exception:
+    #         # If interactive input fails, default to all
+    #         all_subnets = True
+
+    # Call handler directly (coldkey filtering commented out for now)
+    list_subnets_handler(all_subnets, active_only, coldkey=coldkey)
+
+
+@app.command("cost")
+def registration_cost():
+    """Query current subnet registration cost."""
+    registration_cost_handler()
+
+
+@app.command("register", help=REGISTER_SUBNET_HELP)
+def register_subnet(
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+    name: Optional[str] = typer.Option(
+        None, "--name", help="Unique name of the subnet"
+    ),
+    repo: Optional[str] = typer.Option(
+        None, "--repo", help="GitHub or similar link to source code"
+    ),
+    description: Optional[str] = typer.Option(
+        None, "--description", help="Description of the subnet"
+    ),
+    misc: Optional[str] = typer.Option(
+        None, "--misc", help="Miscellaneous information"
+    ),
+    min_stake: Optional[float] = typer.Option(
+        None,
+        "--min-stake",
+        help="Minimum required stake balance to register a node (in TENSOR, e.g. 100.0 for 100 TENSOR)",
+    ),
+    max_stake: Optional[float] = typer.Option(
+        None,
+        "--max-stake",
+        help="Maximum allowable stake balance for a subnet node (in TENSOR, e.g. 1000.0 for 1000 TENSOR)",
+    ),
+    max_cost: Optional[float] = typer.Option(
+        None,
+        "--max-cost",
+        help="Maximum cost willing to pay for registration (in TENSOR, e.g. 800000 for 800k TENSOR)",
+    ),
+    delegate_stake_percentage: Optional[int] = typer.Option(
+        None,
+        "--delegate-percentage",
+        help="Percentage of emissions given to delegate stakers (5-95, e.g. 20 for 20%)",
+    ),
+    # Note: Configuration fields like churn_limit, queue_epochs, max_registered_nodes, etc.
+    # are NOT part of RegistrationSubnetData and cannot be set during registration.
+    # They must be set separately after registration using owner update commands.
+    initial_coldkeys: Optional[str] = typer.Option(
+        None,
+        "--initial-coldkeys",
+        help="Comma-separated list of at least 3 initial coldkey addresses (required for registration, becomes permissionless after activation)",
+    ),
+    key_types: Optional[str] = typer.Option(
+        None,
+        "--key-types",
+        help="Comma-separated key types (Ed25519,Ecdsa,Secp256k1,Rsa) - required when using --initial-coldkeys",
+    ),
+    bootnodes: Optional[str] = typer.Option(
+        None,
+        "--bootnodes",
+        help="Comma-separated list of bootnode addresses (e.g., /ip4/1.2.3.4/tcp/30333,/dns4/node.example/tcp/30333)",
+    ),
+):
+    """Register a new subnet on the network."""
+    register_subnet_handler(
+        coldkey=coldkey,
+        name=name,
+        repo=repo,
+        description=description,
+        misc=misc,
+        min_stake=min_stake,
+        max_stake=max_stake,
+        max_cost=max_cost,
+        delegate_stake_percentage=delegate_stake_percentage,
+        initial_coldkeys=initial_coldkeys,
+        key_types=key_types,
+        bootnodes=bootnodes,
+    )
+
+
+@app.command("check-activation")
+def check_activation(
+    subnet_id: Optional[int] = typer.Option(
+        None,
+        "--subnet-id",
+        "--subnetid",
+        help="The unique ID (UID) of the subnet to check activation requirements for.",
+    ),
+):
+    """Check if a subnet meets activation requirements including minimum registration epochs."""
+    check_activation_handler(subnet_id)
+
+
+@app.command("activate")
+def activate_subnet(
+    subnet_id: Optional[int] = typer.Option(
+        None,
+        "--subnet-id",
+        "--subnetid",
+        help="The unique ID (UID) of the subnet to activate.",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Activate a registered subnet. (owner only)"""
+    activate_subnet_handler(subnet_id, coldkey=coldkey)
+
+
+@app.command("pause")
+def pause_subnet(
+    subnet_id: Optional[int] = typer.Option(
+        None,
+        "--subnet-id",
+        "--subnetid",
+        help="The unique ID (UID) of the subnet to pause.",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Pause a subnet's operations. (owner only)"""
+    pause_subnet_handler(subnet_id, coldkey=coldkey)
+
+
+@app.command("unpause")
+def unpause_subnet(
+    subnet_id: Optional[int] = typer.Option(
+        None,
+        "--subnet-id",
+        "--subnetid",
+        help="The unique ID (UID) of the subnet to unpause.",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Unpause a subnet's operations. (owner only)"""
+    unpause_subnet_handler(subnet_id, coldkey=coldkey)
+
+
+@app.command("update")
+def owner_update(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The UID of the subnet to update."
+    ),
+    new_name: Optional[str] = typer.Option(
+        None, "--name", help="The new name for the subnet."
+    ),
+    new_repo: Optional[str] = typer.Option(
+        None, "--repo", help="The new repository URL for the subnet."
+    ),
+    target_node_registrations: Optional[int] = typer.Option(
+        None,
+        "--target-node-registrations",
+        help="Target number of node registrations per epoch.",
+    ),
+    node_burn_rate_alpha: Optional[int] = typer.Option(
+        None,
+        "--node-burn-rate-alpha",
+        help="Node burn rate alpha value (in wei format).",
+    ),
+    queue_immunity_epochs: Optional[int] = typer.Option(
+        None,
+        "--queue-immunity-epochs",
+        help="Number of epochs nodes are immune from queue removal.",
+    ),
+    min_weight_decrease_threshold: Optional[int] = typer.Option(
+        None,
+        "--min-weight-decrease-threshold",
+        help="Minimum weight decrease reputation threshold (in wei format).",
+    ),
+    min_node_reputation: Optional[int] = typer.Option(
+        None,
+        "--min-node-reputation",
+        help="Minimum subnet node reputation (in wei format).",
+    ),
+    absent_reputation_penalty: Optional[int] = typer.Option(
+        None,
+        "--absent-reputation-penalty",
+        help="Absent decrease reputation factor (in wei format).",
+    ),
+    included_reputation_boost: Optional[int] = typer.Option(
+        None,
+        "--included-reputation-boost",
+        help="Included increase reputation factor (in wei format).",
+    ),
+    below_min_weight_penalty: Optional[int] = typer.Option(
+        None,
+        "--below-min-weight-penalty",
+        help="Below-min weight decrease reputation factor (in wei format).",
+    ),
+    non_attestor_penalty: Optional[int] = typer.Option(
+        None,
+        "--non-attestor-penalty",
+        help="Non-attestor decrease reputation factor (in wei format).",
+    ),
+    validator_absent_penalty: Optional[int] = typer.Option(
+        None,
+        "--validator-absent-penalty",
+        help="Validator absent decrease reputation factor (in wei format).",
+    ),
+    validator_non_consensus_penalty: Optional[int] = typer.Option(
+        None,
+        "--validator-non-consensus-penalty",
+        help="Validator non-consensus decrease reputation factor (in wei format).",
+    ),
+    non_consensus_attestor_penalty: Optional[int] = typer.Option(
+        None,
+        "--non-consensus-attestor-penalty",
+        help="Non-consensus attestor decrease reputation factor (in wei format).",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Update subnet properties. (owner only)"""
+    owner_update_handler(
+        subnet_id,
+        new_name,
+        new_repo,
+        target_node_registrations=target_node_registrations,
+        node_burn_rate_alpha=node_burn_rate_alpha,
+        queue_immunity_epochs=queue_immunity_epochs,
+        min_weight_decrease_threshold=min_weight_decrease_threshold,
+        min_node_reputation=min_node_reputation,
+        absent_reputation_penalty=absent_reputation_penalty,
+        included_reputation_boost=included_reputation_boost,
+        below_min_weight_penalty=below_min_weight_penalty,
+        non_attestor_penalty=non_attestor_penalty,
+        validator_absent_penalty=validator_absent_penalty,
+        validator_non_consensus_penalty=validator_non_consensus_penalty,
+        non_consensus_attestor_penalty=non_consensus_attestor_penalty,
+        coldkey=coldkey,
+    )
+
+
+@app.command("transfer")
+def owner_transfer(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The UID of the subnet to transfer."
+    ),
+    new_owner: Optional[str] = typer.Option(
+        None,
+        "--to",
+        help="The EVM address or wallet name of the new owner (e.g., 0x... or wallet-name).",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Transfer ownership of a subnet to a new address. (owner only)"""
+    owner_transfer_handler(subnet_id, new_owner, coldkey=coldkey)
+
+
+@app.command("accept")
+def owner_accept(
+    subnet_id: Optional[int] = typer.Option(
+        None,
+        "--subnet-id",
+        "--subnetid",
+        help="The UID of the subnet to accept ownership of.",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Accept a pending ownership transfer for a subnet. (owner only)"""
+    owner_accept_handler(subnet_id, coldkey=coldkey)
+
+
+@app.command("remove")
+def owner_remove(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The UID of the subnet to remove."
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Permanently remove a subnet you own from the network. (owner only)"""
+    owner_remove_handler(subnet_id, coldkey=coldkey)
+
+
+@app.command("set-emergency-validator-set")
+def owner_set_emergency_validator_set(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The UID of the subnet."
+    ),
+    node_ids: Optional[str] = typer.Option(
+        None,
+        "--node-ids",
+        help="Comma-separated list of subnet node IDs for emergency validator set.",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Set emergency validator set for a subnet. (owner only)"""
+    owner_set_emergency_validator_set_handler(subnet_id, node_ids, coldkey=coldkey)
+
+
+@app.command("clear-emergency-validator-set")
+def owner_clear_emergency_validator_set(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The UID of the subnet."
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Clear emergency validator set for a subnet. (owner only)"""
+    owner_clear_emergency_validator_set_handler(subnet_id, coldkey=coldkey)
+
+
+@app.command("add-bootnode-access")
+def owner_add_bootnode_access(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The UID of the subnet."
+    ),
+    account: Optional[str] = typer.Option(
+        None, "--account", help="Account address to grant bootnode access to."
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Grant bootnode access to an account. (owner only)"""
+    owner_add_bootnode_access_handler(subnet_id, account, coldkey=coldkey)
+
+
+@app.command("remove-bootnode-access")
+def owner_remove_bootnode_access(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The UID of the subnet."
+    ),
+    account: Optional[str] = typer.Option(
+        None, "--account", help="Account address to revoke bootnode access from."
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Revoke bootnode access from an account. (owner only)"""
+    owner_remove_bootnode_access_handler(subnet_id, account, coldkey=coldkey)
+
+
+@app.command("add-bootnode")
+def owner_add_bootnode(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The UID of the subnet."
+    ),
+    bootnode_address: Optional[str] = typer.Option(
+        None,
+        "--bootnode-address",
+        help="The bootnode multiaddress to add (e.g., /ip4/1.2.3.4/tcp/30333/p2p/...).",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Add a bootnode address to the subnet. (owner only)"""
+    owner_add_bootnode_handler(subnet_id, bootnode_address, coldkey=coldkey)
+
+
+@app.command("remove-bootnode")
+def owner_remove_bootnode(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The UID of the subnet."
+    ),
+    bootnode_address: Optional[str] = typer.Option(
+        None,
+        "--bootnode-address",
+        help="The bootnode multiaddress to remove.",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        "-c",
+        help="The coldkey wallet name or address to sign the transaction with.",
+    ),
+):
+    """Remove a bootnode address from the subnet. (owner only)"""
+    owner_remove_bootnode_handler(subnet_id, bootnode_address, coldkey=coldkey)
+
+
+# New RPC-based commands
+@app.command("info")
+def get_subnet_info(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The subnet ID to get information for"
+    ),
+    all_subnets: bool = typer.Option(
+        False, "--all", help="Show information for every subnet on the network"
+    ),
+):
+    """Get detailed information about a specific subnet or all subnets using RPC."""
+    get_subnet_info_handler(subnet_id, all_subnets=all_subnets)
+
+
+@app.command("nodes")
+def get_subnet_nodes(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The subnet ID to get nodes for"
+    ),
+):
+    """Get all nodes in a specific subnet using RPC."""
+    get_subnet_nodes_handler(subnet_id, None)
+
+
+@app.command("bootnodes")
+def get_bootnodes(
+    subnet_id: Optional[int] = typer.Option(
+        None, "--subnet-id", "--subnetid", help="The subnet ID to get bootnodes for"
+    ),
+):
+    """Get bootnodes for a specific subnet using RPC."""
+    get_bootnodes_handler(subnet_id)
+
+
+__all__ = ["app"]