bittensor-cli 8.4.2__py3-none-any.whl → 9.0.0rc1__py3-none-any.whl

bittensor_cli/src/bittensor/utils.py

@@ -1,43 +1,42 @@
 import ast
-from collections import namedtuple
 import math
 import os
 import sqlite3
+import platform
 import webbrowser
+import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Collection, Optional, Union, Callable
 from urllib.parse import urlparse
+from functools import partial
+import re
 
 from bittensor_wallet import Wallet, Keypair
 from bittensor_wallet.utils import SS58_FORMAT
-from bittensor_wallet.errors import KeyFileError, PasswordError
+from bittensor_wallet.errors import KeyFileError
 from bittensor_wallet import utils
 from jinja2 import Template
 from markupsafe import Markup
 import numpy as np
 from numpy.typing import NDArray
 from rich.console import Console
-import scalecodec
-from scalecodec.base import RuntimeConfiguration
-from scalecodec.type_registry import load_type_registry_preset
+from rich.prompt import Prompt
+from scalecodec.utils.ss58 import ss58_encode, ss58_decode
 import typer
 
 
 from bittensor_cli.src.bittensor.balances import Balance
+from bittensor_cli.src import defaults, Constants
 
 
 if TYPE_CHECKING:
     from bittensor_cli.src.bittensor.chain_data import SubnetHyperparameters
-    from bittensor_cli.src.bittensor.async_substrate_interface import (
-        AsyncSubstrateInterface,
-    )
+    from async_substrate_interface.async_substrate import AsyncSubstrateInterface
 
 console = Console()
 err_console = Console(stderr=True)
 verbose_console = Console(quiet=True)
 
-UnlockStatus = namedtuple("UnlockStatus", ["success", "message"])
-
 
 def print_console(message: str, colour: str, title: str, console: Console):
     console.print(
@@ -241,14 +240,11 @@ def get_hotkey_wallets_for_wallet(
 def get_coldkey_wallets_for_path(path: str) -> list[Wallet]:
     """Gets all wallets with coldkeys from a given path"""
     wallet_path = Path(path).expanduser()
-    try:
-        wallets = [
-            Wallet(name=directory.name, path=path)
-            for directory in wallet_path.iterdir()
-            if directory.is_dir()
-        ]
-    except FileNotFoundError:
-        wallets = []
+    wallets = [
+        Wallet(name=directory.name, path=path)
+        for directory in wallet_path.iterdir()
+        if directory.is_dir()
+    ]
     return wallets
 
 
@@ -376,21 +372,15 @@ def is_valid_bittensor_address_or_public_key(address: Union[str, bytes]) -> bool
         return False
 
 
-def decode_scale_bytes(return_type, scale_bytes, custom_rpc_type_registry):
-    """Decodes a ScaleBytes object using our type registry and return type"""
-    rpc_runtime_config = RuntimeConfiguration()
-    rpc_runtime_config.update_type_registry(load_type_registry_preset("legacy"))
-    rpc_runtime_config.update_type_registry(custom_rpc_type_registry)
-    obj = rpc_runtime_config.create_scale_object(return_type, scale_bytes)
-    if obj.data.to_hex() == "0x0400":  # RPC returned None result
-        return None
-    return obj.decode()
+def decode_account_id(account_id_bytes: Union[tuple[int], tuple[tuple[int]]]):
+    if isinstance(account_id_bytes, tuple) and isinstance(account_id_bytes[0], tuple):
+        account_id_bytes = account_id_bytes[0]
+    # Convert the AccountId bytes to a Base64 string
+    return ss58_encode(bytes(account_id_bytes).hex(), SS58_FORMAT)
 
 
-def ss58_address_to_bytes(ss58_address: str) -> bytes:
-    """Converts a ss58 address to a bytes object."""
-    account_id_hex: str = scalecodec.ss58_decode(ss58_address, SS58_FORMAT)
-    return bytes.fromhex(account_id_hex)
+def encode_account_id(ss58_address: str) -> bytes:
+    return bytes.fromhex(ss58_decode(ss58_address, SS58_FORMAT))
 
 
 def ss58_to_vec_u8(ss58_address: str) -> list[int]:
@@ -401,7 +391,7 @@ def ss58_to_vec_u8(ss58_address: str) -> list[int]:
 
     :return: A list of integers representing the byte values of the SS58 address.
     """
-    ss58_bytes: bytes = ss58_address_to_bytes(ss58_address)
+    ss58_bytes: bytes = encode_account_id(ss58_address)
     encoded_address: list[int] = [int(byte) for byte in ss58_bytes]
     return encoded_address
 
@@ -458,13 +448,16 @@ def get_explorer_url_for_network(
     return explorer_urls
 
 
-def format_error_message(error_message: Union[dict, Exception]) -> str:
+def format_error_message(
+    error_message: Union[dict, Exception], substrate: "AsyncSubstrateInterface"
+) -> str:
     """
     Formats an error message from the Subtensor error information for use in extrinsics.
 
     Args:
         error_message: A dictionary containing the error information from Subtensor, or a SubstrateRequestException
                        containing dictionary literal args.
+        substrate: The initialised SubstrateInterface object to use.
 
     Returns:
         str: A formatted error message string.
@@ -486,7 +479,7 @@ def format_error_message(error_message: Union[dict, Exception]) -> str:
                     elif all(x in d for x in ["code", "message", "data"]):
                         new_error_message = d
                         break
-            except ValueError:
+            except (ValueError, TypeError, SyntaxError, MemoryError, RecursionError):
                 pass
         if new_error_message is None:
             return_val = " ".join(error_message.args)
@@ -564,7 +557,7 @@ def decode_hex_identity_dict(info_dictionary) -> dict[str, Any]:
     def get_decoded(data: str) -> str:
         """Decodes a hex-encoded string."""
         try:
-            return hex_to_bytes(data).decode()
+            return bytes.fromhex(data[2:]).decode()
         except UnicodeDecodeError:
             print(f"Could not decode: {key}: {item}")
 
@@ -630,6 +623,32 @@ def millify(n: int):
     return "{:.2f}{}".format(n_ / 10 ** (3 * mill_idx), mill_names[mill_idx])
 
 
+def millify_tao(n: float, start_at: str = "K") -> str:
+    """
+    Dupe of millify, but for ease in converting tao values.
+    Allows thresholds to be specified for different suffixes.
+    """
+    mill_names = ["", "k", "m", "b", "t"]
+    thresholds = {"K": 1, "M": 2, "B": 3, "T": 4}
+
+    if start_at not in thresholds:
+        raise ValueError(f"start_at must be one of {list(thresholds.keys())}")
+
+    n_ = float(n)
+    if n_ == 0:
+        return "0.00"
+
+    mill_idx = int(math.floor(math.log10(abs(n_)) / 3))
+
+    # Number's index is below our threshold, return with commas
+    if mill_idx < thresholds[start_at]:
+        return f"{n_:,.2f}"
+
+    mill_idx = max(thresholds[start_at], min(len(mill_names) - 1, mill_idx))
+
+    return "{:.2f}{}".format(n_ / 10 ** (3 * mill_idx), mill_names[mill_idx])
+
+
 def normalize_hyperparameters(
     subnet: "SubnetHyperparameters",
 ) -> list[tuple[str, str, str]]:
@@ -942,7 +961,7 @@ def retry_prompt(
     rejection_text: str,
     default="",
     show_default=False,
-    prompt_type=typer.prompt,
+    prompt_type=Prompt.ask,
 ):
     """
     Allows for asking prompts again if they do not meet a certain criteria (as defined in `rejection`)
@@ -965,48 +984,280 @@ def retry_prompt(
             err_console.print(rejection_text)
 
 
-def unlock_key(
-    wallet: Wallet, unlock_type="cold", print_out: bool = True
-) -> "UnlockStatus":
-    """
-    Attempts to decrypt a wallet's coldkey or hotkey
-    Args:
-        wallet: a Wallet object
-        unlock_type: the key type, 'cold' or 'hot'
-        print_out:  whether to print out the error message to the err_console
+def validate_netuid(value: int) -> int:
+    if value is not None and value < 0:
+        raise typer.BadParameter("Negative netuid passed. Please use correct netuid.")
+    return value
+
+
+def validate_uri(uri: str) -> str:
+    if not uri:
+        return None
+    clean_uri = uri.lstrip("/").lower()
+    if not clean_uri.isalnum():
+        raise typer.BadParameter(
+            f"Invalid URI format: {uri}. URI must contain only alphanumeric characters (e.g. 'alice', 'bob')"
+        )
+    return f"//{clean_uri.capitalize()}"
 
-    Returns: UnlockStatus for success status of unlock, with error message if unsuccessful
 
+def get_effective_network(config, network: Optional[list[str]]) -> str:
+    """
+    Determines the effective network to be used, considering the network parameter,
+    the configuration, and the default.
     """
-    if unlock_type == "cold":
-        unlocker = "unlock_coldkey"
-    elif unlock_type == "hot":
-        unlocker = "unlock_hotkey"
+    if network:
+        for item in network:
+            if item.startswith("ws"):
+                network_ = item
+                break
+            else:
+                network_ = item
+        return network_
+    elif config.get("network"):
+        return config["network"]
     else:
-        raise ValueError(
-            f"Invalid unlock type provided: {unlock_type}. Must be 'cold' or 'hot'."
+        return defaults.subtensor.network
+
+
+def is_rao_network(network: str) -> bool:
+    """Check if the given network is 'rao'."""
+    network = network.lower()
+    rao_identifiers = [
+        "rao",
+        Constants.rao_entrypoint,
+    ]
+    return (
+        network == "rao"
+        or network in rao_identifiers
+        or "rao.chain.opentensor.ai" in network
+    )
+
+
+def prompt_for_identity(
+    current_identity: dict,
+    name: Optional[str],
+    web_url: Optional[str],
+    image_url: Optional[str],
+    discord: Optional[str],
+    description: Optional[str],
+    additional: Optional[str],
+    github_repo: Optional[str],
+):
+    """
+    Prompts the user for identity fields with validation.
+    Returns a dictionary with the updated fields.
+    """
+    identity_fields = {}
+
+    fields = [
+        ("name", "[blue]Display name[/blue]", name),
+        ("url", "[blue]Web URL[/blue]", web_url),
+        ("image", "[blue]Image URL[/blue]", image_url),
+        ("discord", "[blue]Discord handle[/blue]", discord),
+        ("description", "[blue]Description[/blue]", description),
+        ("additional", "[blue]Additional information[/blue]", additional),
+        ("github_repo", "[blue]GitHub repository URL[/blue]", github_repo),
+    ]
+
+    text_rejection = partial(
+        retry_prompt,
+        rejection=lambda x: sys.getsizeof(x) > 113,
+        rejection_text="[red]Error:[/red] Identity field must be <= 64 raw bytes.",
+    )
+
+    if not any(
+        [
+            name,
+            web_url,
+            image_url,
+            discord,
+            description,
+            additional,
+            github_repo,
+        ]
+    ):
+        console.print(
+            "\n[yellow]All fields are optional. Press Enter to skip and keep the default/existing value.[/yellow]\n"
+            "[dark_sea_green3]Tip: Entering a space and pressing Enter will clear existing default value.\n"
         )
+
+    for key, prompt, value in fields:
+        if value:
+            identity_fields[key] = value
+        else:
+            identity_fields[key] = text_rejection(
+                prompt,
+                default=current_identity.get(key, ""),
+                show_default=True,
+            )
+
+    return identity_fields
+
+
+def prompt_for_subnet_identity(
+    subnet_name: Optional[str],
+    github_repo: Optional[str],
+    subnet_contact: Optional[str],
+    subnet_url: Optional[str],
+    discord: Optional[str],
+    description: Optional[str],
+    additional: Optional[str],
+):
+    """
+    Prompts the user for required subnet identity fields with validation.
+    Returns a dictionary with the updated fields.
+
+    Args:
+        subnet_name (Optional[str]): Name of the subnet
+        github_repo (Optional[str]): GitHub repository URL
+        subnet_contact (Optional[str]): Contact information for subnet (email)
+
+    Returns:
+        dict: Dictionary containing the subnet identity fields
+    """
+    identity_fields = {}
+
+    fields = [
+        (
+            "subnet_name",
+            "[blue]Subnet name [dim](optional)[/blue]",
+            subnet_name,
+            lambda x: x and sys.getsizeof(x) > 113,
+            "[red]Error:[/red] Subnet name must be <= 64 raw bytes.",
+        ),
+        (
+            "github_repo",
+            "[blue]GitHub repository URL [dim](optional)[/blue]",
+            github_repo,
+            lambda x: x and not is_valid_github_url(x),
+            "[red]Error:[/red] Please enter a valid GitHub repository URL (e.g., https://github.com/username/repo).",
+        ),
+        (
+            "subnet_contact",
+            "[blue]Contact email [dim](optional)[/blue]",
+            subnet_contact,
+            lambda x: x and not is_valid_contact(x),
+            "[red]Error:[/red] Please enter a valid email address.",
+        ),
+        (
+            "subnet_url",
+            "[blue]Subnet URL [dim](optional)[/blue]",
+            subnet_url,
+            lambda x: x and sys.getsizeof(x) > 113,
+            "[red]Error:[/red] Please enter a valid URL.",
+        ),
+        (
+            "discord",
+            "[blue]Discord handle [dim](optional)[/blue]",
+            discord,
+            lambda x: x and sys.getsizeof(x) > 113,
+            "[red]Error:[/red] Please enter a valid Discord handle.",
+        ),
+        (
+            "description",
+            "[blue]Description [dim](optional)[/blue]",
+            description,
+            lambda x: x and sys.getsizeof(x) > 113,
+            "[red]Error:[/red] Description must be <= 64 raw bytes.",
+        ),
+        (
+            "additional",
+            "[blue]Additional information [dim](optional)[/blue]",
+            additional,
+            lambda x: x and sys.getsizeof(x) > 113,
+            "[red]Error:[/red] Additional information must be <= 64 raw bytes.",
+        ),
+    ]
+
+    for key, prompt, value, rejection_func, rejection_msg in fields:
+        if value:
+            if rejection_func(value):
+                raise ValueError(rejection_msg)
+            identity_fields[key] = value
+        else:
+            identity_fields[key] = retry_prompt(
+                prompt,
+                rejection=rejection_func,
+                rejection_text=rejection_msg,
+                default=None,  # Maybe we can add some defaults later
+                show_default=True,
+            )
+
+    return identity_fields
+
+
+def is_valid_github_url(url: str) -> bool:
+    """
+    Validates if the provided URL is a valid GitHub repository URL.
+
+    Args:
+        url (str): URL to validate
+
+    Returns:
+        bool: True if valid GitHub repo URL, False otherwise
+    """
     try:
-        getattr(wallet, unlocker)()
-        return UnlockStatus(True, "")
-    except PasswordError:
-        err_msg = f"The password used to decrypt your {unlock_type.capitalize()}key Keyfile is invalid."
-        if print_out:
-            err_console.print(f":cross_mark: [red]{err_msg}[/red]")
-        return UnlockStatus(False, err_msg)
-    except KeyFileError:
-        err_msg = f"{unlock_type.capitalize()}key Keyfile is corrupt, non-writable, or non-readable, or non-existent."
-        if print_out:
-            err_console.print(f":cross_mark: [red]{err_msg}[/red]")
-        return UnlockStatus(False, err_msg)
-
-
-def hex_to_bytes(hex_str: str) -> bytes:
-    """
-    Converts a hex-encoded string into bytes. Handles 0x-prefixed and non-prefixed hex-encoded strings.
-    """
-    if hex_str.startswith("0x"):
-        bytes_result = bytes.fromhex(hex_str[2:])
-    else:
-        bytes_result = bytes.fromhex(hex_str)
-    return bytes_result
+        parsed = urlparse(url)
+        if parsed.netloc != "github.com":
+            return False
+
+        # Check path follows github.com/user/repo format
+        path_parts = [p for p in parsed.path.split("/") if p]
+        if len(path_parts) < 2:  # Need at least username/repo
+            return False
+
+        return True
+    except Exception:  # TODO figure out the exceptions that can be raised in here
+        return False
+
+
+def is_valid_contact(contact: str) -> bool:
+    """
+    Validates if the provided contact is a valid email address.
+
+    Args:
+        contact (str): Contact information to validate
+
+    Returns:
+        bool: True if valid email, False otherwise
+    """
+    email_pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
+    return bool(re.match(email_pattern, contact))
+
+
+def get_subnet_name(subnet_info) -> str:
+    """Get the subnet name, prioritizing subnet_identity.subnet_name over subnet.subnet_name.
+
+    Args:
+        subnet: The subnet dynamic info
+
+    Returns:
+        str: The subnet name or empty string if no name is found
+    """
+    return (
+        subnet_info.subnet_identity.subnet_name
+        if hasattr(subnet_info, "subnet_identity")
+        and subnet_info.subnet_identity is not None
+        and subnet_info.subnet_identity.subnet_name is not None
+        else (subnet_info.subnet_name if subnet_info.subnet_name is not None else "")
+    )
+
+
+def print_linux_dependency_message():
+    """Prints the WebKit dependency message for Linux systems."""
+    console.print("[red]This command requires WebKit dependencies on Linux.[/red]")
+    console.print(
+        "\nPlease install the required packages using one of the following commands based on your distribution:"
+    )
+    console.print("\nArch Linux / Manjaro:")
+    console.print("[green]sudo pacman -S webkit2gtk[/green]")
+    console.print("\nDebian / Ubuntu:")
+    console.print("[green]sudo apt install libwebkit2gtk-4.0-dev[/green]")
+    console.print("\nFedora / CentOS / AlmaLinux:")
+    console.print("[green]sudo dnf install gtk3-devel webkit2gtk3-devel[/green]")
+
+
+def is_linux():
+    """Returns True if the operating system is Linux."""
+    return platform.system().lower() == "linux"

bittensor_cli/src/commands/stake/__init__.py

@@ -0,0 +1,154 @@
+from typing import Optional, TYPE_CHECKING
+
+import rich.prompt
+from rich.table import Table
+
+from bittensor_cli.src.bittensor.chain_data import DelegateInfoLite
+from bittensor_cli.src.bittensor.utils import console
+
+if TYPE_CHECKING:
+    from bittensor_cli.src.bittensor.subtensor_interface import SubtensorInterface
+
+
+async def select_delegate(subtensor: "SubtensorInterface", netuid: int):
+    # Get a list of delegates and sort them by total stake in descending order
+    delegates: list[DelegateInfoLite] = (
+        await subtensor.get_delegates_by_netuid_light(netuid)
+    ).sort(key=lambda x: x.total_stake, reverse=True)
+
+    # Get registered delegates details.
+    registered_delegate_info = await subtensor.get_delegate_identities()
+
+    # Create a table to display delegate information
+    table = Table(
+        show_header=True,
+        header_style="bold",
+        border_style="rgb(7,54,66)",
+        style="rgb(0,43,54)",
+    )
+
+    # Add columns to the table with specific styles
+    table.add_column("Index", style="rgb(253,246,227)", no_wrap=True)
+    table.add_column("Delegate Name", no_wrap=True)
+    table.add_column("Hotkey SS58", style="rgb(211,54,130)", no_wrap=True)
+    table.add_column("Owner SS58", style="rgb(133,153,0)", no_wrap=True)
+    table.add_column("Take", style="rgb(181,137,0)", no_wrap=True)
+    table.add_column(
+        "Total Stake", style="rgb(38,139,210)", no_wrap=True, justify="right"
+    )
+    table.add_column(
+        "Owner Stake", style="rgb(220,50,47)", no_wrap=True, justify="right"
+    )
+    # table.add_column("Return per 1000", style="rgb(108,113,196)", no_wrap=True, justify="right")
+    # table.add_column("Total Daily Return", style="rgb(42,161,152)", no_wrap=True, justify="right")
+
+    # List to store visible delegates
+    visible_delegates = []
+
+    def get_user_input() -> str:
+        return rich.prompt.Prompt.ask(
+            'Press Enter to scroll, enter a number (1-N) to select, or type "h" for help: ',
+            choices=["", "h"] + [str(x) for x in range(1, len(delegates) - 1)],
+            show_choices=True,
+        )
+
+    # TODO: Add pagination to handle large number of delegates more efficiently
+    # Iterate through delegates and display their information
+
+    def loop_selections() -> Optional[int]:
+        idx = 0
+        selected_idx = None
+        while idx < len(delegates):
+            if idx < len(delegates):
+                delegate = delegates[idx]
+
+                # Add delegate to visible list
+                visible_delegates.append(delegate)
+
+                # Add a row to the table with delegate information
+                table.add_row(
+                    str(idx),
+                    registered_delegate_info[delegate.hotkey_ss58].name
+                    if delegate.hotkey_ss58 in registered_delegate_info
+                    else "",
+                    delegate.hotkey_ss58[:5]
+                    + "..."
+                    + delegate.hotkey_ss58[-5:],  # Show truncated hotkey
+                    delegate.owner_ss58[:5]
+                    + "..."
+                    + delegate.owner_ss58[-5:],  # Show truncated owner address
+                    f"{delegate.take:.6f}",
+                    f"τ{delegate.total_stake.tao:,.4f}",
+                    f"τ{delegate.owner_stake.tao:,.4f}",
+                    # f"τ{delegate.return_per_1000.tao:,.4f}",
+                    # f"τ{delegate.total_daily_return.tao:,.4f}",
+                )
+
+            # Clear console and print updated table
+            console.clear()
+            console.print(table)
+
+            # Prompt user for input
+            user_input: str = get_user_input()
+
+            # Add a help option to display information about each column
+            if user_input == "h":
+                console.print("\nColumn Information:")
+                console.print(
+                    "[rgb(253,246,227)]Index:[/rgb(253,246,227)] Position in the list of delegates"
+                )
+                console.print(
+                    "[rgb(211,54,130)]Hotkey SS58:[/rgb(211,54,130)] Truncated public key of the delegate's hotkey"
+                )
+                console.print(
+                    "[rgb(133,153,0)]Owner SS58:[/rgb(133,153,0)] Truncated public key of the delegate's owner"
+                )
+                console.print(
+                    "[rgb(181,137,0)]Take:[/rgb(181,137,0)] Percentage of rewards the delegate takes"
+                )
+                console.print(
+                    "[rgb(38,139,210)]Total Stake:[/rgb(38,139,210)] Total amount staked to this delegate"
+                )
+                console.print(
+                    "[rgb(220,50,47)]Owner Stake:[/rgb(220,50,47)] Amount staked by the delegate owner"
+                )
+                console.print(
+                    "[rgb(108,113,196)]Return per 1000:[/rgb(108,113,196)] Estimated return for 1000 Tao staked"
+                )
+                console.print(
+                    "[rgb(42,161,152)]Total Daily Return:[/rgb(42,161,152)] Estimated total daily return for all stake"
+                )
+                user_input = get_user_input()
+
+            # If user presses Enter, continue to next delegate
+            if user_input and user_input != "h":
+                selected_idx = int(user_input)
+                break
+
+            if idx < len(delegates):
+                idx += 1
+
+        return selected_idx
+
+    # TODO( const ): uncomment for check
+    # Add a confirmation step before returning the selected delegate
+    # console.print(f"\nSelected delegate: [rgb(211,54,130)]{visible_delegates[selected_idx].hotkey_ss58}[/rgb(211,54,130)]")
+    # console.print(f"Take: [rgb(181,137,0)]{visible_delegates[selected_idx].take:.6f}[/rgb(181,137,0)]")
+    # console.print(f"Total Stake: [rgb(38,139,210)]{visible_delegates[selected_idx].total_stake}[/rgb(38,139,210)]")
+
+    # confirmation = Prompt.ask("Do you want to proceed with this delegate? (y/n)")
+    # if confirmation.lower() != 'yes' and confirmation.lower() != 'y':
+    #     return select_delegate( subtensor, netuid )
+
+    # Return the selected delegate
+    while True:
+        selected_idx_ = loop_selections()
+        if selected_idx_ is None:
+            if not rich.prompt.Confirm.ask(
+                "You've reached the end of the list. You must make a selection. Loop through again?"
+            ):
+                raise IndexError
+            else:
+                continue
+        else:
+            return delegates[selected_idx_]