bittensor-cli 9.0.0rc4__py3-none-any.whl → 9.0.1__py3-none-any.whl

bittensor_cli/src/commands/subnets/subnets.py

@@ -35,12 +35,13 @@ from bittensor_cli.src.bittensor.utils import (
     update_metadata_table,
     prompt_for_identity,
     get_subnet_name,
+    unlock_key,
 )
 
 if TYPE_CHECKING:
     from bittensor_cli.src.bittensor.subtensor_interface import SubtensorInterface
 
-TAO_WEIGHT = 0.018
+TAO_WEIGHT = 0.18
 
 # helpers and extrinsics
 
@@ -183,7 +184,7 @@ async def register_subnetwork_extrinsic(
         await response.process_events()
         if not await response.is_success:
             err_console.print(
-                f":cross_mark: [red]Failed[/red]: {format_error_message(await response.error_message, substrate)}"
+                f":cross_mark: [red]Failed[/red]: {format_error_message(await response.error_message)}"
             )
             await asyncio.sleep(0.5)
             return False
@@ -889,7 +890,7 @@ async def show(
             for netuid_ in range(len(all_subnets)):
                 subnet = all_subnets[netuid_]
                 emission_on_subnet = (
-                    root_state.emission_history[netuid_][idx] / subnet.tempo
+                    root_state.emission_history[netuid_][idx] / (subnet.tempo or 1)
                 )
                 total_emission_per_block += subnet.alpha_to_tao(
                     Balance.from_rao(emission_on_subnet)
@@ -1322,7 +1323,7 @@ async def show(
                         return hotkey
                     else:
                         console.print(
-                            f"[red]Invalid UID. Please enter a valid UID from the table above[/red]"
+                            "[red]Invalid UID. Please enter a valid UID from the table above[/red]"
                         )
                 except ValueError:
                     console.print("[red]Please enter a valid number[/red]")
@@ -2026,3 +2027,146 @@ async def metagraph_cmd(
                 table.add_row(*row)
 
         console.print(table)
+
+
+def create_identity_table(title: str = None):
+    if not title:
+        title = "Subnet Identity"
+
+    table = Table(
+        Column(
+            "Item",
+            justify="right",
+            style=COLOR_PALETTE["GENERAL"]["SUBHEADING_MAIN"],
+            no_wrap=True,
+        ),
+        Column("Value", style=COLOR_PALETTE["GENERAL"]["SUBHEADING"]),
+        title=f"\n[{COLOR_PALETTE['GENERAL']['HEADER']}]{title}\n",
+        show_footer=True,
+        show_edge=False,
+        header_style="bold white",
+        border_style="bright_black",
+        style="bold",
+        title_justify="center",
+        show_lines=False,
+        pad_edge=True,
+    )
+    return table
+
+
+async def set_identity(
+    wallet: "Wallet",
+    subtensor: "SubtensorInterface",
+    netuid: int,
+    subnet_identity: dict,
+    prompt: bool = False,
+) -> bool:
+    """Set identity information for a subnet"""
+
+    if not await subtensor.subnet_exists(netuid):
+        err_console.print(f"Subnet {netuid} does not exist")
+        return False
+
+    identity_data = {
+        "netuid": netuid,
+        "subnet_name": subnet_identity.get("subnet_name", ""),
+        "github_repo": subnet_identity.get("github_repo", ""),
+        "subnet_contact": subnet_identity.get("subnet_contact", ""),
+        "subnet_url": subnet_identity.get("subnet_url", ""),
+        "discord": subnet_identity.get("discord", ""),
+        "description": subnet_identity.get("description", ""),
+        "additional": subnet_identity.get("additional", ""),
+    }
+
+    if not unlock_key(wallet).success:
+        return False
+
+    if prompt:
+        if not Confirm.ask(
+            "Are you sure you want to set subnet's identity? This is subject to a fee."
+        ):
+            return False
+
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="set_subnet_identity",
+        call_params=identity_data,
+    )
+
+    with console.status(
+        " :satellite: [dark_sea_green3]Setting subnet identity on-chain...",
+        spinner="earth",
+    ):
+        success, err_msg = await subtensor.sign_and_send_extrinsic(call, wallet)
+
+        if not success:
+            err_console.print(f"[red]:cross_mark: Failed![/red] {err_msg}")
+            return False
+
+        console.print(
+            ":white_heavy_check_mark: [dark_sea_green3]Successfully set subnet identity\n"
+        )
+
+        subnet = await subtensor.subnet(netuid)
+        identity = subnet.subnet_identity if subnet else None
+
+    if identity:
+        table = create_identity_table(title=f"New Subnet {netuid} Identity")
+        table.add_row("Netuid", str(netuid))
+        for key in [
+            "subnet_name",
+            "github_repo",
+            "subnet_contact",
+            "subnet_url",
+            "discord",
+            "description",
+            "additional",
+        ]:
+            value = getattr(identity, key, None)
+            table.add_row(key, str(value) if value else "~")
+        console.print(table)
+
+    return True
+
+
+async def get_identity(subtensor: "SubtensorInterface", netuid: int, title: str = None):
+    """Fetch and display existing subnet identity information."""
+    if not title:
+        title = "Subnet Identity"
+
+    if not await subtensor.subnet_exists(netuid):
+        print_error(
+            f"Subnet {netuid} does not exist."
+        )
+        raise typer.Exit()
+
+    with console.status(
+        ":satellite: [bold green]Querying subnet identity...", spinner="earth"
+    ):
+        subnet = await subtensor.subnet(netuid)
+        identity = subnet.subnet_identity if subnet else None
+
+    if not identity:
+        err_console.print(
+            f"Existing subnet identity not found"
+            f" for subnet [blue]{netuid}[/blue]"
+            f" on {subtensor}"
+        )
+        return {}
+
+    if identity:
+        table = create_identity_table(title=f"Current Subnet {netuid} Identity")
+        table.add_row("Netuid", str(netuid))
+        for key in [
+            "subnet_name",
+            "github_repo",
+            "subnet_contact",
+            "subnet_url",
+            "discord",
+            "description",
+            "additional",
+        ]:
+            value = getattr(identity, key, None)
+            table.add_row(key, str(value) if value else "~")
+        console.print(table)
+        return identity

bittensor_cli/src/commands/sudo.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING, Union, Optional
 
 import typer
 from bittensor_wallet import Wallet
-from bittensor_wallet.errors import KeyFileError
 from rich import box
 from rich.table import Column, Table
 from rich.prompt import Confirm
@@ -17,6 +16,8 @@ from bittensor_cli.src.bittensor.utils import (
     print_error,
     print_verbose,
     normalize_hyperparameters,
+    unlock_key,
+    blocks_to_duration,
 )
 
 if TYPE_CHECKING:
@@ -106,13 +107,10 @@ async def set_hyperparameter_extrinsic(
         )
         return False
 
-    try:
-        wallet.unlock_coldkey()
-    except KeyFileError:
-        err_console.print("Error decrypting coldkey (possibly incorrect password)")
+    if not unlock_key(wallet).success:
         return False
 
-    extrinsic = HYPERPARAMS.get(parameter)
+    extrinsic, sudo_ = HYPERPARAMS.get(parameter, ("", False))
     if extrinsic is None:
         err_console.print(":cross_mark: [red]Invalid hyperparameter specified.[/red]")
         return False
@@ -152,11 +150,17 @@ async def set_hyperparameter_extrinsic(
             call_params[str(value_argument["name"])] = value
 
         # create extrinsic call
-        call = await substrate.compose_call(
+        call_ = await substrate.compose_call(
             call_module="AdminUtils",
             call_function=extrinsic,
             call_params=call_params,
         )
+        if sudo_:
+            call = await substrate.compose_call(
+                call_module="Sudo", call_function="sudo", call_params={"call": call_}
+            )
+        else:
+            call = call_
         success, err_msg = await subtensor.sign_and_send_extrinsic(
             call, wallet, wait_for_inclusion, wait_for_finalization
         )
@@ -266,14 +270,22 @@ def format_call_data(call_data: dict) -> str:
     call_info = call_details[0]
     call_function, call_args = next(iter(call_info.items()))
 
-    # Extract the argument, handling tuple values
-    formatted_args = ", ".join(
-        str(arg[0]) if isinstance(arg, tuple) else str(arg)
-        for arg in call_args.values()
-    )
+    # Format arguments, handle nested/large payloads
+    formatted_args = []
+    for arg_name, arg_value in call_args.items():
+        if isinstance(arg_value, (tuple, list, dict)):
+            # For large nested, show abbreviated version
+            content_str = str(arg_value)
+            if len(content_str) > 20:
+                formatted_args.append(f"{arg_name}: ... [{len(content_str)}] ...")
+            else:
+                formatted_args.append(f"{arg_name}: {arg_value}")
+        else:
+            formatted_args.append(f"{arg_name}: {arg_value}")
 
     # Format the final output string
-    return f"{call_function}({formatted_args})"
+    args_str = ", ".join(formatted_args)
+    return f"{module}.{call_function}({args_str})"
 
 
 def _validate_proposal_hash(proposal_hash: str) -> bool:
@@ -464,19 +476,20 @@ async def sudo_set_hyperparameter(
 
     normalized_value: Union[str, bool]
     if param_name in [
-        "network_registration_allowed",
+        "registration_allowed",
         "network_pow_registration_allowed",
         "commit_reveal_weights_enabled",
         "liquid_alpha_enabled",
     ]:
-        normalized_value = param_value.lower() in ["true", "1"]
+        normalized_value = param_value.lower() in ["true", "True", "1"]
     else:
         normalized_value = param_value
 
     is_allowed_value, value = allowed_value(param_name, normalized_value)
     if not is_allowed_value:
         err_console.print(
-            f"Hyperparameter {param_name} value is not within bounds. Value is {normalized_value} but must be {value}"
+            f"Hyperparameter [dark_orange]{param_name}[/dark_orange] value is not within bounds. "
+            f"Value is {normalized_value} but must be {value}"
         )
         return
 
@@ -572,24 +585,30 @@ async def get_senate(subtensor: "SubtensorInterface"):
     return console.print(table)
 
 
-async def proposals(subtensor: "SubtensorInterface"):
+async def proposals(subtensor: "SubtensorInterface", verbose: bool):
     console.print(
         ":satellite: Syncing with chain: [white]{}[/white] ...".format(
             subtensor.network
         )
     )
-    print_verbose("Fetching senate members & proposals")
     block_hash = await subtensor.substrate.get_chain_head()
-    senate_members, all_proposals = await asyncio.gather(
+    senate_members, all_proposals, current_block = await asyncio.gather(
         _get_senate_members(subtensor, block_hash),
         _get_proposals(subtensor, block_hash),
+        subtensor.substrate.get_block_number(block_hash),
     )
 
-    print_verbose("Fetching member information from Chain")
     registered_delegate_info: dict[
         str, DelegatesDetails
     ] = await subtensor.get_delegate_identities()
 
+    title = (
+        f"[bold #4196D6]Bittensor Governance Proposals[/bold #4196D6]\n"
+        f"[steel_blue3]Current Block:[/steel_blue3] {current_block}\t"
+        f"[steel_blue3]Network:[/steel_blue3] {subtensor.network}\n\n"
+        f"[steel_blue3]Active Proposals:[/steel_blue3] {len(all_proposals)}\t"
+        f"[steel_blue3]Senate Size:[/steel_blue3] {len(senate_members)}\n"
+    )
     table = Table(
         Column(
             "[white]HASH",
@@ -604,8 +623,8 @@ async def proposals(subtensor: "SubtensorInterface"):
             style="rgb(50,163,219)",
         ),
         Column("[white]END", style="bright_cyan"),
-        Column("[white]CALLDATA", style="dark_sea_green"),
-        title=f"\n[dark_orange]Proposals\t\t\nActive Proposals: {len(all_proposals)}\t\tSenate Size: {len(senate_members)}\nNetwork: {subtensor.network}",
+        Column("[white]CALLDATA", style="dark_sea_green", width=30),
+        title=title,
         show_footer=True,
         box=box.SIMPLE_HEAVY,
         pad_edge=False,
@@ -613,16 +632,36 @@ async def proposals(subtensor: "SubtensorInterface"):
         border_style="bright_black",
     )
     for hash_, (call_data, vote_data) in all_proposals.items():
+        blocks_remaining = vote_data.end - current_block
+        if blocks_remaining > 0:
+            duration_str = blocks_to_duration(blocks_remaining)
+            vote_end_cell = f"{vote_data.end} [dim](in {duration_str})[/dim]"
+        else:
+            vote_end_cell = f"{vote_data.end} [red](expired)[/red]"
+
+        ayes_threshold = (
+            (len(vote_data.ayes) / vote_data.threshold * 100)
+            if vote_data.threshold > 0
+            else 0
+        )
+        nays_threshold = (
+            (len(vote_data.nays) / vote_data.threshold * 100)
+            if vote_data.threshold > 0
+            else 0
+        )
         table.add_row(
-            hash_,
+            hash_ if verbose else f"{hash_[:4]}...{hash_[-4:]}",
             str(vote_data.threshold),
-            str(len(vote_data.ayes)),
-            str(len(vote_data.nays)),
+            f"{len(vote_data.ayes)} ({ayes_threshold:.2f}%)",
+            f"{len(vote_data.nays)} ({nays_threshold:.2f}%)",
             display_votes(vote_data, registered_delegate_info),
-            str(vote_data.end),
+            vote_end_cell,
             format_call_data(call_data),
         )
-    return console.print(table)
+    console.print(table)
+    console.print(
+        "\n[dim]* Both Ayes and Nays percentages are calculated relative to the proposal's threshold.[/dim]"
+    )
 
 
 async def senate_vote(
@@ -653,10 +692,7 @@ async def senate_vote(
         return False
 
     # Unlock the wallet.
-    try:
-        wallet.unlock_hotkey()
-        wallet.unlock_coldkey()
-    except KeyFileError:
+    if not unlock_key(wallet, "hot").success and unlock_key(wallet, "cold").success:
         return False
 
     console.print(f"Fetching proposals in [dark_orange]network: {subtensor.network}")
@@ -732,10 +768,7 @@ async def set_take(
         f"Setting take on [{COLOR_PALETTE['GENERAL']['LINKS']}]network: {subtensor.network}"
     )
 
-    try:
-        wallet.unlock_hotkey()
-        wallet.unlock_coldkey()
-    except KeyFileError:
+    if not unlock_key(wallet, "hot").success and unlock_key(wallet, "cold").success:
         return False
 
     result_ = await _do_set_take()

bittensor_cli/src/commands/wallets.py

@@ -6,7 +6,7 @@ from typing import Generator, Optional
 
 import aiohttp
 from bittensor_wallet import Wallet, Keypair
-from bittensor_wallet.errors import KeyFileError, PasswordError
+from bittensor_wallet.errors import KeyFileError
 from bittensor_wallet.keyfile import Keyfile
 from fuzzywuzzy import fuzz
 from rich import box
@@ -43,16 +43,11 @@ from bittensor_cli.src.bittensor.utils import (
     validate_coldkey_presence,
     get_subnet_name,
     millify_tao,
+    unlock_key,
+    WalletLike,
 )
 
 
-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
-
-
 async def regen_coldkey(
     wallet: Wallet,
     mnemonic: Optional[str],
@@ -60,6 +55,7 @@ async def regen_coldkey(
     json_path: Optional[str] = None,
     json_password: Optional[str] = "",
     use_password: Optional[bool] = True,
+    overwrite: Optional[bool] = False,
 ):
     """Creates a new coldkey under this wallet"""
     json_str: Optional[str] = None
@@ -69,13 +65,21 @@ async def regen_coldkey(
         with open(json_path, "r") as f:
             json_str = f.read()
     try:
-        wallet.regenerate_coldkey(
+        new_wallet = wallet.regenerate_coldkey(
             mnemonic=mnemonic,
             seed=seed,
             json=(json_str, json_password) if all([json_str, json_password]) else None,
             use_password=use_password,
-            overwrite=False,
+            overwrite=overwrite,
         )
+
+        if isinstance(new_wallet, Wallet):
+            console.print(
+                "\n✅ [dark_sea_green]Regenerated coldkey successfully!\n",
+                f"[dark_sea_green]Wallet name: ({new_wallet.name}), path: ({new_wallet.path}), coldkey ss58: ({new_wallet.coldkeypub.ss58_address})",
+            )
+    except ValueError:
+        print_error("Mnemonic phrase is invalid")
     except KeyFileError:
         print_error("KeyFileError: File is not writable")
 
@@ -84,14 +88,20 @@ async def regen_coldkey_pub(
     wallet: Wallet,
     ss58_address: str,
     public_key_hex: str,
+    overwrite: Optional[bool] = False,
 ):
     """Creates a new coldkeypub under this wallet."""
     try:
-        wallet.regenerate_coldkeypub(
+        new_coldkeypub = wallet.regenerate_coldkeypub(
             ss58_address=ss58_address,
             public_key=public_key_hex,
-            overwrite=False,
+            overwrite=overwrite,
         )
+        if isinstance(new_coldkeypub, Wallet):
+            console.print(
+                "\n✅ [dark_sea_green]Regenerated coldkeypub successfully!\n",
+                f"[dark_sea_green]Wallet name: ({new_coldkeypub.name}), path: ({new_coldkeypub.path}), coldkey ss58: ({new_coldkeypub.coldkeypub.ss58_address})",
+            )
     except KeyFileError:
         print_error("KeyFileError: File is not writable")
 
@@ -103,6 +113,7 @@ async def regen_hotkey(
     json_path: Optional[str],
     json_password: Optional[str] = "",
     use_password: Optional[bool] = False,
+    overwrite: Optional[bool] = False,
 ):
     """Creates a new hotkey under this wallet."""
     json_str: Optional[str] = None
@@ -114,13 +125,20 @@ async def regen_hotkey(
             json_str = f.read()
 
     try:
-        wallet.regenerate_hotkey(
+        new_hotkey = wallet.regenerate_hotkey(
             mnemonic=mnemonic,
             seed=seed,
             json=(json_str, json_password) if all([json_str, json_password]) else None,
             use_password=use_password,
-            overwrite=False,
+            overwrite=overwrite,
         )
+        if isinstance(new_hotkey, Wallet):
+            console.print(
+                "\n✅ [dark_sea_green]Regenerated hotkey successfully!\n",
+                f"[dark_sea_green]Wallet name: ({new_hotkey.name}), path: ({new_hotkey.path}), hotkey ss58: ({new_hotkey.hotkey.ss58_address})",
+            )
+    except ValueError:
+        print_error("Mnemonic phrase is invalid")
     except KeyFileError:
         print_error("KeyFileError: File is not writable")
 
@@ -130,6 +148,7 @@ async def new_hotkey(
     n_words: int,
     use_password: bool,
     uri: Optional[str] = None,
+    overwrite: Optional[bool] = False,
 ):
     """Creates a new hotkey under this wallet."""
     try:
@@ -146,7 +165,7 @@ async def new_hotkey(
             wallet.create_new_hotkey(
                 n_words=n_words,
                 use_password=use_password,
-                overwrite=False,
+                overwrite=overwrite,
             )
             console.print("[dark_sea_green]Hotkey created[/dark_sea_green]")
     except KeyFileError:
@@ -158,6 +177,7 @@ async def new_coldkey(
     n_words: int,
     use_password: bool,
     uri: Optional[str] = None,
+    overwrite: Optional[bool] = False,
 ):
     """Creates a new coldkey under this wallet."""
     try:
@@ -175,7 +195,7 @@ async def new_coldkey(
             wallet.create_new_coldkey(
                 n_words=n_words,
                 use_password=use_password,
-                overwrite=False,
+                overwrite=overwrite,
             )
             console.print("[dark_sea_green]Coldkey created[/dark_sea_green]")
     except KeyFileError:
@@ -187,6 +207,7 @@ async def wallet_create(
     n_words: int = 12,
     use_password: bool = True,
     uri: Optional[str] = None,
+    overwrite: Optional[bool] = False,
 ):
     """Creates a new wallet."""
     if uri:
@@ -205,7 +226,7 @@ async def wallet_create(
             wallet.create_new_coldkey(
                 n_words=n_words,
                 use_password=use_password,
-                overwrite=False,
+                overwrite=overwrite,
             )
             console.print("[dark_sea_green]Coldkey created[/dark_sea_green]")
         except KeyFileError:
@@ -215,7 +236,7 @@ async def wallet_create(
             wallet.create_new_hotkey(
                 n_words=n_words,
                 use_password=False,
-                overwrite=False,
+                overwrite=overwrite,
             )
             console.print("[dark_sea_green]Hotkey created[/dark_sea_green]")
         except KeyFileError:
@@ -487,7 +508,9 @@ async def wallet_list(wallet_path: str):
         wallet_tree = root.add(
             f"[bold blue]Coldkey[/bold blue] [green]{wallet.name}[/green]  ss58_address [green]{coldkeypub_str}[/green]"
         )
-        hotkeys = utils.get_hotkey_wallets_for_wallet(wallet, show_nulls=True)
+        hotkeys = utils.get_hotkey_wallets_for_wallet(
+            wallet, show_nulls=True, show_encrypted=True
+        )
         for hkey in hotkeys:
             data = f"[bold red]Hotkey[/bold red][green] {hkey}[/green] (?)"
             if hkey:
@@ -1047,11 +1070,17 @@ async def transfer(
     subtensor: SubtensorInterface,
     destination: str,
     amount: float,
+    transfer_all: bool,
     prompt: bool,
 ):
     """Transfer token of amount to destination."""
     await transfer_extrinsic(
-        subtensor, wallet, destination, Balance.from_tao(amount), prompt=prompt
+        subtensor=subtensor,
+        wallet=wallet,
+        destination=destination,
+        amount=Balance.from_tao(amount),
+        transfer_all=transfer_all,
+        prompt=prompt,
     )
 
 
@@ -1211,13 +1240,14 @@ async def faucet(
     output_in_place: bool,
     log_verbose: bool,
     max_successes: int = 3,
+    prompt: bool = True,
 ):
     # TODO: - work out prompts to be passed through the cli
     success = await run_faucet_extrinsic(
         subtensor,
         wallet,
         tpb=threads_per_block,
-        prompt=False,
+        prompt=prompt,
         update_interval=update_interval,
         num_processes=processes,
         cuda=use_cuda,
@@ -1303,10 +1333,7 @@ async def set_id(
             )
             return False
 
-    try:
-        wallet.unlock_coldkey()
-    except KeyFileError:
-        err_console.print("Error decrypting coldkey (possibly incorrect password)")
+    if not unlock_key(wallet).success:
         return False
 
     call = await subtensor.substrate.compose_call(
@@ -1398,30 +1425,15 @@ async def check_coldkey_swap(wallet: Wallet, subtensor: SubtensorInterface):
 async def sign(wallet: Wallet, message: str, use_hotkey: str):
     """Sign a message using the provided wallet or hotkey."""
 
-    def _unlock(key: str):
-        try:
-            getattr(wallet, f"unlock_{key}")()
-            return True
-        except PasswordError:
-            err_console.print(
-                ":cross_mark: [red]The password used to decrypt your keyfile is invalid[/red]"
-            )
-            return False
-        except KeyFileError:
-            err_console.print(
-                ":cross_mark: [red]Keyfile is corrupt, non-writable, or non-readable[/red]:"
-            )
-            return False
-
     if not use_hotkey:
-        if not _unlock("coldkey"):
+        if not unlock_key(wallet, "cold").success:
             return False
         keypair = wallet.coldkey
         print_verbose(
             f"Signing using [{COLOR_PALETTE['GENERAL']['COLDKEY']}]coldkey: {wallet.name}"
         )
     else:
-        if not _unlock("hotkey"):
+        if not unlock_key(wallet, "hot").success:
             return False
         keypair = wallet.hotkey
         print_verbose(