cartha-cli 1.0.0__py3-none-any.whl

cartha_cli/commands/register.py

@@ -0,0 +1,274 @@
+"""Register command."""
+
+from __future__ import annotations
+
+import bittensor as bt
+import typer
+from rich.prompt import Confirm
+from rich.table import Table
+
+from ..bt import (
+    RegistrationResult,
+    get_burn_cost,
+    get_subtensor,
+    get_wallet,
+    register_hotkey,
+)
+from ..config import settings
+from ..display import display_clock_and_countdown
+from ..verifier import VerifierError
+from .common import (
+    console,
+    handle_unexpected_exception,
+    handle_wallet_exception,
+)
+from .shared_options import (
+    wallet_name_option,
+    wallet_hotkey_option,
+    network_option,
+    netuid_option,
+)
+
+
+def register(
+    wallet_name: str | None = wallet_name_option(required=False),
+    wallet_hotkey: str | None = wallet_hotkey_option(required=False),
+    network: str = network_option(),
+    netuid: int = netuid_option(),
+    burned: bool = typer.Option(
+        True,
+        "--burned/--pow",
+        help="Burned registration by default; pass --pow to run PoW registration.",
+    ),
+    cuda: bool = typer.Option(
+        False, "--cuda", help="Enable CUDA for PoW registration."
+    ),
+) -> None:
+    """Register your hotkey on the Cartha subnet (subnet 35 on finney, subnet 78 on testnet).
+    
+    USAGE:
+    ------
+    Interactive mode (recommended): 'cartha miner register' (will prompt for wallet)
+    With arguments: 'cartha miner register -w cold -wh hot'
+    
+    ALIASES:
+    --------
+    Wallet: --wallet-name, --coldkey, -w  |  --wallet-hotkey, --hotkey, -wh
+    Network: --network, -n
+    
+    REGISTRATION OPTIONS:
+    ---------------------
+    --burned (default): Register using burned TAO
+    --pow: Register using Proof of Work
+    --cuda: Enable CUDA for PoW registration
+    
+    After registration, use 'cartha vault lock' to create lock positions.
+    
+    ⚠️  Note: Password generation is no longer supported. The new lock flow uses 
+    session tokens instead of passwords.
+    """
+
+    assert wallet_name is not None  # nosec - enforced by Typer prompt
+    assert wallet_hotkey is not None  # nosec - enforced by Typer prompt
+
+    # Auto-map netuid and verifier URL based on network
+    if network == "test":
+        netuid = 78
+    elif network == "finney":
+        netuid = 35
+        # Warn that mainnet is not live yet
+        console.print()
+        console.print("[bold yellow]⚠️  MAINNET NOT AVAILABLE YET[/]")
+        console.print()
+        console.print("[yellow]Cartha subnet is currently in testnet phase (subnet 78 on test network).[/]")
+        console.print("[yellow]Mainnet (subnet 35 on finney network) has not been announced yet.[/]")
+        console.print()
+        console.print("[bold cyan]To use testnet:[/]")
+        console.print("  cartha miner register --network test")
+        console.print()
+        console.print("[dim]If you continue with finney network, registration will attempt[/]")
+        console.print("[dim]subnet 35 but the subnet may not be operational yet.[/]")
+        console.print()
+        if not Confirm.ask("[yellow]Continue with finney network anyway?[/]", default=False):
+            console.print("[yellow]Cancelled. Use --network test for testnet.[/]")
+            raise typer.Exit(code=0)
+    # Note: netuid parameter is kept for backwards compatibility / explicit override
+    
+    from ..config import get_verifier_url_for_network
+    expected_verifier_url = get_verifier_url_for_network(network)
+    if settings.verifier_url != expected_verifier_url:
+        settings.verifier_url = expected_verifier_url
+
+    subtensor = None
+    try:
+        # Initialize subtensor and wallet to get info before registration
+        try:
+            subtensor = get_subtensor(network)
+            wallet = get_wallet(wallet_name, wallet_hotkey)
+        except bt.KeyFileError as exc:
+            handle_wallet_exception(
+                wallet_name=wallet_name, wallet_hotkey=wallet_hotkey, exc=exc
+            )
+        except typer.Exit:
+            raise
+        except Exception as exc:
+            handle_unexpected_exception("Failed to initialize wallet/subtensor", exc)
+
+        hotkey_ss58 = wallet.hotkey.ss58_address
+        coldkey_ss58 = wallet.coldkeypub.ss58_address
+
+        # Check if already registered
+        if subtensor.is_hotkey_registered(hotkey_ss58, netuid=netuid):
+            neuron = subtensor.get_neuron_for_pubkey_and_subnet(hotkey_ss58, netuid)
+            uid = (
+                None if getattr(neuron, "is_null", False) else getattr(neuron, "uid", None)
+            )
+            if uid is not None:
+                console.print(f"[bold yellow]Hotkey already registered[/]. UID: {uid}")
+                raise typer.Exit(code=0)
+
+        # Get registration cost and balance
+        registration_cost = None
+        balance = None
+
+        if burned:
+            try:
+                registration_cost = get_burn_cost(network, netuid)
+            except Exception as exc:
+                # Log warning but continue - cost may not be available on all networks
+                console.print(
+                    f"[bold yellow]Warning: Could not fetch registration cost[/]: {exc}"
+                )
+
+        try:
+            balance_obj = subtensor.get_balance(coldkey_ss58)
+            # Convert Balance object to float using .tao property
+            balance = balance_obj.tao if hasattr(balance_obj, "tao") else float(balance_obj)
+        except Exception:
+            pass
+
+        # Display registration summary table (like btcli)
+        console.print(f"[bold]Using the wallet path from config:[/] {wallet.path}")
+
+        summary_table = Table(title="Registration Summary")
+        summary_table.add_column("Field", style="cyan")
+        summary_table.add_column("Value", style="yellow")
+
+        summary_table.add_row("Netuid", str(netuid))
+        if burned:
+            if registration_cost is not None:
+                summary_table.add_row("Cost", f"τ {registration_cost:.4f}")
+            else:
+                summary_table.add_row("Cost", "Unable to fetch")
+        summary_table.add_row("Hotkey", hotkey_ss58)
+        summary_table.add_row("Coldkey", coldkey_ss58)
+        summary_table.add_row("Network", network)
+
+        console.print(summary_table)
+
+        # Display balance and cost (already converted to float above)
+        if balance is not None:
+            console.print(f"\n[bold]Your balance is:[/] {balance:.4f} τ")
+
+        if registration_cost is not None:
+            console.print(
+                f"[bold]The cost to register by recycle is[/] {registration_cost:.4f} τ"
+            )
+
+        # Display clock and countdown
+        console.print()
+        display_clock_and_countdown()
+
+        # Confirmation prompt
+        if not typer.confirm("\nDo you want to continue?", default=False):
+            console.print("[bold yellow]Registration cancelled.[/]")
+            raise typer.Exit(code=0)
+
+        console.print("\n[bold cyan]Registering...[/]")
+
+        try:
+            result: RegistrationResult = register_hotkey(
+                network=network,
+                wallet_name=wallet_name,
+                hotkey_name=wallet_hotkey,
+                netuid=netuid,
+                burned=burned,
+                cuda=cuda,
+            )
+        except bt.KeyFileError as exc:
+            handle_wallet_exception(
+                wallet_name=wallet_name, wallet_hotkey=wallet_hotkey, exc=exc
+            )
+        except typer.Exit:
+            raise
+        except Exception as exc:
+            handle_unexpected_exception("Registration failed unexpectedly", exc)
+
+        if result.status == "already":
+            console.print(f"[bold yellow]Hotkey already registered[/]. UID: {result.uid}")
+            raise typer.Exit(code=0)
+
+        if not result.success:
+            console.print("[bold red]Registration failed.[/]")
+            raise typer.Exit(code=1)
+
+        # Display extrinsic if available
+        if result.extrinsic:
+            console.print(
+                f"[bold green]✔ Your extrinsic has been included as[/] [cyan]{result.extrinsic}[/]"
+            )
+
+        # Display balance update if available (already converted to float in register_hotkey)
+        if result.balance_before is not None and result.balance_after is not None:
+            console.print(
+                f"[bold]Balance:[/] {result.balance_before:.4f} τ -> {result.balance_after:.4f} τ"
+            )
+
+        # Display success message with UID
+        if result.status == "burned":
+            console.print(
+                "[bold green]✔ Registered on netuid[/] "
+                f"[cyan]{netuid}[/] [bold green]with UID[/] [cyan]{result.uid}[/]"
+            )
+        else:
+            console.print(
+                "[bold green]✔ Registered on netuid[/] "
+                f"[cyan]{netuid}[/] [bold green]with UID[/] [cyan]{result.uid}[/]"
+            )
+
+        if result.uid is not None:
+            slot_uid = str(result.uid)
+            console.print()
+            console.print(
+                "[bold green]✓ Registration complete![/] "
+                f"Hotkey: {result.hotkey}, Slot UID: {slot_uid}"
+            )
+            console.print()
+            console.print(
+                "[bold cyan]Next steps:[/]"
+            )
+            console.print(
+                "  • Use [green]cartha vault lock[/] to create a lock position"
+            )
+            console.print(
+                "  • Use [green]cartha miner status[/] to check your miner status"
+            )
+            console.print()
+            console.print(
+                "[dim]Note: The new lock flow uses session tokens instead of passwords. "
+                "Password generation is no longer supported.[/]"
+            )
+        else:
+            console.print(
+                "[bold yellow]UID not yet available[/] (node may still be syncing)."
+            )
+        
+        raise typer.Exit(code=0)
+    finally:
+        # Clean up subtensor connection
+        if subtensor is not None:
+            try:
+                if hasattr(subtensor, "close"):
+                    subtensor.close()
+            except Exception:
+                pass

cartha_cli/commands/shared_options.py

@@ -0,0 +1,235 @@
+"""Shared option definitions for consistent CLI interface.
+
+This module provides reusable typer.Option definitions with comprehensive aliases
+to ensure consistency across all CLI commands.
+"""
+
+import typer
+from ..config import settings
+
+
+def wallet_name_option(required: bool = True):
+    """Coldkey wallet name option with consistent aliases.
+    
+    Aliases: --wallet-name, --wallet.name, --coldkey, -w
+    """
+    if required:
+        return typer.Option(
+            ...,
+            "--wallet-name",
+            "--wallet.name",
+            "--coldkey",
+            "-w",
+            prompt="Coldkey wallet name",
+            help="Coldkey wallet name (aliases: --wallet-name, --wallet.name, --coldkey, -w)",
+            show_default=False,
+        )
+    else:
+        return typer.Option(
+            None,
+            "--wallet-name",
+            "--wallet.name",
+            "--coldkey",
+            "-w",
+            help="Coldkey wallet name (aliases: --wallet-name, --wallet.name, --coldkey, -w)",
+            show_default=False,
+        )
+
+
+def wallet_hotkey_option(required: bool = True):
+    """Hotkey name option with consistent aliases.
+    
+    Aliases: --wallet-hotkey, --wallet.hotkey, --hotkey, -wh
+    """
+    if required:
+        return typer.Option(
+            ...,
+            "--wallet-hotkey",
+            "--wallet.hotkey",
+            "--hotkey",
+            "-wh",
+            prompt="Hotkey name",
+            help="Hotkey name (aliases: --wallet-hotkey, --wallet.hotkey, --hotkey, -wh)",
+            show_default=False,
+        )
+    else:
+        return typer.Option(
+            None,
+            "--wallet-hotkey",
+            "--wallet.hotkey",
+            "--hotkey",
+            "-wh",
+            help="Hotkey name (aliases: --wallet-hotkey, --wallet.hotkey, --hotkey, -wh)",
+            show_default=False,
+        )
+
+
+def pool_id_option():
+    """Pool ID option with aliases.
+    
+    Aliases: --pool-id, --pool, --poolid, -p
+    """
+    return typer.Option(
+        None,
+        "--pool-id",
+        "--pool",
+        "--poolid",
+        "-p",
+        help="Pool name (e.g., BTCUSD, ETHUSD) or hex ID (0x...) (aliases: --pool-id, --pool, --poolid, -p)",
+        show_default=False,
+    )
+
+
+def chain_id_option():
+    """Chain ID option with aliases.
+    
+    Aliases: --chain-id, --chain, --chainid
+    """
+    return typer.Option(
+        None,
+        "--chain-id",
+        "--chain",
+        "--chainid",
+        help="EVM chain ID (auto-detected from pool if not provided) (aliases: --chain-id, --chain, --chainid)",
+        show_default=False,
+    )
+
+
+def vault_address_option():
+    """Vault contract address option with aliases.
+    
+    Aliases: --vault-address, --vault
+    """
+    return typer.Option(
+        None,
+        "--vault-address",
+        "--vault",
+        help="Vault contract address (auto-detected from pool if not provided) (aliases: --vault-address, --vault)",
+        show_default=False,
+    )
+
+
+def owner_evm_option():
+    """Owner EVM address option with aliases.
+    
+    Aliases: --owner-evm, --owner, --evm-address, --evm, -e
+    """
+    return typer.Option(
+        None,
+        "--owner-evm",
+        "--owner",
+        "--evm-address",
+        "--evm",
+        "-e",
+        help="EVM address that will own the lock position (aliases: --owner-evm, --owner, --evm-address, --evm, -e)",
+        show_default=False,
+    )
+
+
+def amount_option():
+    """Amount option.
+    
+    Aliases: --amount, -a
+    """
+    return typer.Option(
+        None,
+        "--amount",
+        "-a",
+        help="Lock amount in USDC (e.g., 250.5). Auto-detects if normalized USDC or base units (>1e9) (alias: -a)",
+        show_default=False,
+    )
+
+
+def lock_days_option():
+    """Lock days option with aliases.
+    
+    Aliases: --lock-days, --days, -d
+    """
+    return typer.Option(
+        None,
+        "--lock-days",
+        "--days",
+        "-d",
+        help="Lock duration in days (e.g., 365) (aliases: --lock-days, --days, -d)",
+        show_default=False,
+    )
+
+
+def network_option():
+    """Network option with netuid auto-mapping.
+    
+    Aliases: --network, -n
+    Maps: test → netuid 78, finney → netuid 35
+    """
+    return typer.Option(
+        settings.network,
+        "--network",
+        "-n",
+        help="Bittensor network (test or finney). Auto-maps to correct netuid (test=78, finney=35)"
+    )
+
+
+def netuid_option():
+    """Netuid option."""
+    return typer.Option(
+        settings.netuid,
+        "--netuid",
+        help="Subnet netuid"
+    )
+
+
+def slot_option():
+    """Slot UID option with aliases.
+    
+    Aliases: --slot, --uid, -u
+    """
+    return typer.Option(
+        None,
+        "--slot",
+        "--uid",
+        "-u",
+        help="Subnet UID assigned to the miner (aliases: --slot, --uid, -u). If not provided, will auto-fetch or prompt.",
+        show_default=False,
+    )
+
+
+def auto_fetch_uid_option():
+    """Auto-fetch UID option."""
+    return typer.Option(
+        True,
+        "--auto-fetch-uid/--no-auto-fetch-uid",
+        help="Automatically fetch UID from Bittensor network (default: enabled).",
+        show_default=False,
+    )
+
+
+def tx_hash_option():
+    """Transaction hash option with aliases.
+    
+    Aliases: --tx-hash, --tx, --transaction
+    """
+    return typer.Option(
+        None,
+        "--tx-hash",
+        "--tx",
+        "--transaction",
+        help="Transaction hash (aliases: --tx-hash, --tx, --transaction)",
+    )
+
+
+def json_output_option():
+    """JSON output option."""
+    return typer.Option(
+        False,
+        "--json",
+        help="Emit responses as JSON."
+    )
+
+
+def refresh_option():
+    """Refresh option for triggering manual processing."""
+    return typer.Option(
+        False,
+        "--refresh",
+        help="If position not found, manually trigger verifier to process a lock transaction.",
+    )

cartha_cli/commands/version.py

@@ -0,0 +1,15 @@
+"""Version command."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .common import console
+
+
+def version_command() -> None:
+    """Print the CLI version."""
+    try:
+        console.print(f"[bold white]cartha-cli[/] {version('cartha-cli')}")
+    except PackageNotFoundError:  # pragma: no cover
+        console.print("[bold white]cartha-cli[/] 0.0.0")
+    console.print("[dim]Cartha is the Liquidity Provider for 0xMarkets DEX[/]")
+

cartha_cli/config.py

@@ -0,0 +1,75 @@
+"""Runtime configuration for the Cartha CLI."""
+
+from __future__ import annotations
+
+import os
+from functools import lru_cache
+from typing import Any
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+# Network to verifier URL mapping
+NETWORK_VERIFIER_MAP = {
+    "test": "https://cartha-verifier-826542474079.us-central1.run.app",
+    "finney": None,  # No mainnet verifier yet - use default or env var
+}
+
+
+def get_verifier_url_for_network(network: str) -> str:
+    """Get the appropriate verifier URL for a given network.
+    
+    Args:
+        network: Network name ("test" or "finney")
+        
+    Returns:
+        Verifier URL for the network
+    """
+    # Check if user set CARTHA_VERIFIER_URL explicitly
+    env_url = os.getenv("CARTHA_VERIFIER_URL")
+    if env_url:
+        return env_url
+    
+    # Auto-map based on network
+    mapped_url = NETWORK_VERIFIER_MAP.get(network)
+    if mapped_url:
+        return mapped_url
+    
+    # Default fallback (testnet for now since no mainnet)
+    return "https://cartha-verifier-826542474079.us-central1.run.app"
+
+
+class Settings(BaseSettings):
+    verifier_url: str = Field(
+        "https://cartha-verifier-826542474079.us-central1.run.app", alias="CARTHA_VERIFIER_URL"
+    )
+    network: str = Field("finney", alias="CARTHA_NETWORK")
+    netuid: int = Field(35, alias="CARTHA_NETUID")
+    evm_private_key: str | None = Field(None, alias="CARTHA_EVM_PK")
+    # Retry configuration
+    retry_max_attempts: int = Field(3, alias="CARTHA_RETRY_MAX_ATTEMPTS")
+    retry_backoff_factor: float = Field(1.5, alias="CARTHA_RETRY_BACKOFF_FACTOR")
+    # Note: retry_on_status cannot be set via env var easily (would need JSON parsing)
+    # For now, it's hardcoded but can be overridden programmatically
+    retry_on_status: list[int] = Field(default_factory=lambda: [500, 502, 503, 504])
+    # Frontend lock UI URL
+    lock_ui_url: str = Field(
+        "https://cartha.finance", alias="CARTHA_LOCK_UI_URL"
+    )
+
+    model_config = {
+        "env_file": ".env",
+        "env_file_encoding": "utf-8",
+        "env_nested_delimiter": "__",
+    }
+
+
+@lru_cache(maxsize=1)
+def get_settings(**overrides: Any) -> Settings:
+    return Settings(**overrides)
+
+
+settings = get_settings()
+
+__all__ = ["settings", "Settings", "get_settings"]

cartha_cli/display.py

@@ -0,0 +1,62 @@
+"""Display and formatting utilities for the Cartha CLI."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from .utils import format_countdown, get_local_timezone, get_next_epoch_freeze_time
+
+console = Console()
+
+
+def get_clock_table() -> Table:
+    """Create a table with current time (UTC and local) and countdown to next epoch freeze.
+
+    Returns:
+        Table with clock and countdown information
+    """
+    now_utc = datetime.now(tz=UTC)
+    local_tz = get_local_timezone()
+    now_local = now_utc.astimezone(local_tz)
+
+    # Format current time
+    utc_str = now_utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+    local_str = now_local.strftime("%Y-%m-%d %H:%M:%S %Z")
+
+    # Calculate next epoch freeze
+    next_freeze_utc = get_next_epoch_freeze_time(now_utc)
+    next_freeze_local = next_freeze_utc.astimezone(local_tz)
+
+    # Calculate countdown
+    time_until_freeze = (next_freeze_utc - now_utc).total_seconds()
+    countdown_str = format_countdown(time_until_freeze)
+
+    # Format next freeze times
+    next_freeze_utc_str = next_freeze_utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+    next_freeze_local_str = next_freeze_local.strftime("%Y-%m-%d %H:%M:%S %Z")
+
+    # Create table
+    clock_table = Table(show_header=False, box=box.SIMPLE)
+    clock_table.add_column(style="cyan")
+    clock_table.add_column(style="yellow")
+
+    clock_table.add_row("Current time (UTC)", utc_str)
+    clock_table.add_row("Current time (Local)", local_str)
+    clock_table.add_row("", "")  # Spacer
+    clock_table.add_row("Next epoch freeze (UTC)", next_freeze_utc_str)
+    clock_table.add_row("Next epoch freeze (Local)", next_freeze_local_str)
+    clock_table.add_row("Countdown", countdown_str)
+
+    return clock_table
+
+
+def display_clock_and_countdown() -> None:
+    """Display the clock table with current time and countdown."""
+    clock_table = get_clock_table()
+    console.print(clock_table)
+    console.print()  # Empty line after table
+

cartha_cli/eth712.py

@@ -0,0 +1,7 @@
+"""EIP-712 helpers (deprecated - LockProof signing moved to verifier).
+
+This file is kept for backward compatibility but is no longer used.
+LockRequest EIP-712 signing is now handled server-side by the verifier.
+"""
+
+__all__: list[str] = []