bittensor-cli 8.4.3__py3-none-any.whl → 9.0.0__py3-none-any.whl

bittensor_cli/src/bittensor/utils.py

@@ -3,10 +3,14 @@ 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
@@ -17,20 +21,17 @@ 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,
-    )
 
 console = Console()
 err_console = Console(stderr=True)
@@ -39,6 +40,23 @@ verbose_console = Console(quiet=True)
 UnlockStatus = namedtuple("UnlockStatus", ["success", "message"])
 
 
+class _Hotkey:
+    def __init__(self, hotkey_ss58=None):
+        self.ss58_address = hotkey_ss58
+
+
+class WalletLike:
+    def __init__(self, name=None, hotkey_ss58=None, hotkey_str=None):
+        self.name = name
+        self.hotkey_ss58 = hotkey_ss58
+        self.hotkey_str = hotkey_str
+        self._hotkey = _Hotkey(hotkey_ss58)
+
+    @property
+    def hotkey(self):
+        return self._hotkey
+
+
 def print_console(message: str, colour: str, title: str, console: Console):
     console.print(
         f"[bold {colour}][{title}]:[/bold {colour}] [{colour}]{message}[/{colour}]\n"
@@ -197,13 +215,14 @@ def convert_root_weight_uids_and_vals_to_tensor(
 
 
 def get_hotkey_wallets_for_wallet(
-    wallet: Wallet, show_nulls: bool = False
+    wallet: Wallet, show_nulls: bool = False, show_encrypted: bool = False
 ) -> list[Optional[Wallet]]:
     """
     Returns wallet objects with hotkeys for a single given wallet
 
     :param wallet: Wallet object to use for the path
     :param show_nulls: will add `None` into the output if a hotkey is encrypted or not on the device
+    :param show_encrypted: will add some basic info about the encrypted hotkey
 
     :return: a list of wallets (with Nones included for cases of a hotkey being encrypted or not on the device, if
              `show_nulls` is set to `True`)
@@ -219,12 +238,18 @@ def get_hotkey_wallets_for_wallet(
         hotkey_for_name = Wallet(path=str(wallet_path), name=wallet.name, hotkey=h_name)
         try:
             if (
-                hotkey_for_name.hotkey_file.exists_on_device()
+                (exists := hotkey_for_name.hotkey_file.exists_on_device())
                 and not hotkey_for_name.hotkey_file.is_encrypted()
                 # and hotkey_for_name.coldkeypub.ss58_address
                 and hotkey_for_name.hotkey.ss58_address
             ):
                 hotkey_wallets.append(hotkey_for_name)
+            elif (
+                show_encrypted and exists and hotkey_for_name.hotkey_file.is_encrypted()
+            ):
+                hotkey_wallets.append(
+                    WalletLike(str(wallet_path), "<ENCRYPTED>", h_name)
+                )
             elif show_nulls:
                 hotkey_wallets.append(None)
         except (
@@ -376,21 +401,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 +420,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
 
@@ -507,7 +526,10 @@ def format_error_message(error_message: Union[dict, Exception]) -> str:
 
             # subtensor custom error marker
             if err_data.startswith("Custom error:"):
-                err_description = f"{err_data} | Please consult https://docs.bittensor.com/subtensor-nodes/subtensor-error-messages"
+                err_description = (
+                    f"{err_data} | Please consult "
+                    f"https://docs.bittensor.com/subtensor-nodes/subtensor-error-messages"
+                )
             else:
                 err_description = err_data
 
@@ -542,7 +564,8 @@ def decode_hex_identity_dict(info_dictionary) -> dict[str, Any]:
     """
     Decodes hex-encoded strings in a dictionary.
 
-    This function traverses the given dictionary, identifies hex-encoded strings, and decodes them into readable strings. It handles nested dictionaries and lists within the dictionary.
+    This function traverses the given dictionary, identifies hex-encoded strings, and decodes them into readable
+        strings. It handles nested dictionaries and lists within the dictionary.
 
     Args:
         info_dictionary (dict): The dictionary containing hex-encoded strings to decode.
@@ -630,6 +653,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 +991,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,6 +1014,302 @@ def retry_prompt(
             err_console.print(rejection_text)
 
 
+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()}"
+
+
+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 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:
+        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:
+        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"
+
+
+def validate_rate_tolerance(value: Optional[float]) -> Optional[float]:
+    """Validates rate tolerance input"""
+    if value is not None:
+        if value < 0:
+            raise typer.BadParameter(
+                "Rate tolerance cannot be negative (less than 0%)."
+            )
+        if value > 1:
+            raise typer.BadParameter("Rate tolerance cannot be greater than 1 (100%).")
+        if value > 0.5:
+            console.print(
+                f"[yellow]Warning: High rate tolerance of {value*100}% specified. "
+                "This may result in unfavorable transaction execution.[/yellow]"
+            )
+    return value
+
+
 def unlock_key(
     wallet: Wallet, unlock_type="cold", print_out: bool = True
 ) -> "UnlockStatus":
@@ -1010,3 +1355,32 @@ def hex_to_bytes(hex_str: str) -> bytes:
     else:
         bytes_result = bytes.fromhex(hex_str)
     return bytes_result
+
+
+def blocks_to_duration(blocks: int) -> str:
+    """Convert blocks to human readable duration string using two largest units.
+
+    Args:
+        blocks (int): Number of blocks (12s per block)
+
+    Returns:
+        str: Duration string like '2d 5h', '3h 45m', '2m 10s', or '0s'
+    """
+    if blocks <= 0:
+        return "0s"
+
+    seconds = blocks * 12
+    intervals = [
+        ("d", 86400),  # 60 * 60 * 24
+        ("h", 3600),  # 60 * 60
+        ("m", 60),
+        ("s", 1),
+    ]
+    results = []
+    for unit, seconds_per_unit in intervals:
+        unit_count = seconds // seconds_per_unit
+        seconds %= seconds_per_unit
+        if unit_count > 0:
+            results.append(f"{unit_count}{unit}")
+    # Return only the first two non-zero units
+    return " ".join(results[:2]) or "0s"

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_]