htcli 1.1.0__py3-none-any.whl

src/htcli/commands/validator/__init__.py

@@ -0,0 +1,192 @@
+"""
+Validator command module.
+"""
+
+from typing import Optional
+
+import typer
+
+from . import handlers as validator_handlers
+
+app = typer.Typer(name="validator", help="Validator operations")
+
+
+@app.command("register")
+def register_validator(
+    hotkey: Optional[str] = typer.Option(
+        None, "--hotkey", help="Validator hotkey address"
+    ),
+    delegate_rate: Optional[int] = typer.Option(
+        None,
+        "--delegate-rate",
+        help="Delegate reward rate (0-100 as percent, or 1e18-format value)",
+    ),
+    delegate_account: Optional[str] = typer.Option(
+        None, "--delegate-account", help="Optional delegate account address"
+    ),
+    delegate_account_rate: Optional[int] = typer.Option(
+        None,
+        "--delegate-account-rate",
+        help="Optional delegate account rate (0-100 as percent, or 1e18-format value)",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Coldkey wallet name or address to sign the registration extrinsic",
+    ),
+):
+    """Register a validator."""
+    validator_handlers.register_validator_handler(
+        hotkey=hotkey,
+        delegate_rate=delegate_rate,
+        delegate_account=delegate_account,
+        delegate_account_rate=delegate_account_rate,
+        coldkey=coldkey,
+    )
+
+
+@app.command("update-delegate-rate")
+def update_delegate_rate(
+    validator_id: Optional[int] = typer.Option(
+        None, "--validator-id", help="Validator ID to update"
+    ),
+    delegate_rate: Optional[int] = typer.Option(
+        None,
+        "--delegate-rate",
+        help="Delegate reward rate (0-100 as percent, or 1e18-format value)",
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Coldkey wallet name or address to sign the update extrinsic",
+    ),
+):
+    """Update a validator delegate reward rate."""
+    validator_handlers.update_delegate_rate_handler(
+        validator_id=validator_id,
+        delegate_rate=delegate_rate,
+        coldkey=coldkey,
+    )
+
+
+@app.command("update-delegate-account")
+def update_delegate_account(
+    validator_id: Optional[int] = typer.Option(
+        None, "--validator-id", help="Validator ID to update"
+    ),
+    delegate_account: Optional[str] = typer.Option(
+        None, "--delegate-account", help="Delegate account address"
+    ),
+    delegate_account_rate: Optional[int] = typer.Option(
+        None,
+        "--delegate-account-rate",
+        help="Delegate account rate (0-100 as percent, or 1e18-format value)",
+    ),
+    clear: bool = typer.Option(
+        False, "--clear", help="Clear the validator delegate account"
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Coldkey wallet name or address to sign the update extrinsic",
+    ),
+):
+    """Update or clear a validator delegate account."""
+    validator_handlers.update_delegate_account_handler(
+        validator_id=validator_id,
+        delegate_account=delegate_account,
+        delegate_account_rate=delegate_account_rate,
+        clear=clear,
+        coldkey=coldkey,
+    )
+
+
+@app.command("update-hotkey")
+def update_hotkey(
+    validator_id: Optional[int] = typer.Option(
+        None, "--validator-id", help="Validator ID to update"
+    ),
+    hotkey: Optional[str] = typer.Option(
+        None, "--hotkey", help="New validator hotkey address"
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Coldkey wallet name or address to sign the update extrinsic",
+    ),
+):
+    """Update a validator hotkey."""
+    validator_handlers.update_hotkey_handler(
+        validator_id=validator_id,
+        hotkey=hotkey,
+        coldkey=coldkey,
+    )
+
+
+@app.command("update-coldkey")
+def update_coldkey(
+    validator_id: Optional[int] = typer.Option(
+        None, "--validator-id", help="Validator ID to update"
+    ),
+    new_coldkey: Optional[str] = typer.Option(
+        None, "--new-coldkey", help="New validator coldkey address"
+    ),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Current coldkey wallet name or address to sign the update extrinsic",
+    ),
+):
+    """Update a validator coldkey."""
+    validator_handlers.update_coldkey_handler(
+        validator_id=validator_id,
+        new_coldkey=new_coldkey,
+        coldkey=coldkey,
+    )
+
+
+@app.command("update-identity")
+def update_identity(
+    validator_id: Optional[int] = typer.Option(
+        None, "--validator-id", help="Validator ID to update"
+    ),
+    name: Optional[str] = typer.Option(None, "--name", help="Display name"),
+    url: Optional[str] = typer.Option(None, "--url", help="Website URL"),
+    image: Optional[str] = typer.Option(None, "--image", help="Profile image URL"),
+    discord: Optional[str] = typer.Option(None, "--discord", help="Discord handle"),
+    x: Optional[str] = typer.Option(None, "--x", help="X handle"),
+    telegram: Optional[str] = typer.Option(None, "--telegram", help="Telegram handle"),
+    github: Optional[str] = typer.Option(None, "--github", help="GitHub profile URL"),
+    hugging_face: Optional[str] = typer.Option(
+        None, "--hugging-face", help="Hugging Face profile URL"
+    ),
+    description: Optional[str] = typer.Option(
+        None, "--description", help="Short description"
+    ),
+    misc: Optional[str] = typer.Option(None, "--misc", help="Additional data"),
+    clear: bool = typer.Option(False, "--clear", help="Clear validator identity"),
+    coldkey: Optional[str] = typer.Option(
+        None,
+        "--coldkey",
+        help="Coldkey wallet name or address to sign the update extrinsic",
+    ),
+):
+    """Update or clear a validator identity."""
+    validator_handlers.update_identity_handler(
+        validator_id=validator_id,
+        name=name,
+        url=url,
+        image=image,
+        discord=discord,
+        x=x,
+        telegram=telegram,
+        github=github,
+        hugging_face=hugging_face,
+        description=description,
+        misc=misc,
+        clear=clear,
+        coldkey=coldkey,
+    )
+
+
+__all__ = ["app"]

src/htcli/commands/validator/display.py

@@ -0,0 +1,54 @@
+"""
+Validator command display helpers.
+"""
+
+from typing import Any
+
+from ...ui.colors import error, info, success
+from ...ui.components import HTCLIPanel
+from ...ui.display import HTCLIConsole
+
+console = HTCLIConsole()
+
+
+def _response_value(response: Any, field: str, default: Any = None) -> Any:
+    if isinstance(response, dict):
+        return response.get(field, default)
+    return getattr(response, field, default)
+
+
+def display_validator_result(response: Any, operation: str) -> None:
+    """Display a validator extrinsic response."""
+    succeeded = _response_value(response, "success", False)
+    message = _response_value(response, "message") or operation
+    transaction_hash = _response_value(response, "transaction_hash")
+    block_number = _response_value(response, "block_number")
+    validator_id = _response_value(response, "validator_id")
+    hotkey = _response_value(response, "hotkey")
+
+    if not succeeded:
+        error_message = _response_value(response, "error", f"{operation} failed")
+        panel = HTCLIPanel(
+            error(str(error_message)),
+            title=f"{operation} Failed",
+            border_style="htcli.error",
+        )
+        panel.render(console.console)
+        return
+
+    lines = [success(str(message))]
+    if validator_id is not None:
+        lines.append(f"[htcli.value]Validator ID:[/htcli.value] {validator_id}")
+    if hotkey:
+        lines.append(f"[htcli.value]Hotkey:[/htcli.value] {hotkey}")
+    if transaction_hash:
+        lines.append(f"[htcli.value]Transaction:[/htcli.value] {transaction_hash}")
+    if block_number is not None:
+        lines.append(f"[htcli.value]Block:[/htcli.value] {block_number}")
+
+    panel = HTCLIPanel(
+        "\n".join(lines) if lines else info("Submitted"),
+        title=operation,
+        border_style="htcli.success",
+    )
+    panel.render(console.console)

src/htcli/commands/validator/handlers.py

@@ -0,0 +1,340 @@
+"""
+Validator command handlers.
+"""
+
+from typing import Optional
+
+from ...dependencies import get_client
+from ...errors.handlers import handle_and_display_error
+from ...models.requests.validator import (
+    ValidatorColdkeyUpdateRequest,
+    ValidatorDelegateAccountUpdateRequest,
+    ValidatorDelegateRewardRateUpdateRequest,
+    ValidatorHotkeyUpdateRequest,
+    ValidatorIdentityUpdateRequest,
+    ValidatorRegisterRequest,
+)
+from ...ui.components import HTCLILoadingContext
+from ...ui.display import print_error
+from ...utils import retrieve_wallet_with_validation
+from ...utils.prompts import integer_prompt, string_prompt
+from ..node.prompts import normalize_delegate_reward_rate
+from .display import display_validator_result
+
+
+def _resolve_signing_keypair(coldkey: Optional[str], purpose: str):
+    if coldkey:
+        from ...utils.wallet.core import resolve_coldkey_and_get_keypair
+
+        return resolve_coldkey_and_get_keypair(coldkey)
+    return retrieve_wallet_with_validation(wallet_type="coldkey", purpose=purpose)
+
+
+def _connect_client():
+    client = get_client()
+    if not client.connect():
+        print_error("Failed to connect to blockchain")
+        return None
+    if not client.substrate:
+        print_error("Blockchain connection failed!")
+        raise RuntimeError("Not connected to blockchain")
+    if not client.extrinsics:
+        print_error("Extrinsics layer not initialized. Connection may have failed.")
+        raise RuntimeError("Extrinsics layer not available")
+    return client
+
+
+def _rate_or_prompt(value: Optional[int], prompt_text: str) -> int:
+    if value is None:
+        value = integer_prompt(prompt_text)
+    return normalize_delegate_reward_rate(value)
+
+
+def register_validator_handler(
+    hotkey: Optional[str] = None,
+    delegate_rate: Optional[int] = None,
+    delegate_account: Optional[str] = None,
+    delegate_account_rate: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle validator registration."""
+    try:
+        if hotkey is None:
+            hotkey = string_prompt("Enter validator hotkey address")
+
+        delegate_reward_rate = _rate_or_prompt(
+            delegate_rate, "Enter delegate reward rate"
+        )
+        delegate_account_rate = (
+            normalize_delegate_reward_rate(delegate_account_rate)
+            if delegate_account_rate is not None
+            else None
+        )
+
+        _, keypair = _resolve_signing_keypair(
+            coldkey, "sign the validator registration transaction"
+        )
+
+        request = ValidatorRegisterRequest(
+            hotkey=hotkey,
+            delegate_reward_rate=delegate_reward_rate,
+            delegate_account_id=delegate_account,
+            delegate_account_rate=delegate_account_rate,
+            identity=None,
+        )
+
+        client = _connect_client()
+        if client is None:
+            return
+
+        with HTCLILoadingContext("Registering validator..."):
+            response = client.extrinsics.validator.register_validator(request, keypair)
+
+        display_validator_result(response, "Validator Registration")
+    except Exception as e:
+        handle_and_display_error(e, operation="validator register")
+
+
+def update_delegate_rate_handler(
+    validator_id: Optional[int] = None,
+    delegate_rate: Optional[int] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle validator delegate reward rate updates."""
+    try:
+        if validator_id is None:
+            validator_id = integer_prompt("Enter validator ID")
+        new_delegate_reward_rate = _rate_or_prompt(
+            delegate_rate, "Enter new delegate reward rate"
+        )
+
+        _, keypair = _resolve_signing_keypair(
+            coldkey, "sign the validator delegate reward rate update transaction"
+        )
+        request = ValidatorDelegateRewardRateUpdateRequest(
+            validator_id=validator_id,
+            new_delegate_reward_rate=new_delegate_reward_rate,
+        )
+
+        client = _connect_client()
+        if client is None:
+            return
+
+        with HTCLILoadingContext(
+            f"Updating validator {validator_id} delegate reward rate..."
+        ):
+            response = (
+                client.extrinsics.validator.update_validator_delegate_reward_rate(
+                    request, keypair
+                )
+            )
+
+        display_validator_result(response, "Validator Delegate Rate Update")
+    except Exception as e:
+        handle_and_display_error(e, operation="validator update delegate rate")
+
+
+def update_delegate_account_handler(
+    validator_id: Optional[int] = None,
+    delegate_account: Optional[str] = None,
+    delegate_account_rate: Optional[int] = None,
+    clear: bool = False,
+    coldkey: Optional[str] = None,
+):
+    """Handle validator delegate account updates."""
+    try:
+        if validator_id is None:
+            validator_id = integer_prompt("Enter validator ID")
+
+        if clear:
+            delegate_account = None
+            delegate_rate = None
+        else:
+            if delegate_account is None:
+                delegate_account = string_prompt("Enter delegate account address")
+            delegate_rate = (
+                normalize_delegate_reward_rate(delegate_account_rate)
+                if delegate_account_rate is not None
+                else None
+            )
+
+        _, keypair = _resolve_signing_keypair(
+            coldkey, "sign the validator delegate account update transaction"
+        )
+        request = ValidatorDelegateAccountUpdateRequest(
+            validator_id=validator_id,
+            delegate_account_id=delegate_account,
+            delegate_rate=delegate_rate,
+        )
+
+        client = _connect_client()
+        if client is None:
+            return
+
+        with HTCLILoadingContext(
+            f"Updating validator {validator_id} delegate account..."
+        ):
+            response = client.extrinsics.validator.update_validator_delegate_account(
+                request, keypair
+            )
+
+        display_validator_result(response, "Validator Delegate Account Update")
+    except Exception as e:
+        handle_and_display_error(e, operation="validator update delegate account")
+
+
+def update_hotkey_handler(
+    validator_id: Optional[int] = None,
+    hotkey: Optional[str] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle validator hotkey updates."""
+    try:
+        if validator_id is None:
+            validator_id = integer_prompt("Enter validator ID")
+        if hotkey is None:
+            hotkey = string_prompt("Enter new validator hotkey address")
+
+        _, keypair = _resolve_signing_keypair(
+            coldkey, "sign the validator hotkey update transaction"
+        )
+        request = ValidatorHotkeyUpdateRequest(
+            validator_id=validator_id,
+            new_hotkey=hotkey,
+        )
+
+        client = _connect_client()
+        if client is None:
+            return
+
+        with HTCLILoadingContext(f"Updating validator {validator_id} hotkey..."):
+            response = client.extrinsics.validator.update_validator_hotkey(
+                request, keypair
+            )
+
+        display_validator_result(response, "Validator Hotkey Update")
+    except Exception as e:
+        handle_and_display_error(e, operation="validator update hotkey")
+
+
+def update_coldkey_handler(
+    validator_id: Optional[int] = None,
+    new_coldkey: Optional[str] = None,
+    coldkey: Optional[str] = None,
+):
+    """Handle validator coldkey updates."""
+    try:
+        if validator_id is None:
+            validator_id = integer_prompt("Enter validator ID")
+        if new_coldkey is None:
+            new_coldkey = string_prompt("Enter new validator coldkey address")
+
+        _, keypair = _resolve_signing_keypair(
+            coldkey, "sign the validator coldkey update transaction"
+        )
+        request = ValidatorColdkeyUpdateRequest(
+            validator_id=validator_id,
+            new_coldkey=new_coldkey,
+        )
+
+        client = _connect_client()
+        if client is None:
+            return
+
+        with HTCLILoadingContext(f"Updating validator {validator_id} coldkey..."):
+            response = client.extrinsics.validator.update_validator_coldkey(
+                request, keypair
+            )
+
+        display_validator_result(response, "Validator Coldkey Update")
+    except Exception as e:
+        handle_and_display_error(e, operation="validator update coldkey")
+
+
+def _encode_identity_fields(
+    name: Optional[str] = None,
+    url: Optional[str] = None,
+    image: Optional[str] = None,
+    discord: Optional[str] = None,
+    x: Optional[str] = None,
+    telegram: Optional[str] = None,
+    github: Optional[str] = None,
+    hugging_face: Optional[str] = None,
+    description: Optional[str] = None,
+    misc: Optional[str] = None,
+) -> dict[str, bytes]:
+    values = {
+        "name": name,
+        "url": url,
+        "image": image,
+        "discord": discord,
+        "x": x,
+        "telegram": telegram,
+        "github": github,
+        "hugging_face": hugging_face,
+        "description": description,
+        "misc": misc,
+    }
+    if not any(value is not None for value in values.values()):
+        raise ValueError("Provide at least one identity field or use --clear")
+    return {
+        field: ("" if value is None else value).encode("utf-8")
+        for field, value in values.items()
+    }
+
+
+def update_identity_handler(
+    validator_id: Optional[int] = None,
+    name: Optional[str] = None,
+    url: Optional[str] = None,
+    image: Optional[str] = None,
+    discord: Optional[str] = None,
+    x: Optional[str] = None,
+    telegram: Optional[str] = None,
+    github: Optional[str] = None,
+    hugging_face: Optional[str] = None,
+    description: Optional[str] = None,
+    misc: Optional[str] = None,
+    clear: bool = False,
+    coldkey: Optional[str] = None,
+):
+    """Handle validator identity updates."""
+    try:
+        if validator_id is None:
+            validator_id = integer_prompt("Enter validator ID")
+
+        identity = None
+        if not clear:
+            identity = _encode_identity_fields(
+                name=name,
+                url=url,
+                image=image,
+                discord=discord,
+                x=x,
+                telegram=telegram,
+                github=github,
+                hugging_face=hugging_face,
+                description=description,
+                misc=misc,
+            )
+
+        _, keypair = _resolve_signing_keypair(
+            coldkey, "sign the validator identity update transaction"
+        )
+        request = ValidatorIdentityUpdateRequest(
+            validator_id=validator_id,
+            identity=identity,
+        )
+
+        client = _connect_client()
+        if client is None:
+            return
+
+        with HTCLILoadingContext(f"Updating validator {validator_id} identity..."):
+            response = client.extrinsics.validator.update_validator_identity(
+                request, keypair
+            )
+
+        display_validator_result(response, "Validator Identity Update")
+    except Exception as e:
+        handle_and_display_error(e, operation="validator update identity")