bittensor-cli 8.1.1__py3-none-any.whl → 8.3.0__py3-none-any.whl

bittensor_cli/src/commands/root.py

@@ -11,9 +11,10 @@ from rich.prompt import Confirm
 from rich.table import Column, Table
 from rich.text import Text
 from scalecodec import GenericCall, ScaleType
+from substrateinterface.exceptions import SubstrateRequestException
 import typer
 
-from bittensor_cli.src import Constants, DelegatesDetails
+from bittensor_cli.src import DelegatesDetails
 from bittensor_cli.src.bittensor.balances import Balance
 from bittensor_cli.src.bittensor.chain_data import (
     DelegateInfo,
@@ -282,6 +283,7 @@ async def burned_register_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     with console.status(
@@ -538,6 +540,7 @@ async def delegate_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     print_verbose("Checking if hotkey is a delegate")
@@ -721,7 +724,7 @@ async def root_list(subtensor: SubtensorInterface):
 
         rn: list[NeuronInfoLite] = await subtensor.neurons_lite(netuid=0)
         if not rn:
-            return None, None, None, None
+            return [], [], {}, {}
 
         di: dict[str, DelegatesDetails] = await subtensor.get_delegate_identities()
         ts: dict[str, ScaleType] = await subtensor.substrate.query_multiple(
@@ -1099,6 +1102,7 @@ async def senate_vote(
         wallet.unlock_hotkey()
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     console.print(f"Fetching proposals in [dark_orange]network: {subtensor.network}")
@@ -1322,6 +1326,7 @@ async def set_take(wallet: Wallet, subtensor: SubtensorInterface, take: float) -
         wallet.unlock_hotkey()
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     result_ = await _do_set_take()
@@ -1539,16 +1544,24 @@ async def list_delegates(subtensor: SubtensorInterface):
             subtensor.get_delegates(block_hash=block_hash),
         )
 
-        # TODO keep an eye on this, was not working at one point
         print_verbose("Fetching previous delegates info from chain", status)
-        prev_block_hash = await subtensor.substrate.get_block_hash(
-            max(0, block_number - 1200)
-        )
-        prev_delegates = await subtensor.get_delegates(block_hash=prev_block_hash)
+
+        async def get_prev_delegates(fallback_offsets=(1200, 200)):
+            for offset in fallback_offsets:
+                try:
+                    prev_block_hash = await subtensor.substrate.get_block_hash(
+                        max(0, block_number - offset)
+                    )
+                    return await subtensor.get_delegates(block_hash=prev_block_hash)
+                except SubstrateRequestException:
+                    continue
+            return None
+
+        prev_delegates = await get_prev_delegates()
 
     if prev_delegates is None:
         err_console.print(
-            ":warning: [yellow]Could not fetch delegates history[/yellow]"
+            ":warning: [yellow]Could not fetch delegates history. [/yellow]"
         )
 
     delegates.sort(key=lambda d: d.total_stake, reverse=True)
@@ -1715,6 +1728,7 @@ async def nominate(wallet: Wallet, subtensor: SubtensorInterface, prompt: bool):
         wallet.unlock_hotkey()
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     print_verbose(f"Checking hotkey ({wallet.hotkey_str}) is a delegate")

bittensor_cli/src/commands/stake/children_hotkeys.py

@@ -18,6 +18,7 @@ from bittensor_cli.src.bittensor.utils import (
     u16_to_float,
     u64_to_float,
     is_valid_ss58_address,
+    format_error_message,
 )
 
 
@@ -208,8 +209,11 @@ async def set_childkey_take_extrinsic(
                 # )
                 return False, error_message
 
-        except Exception as e:
-            return False, f"Exception occurred while setting childkey take: {str(e)}"
+        except SubstrateRequestException as e:
+            return (
+                False,
+                f"Exception occurred while setting childkey take: {format_error_message(e, subtensor.substrate)}",
+            )
 
 
 async def get_childkey_take(subtensor, hotkey: str, netuid: int) -> Optional[int]:
@@ -232,7 +236,9 @@ async def get_childkey_take(subtensor, hotkey: str, netuid: int) -> Optional[int
             return int(childkey_take_.value)
 
     except SubstrateRequestException as e:
-        err_console.print(f"Error querying ChildKeys: {e}")
+        err_console.print(
+            f"Error querying ChildKeys: {format_error_message(e, subtensor.substrate)}"
+        )
         return None
 
 
@@ -488,6 +494,7 @@ async def set_children(
     netuid: Optional[int] = None,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = True,
+    prompt: bool = True,
 ):
     """Set children hotkeys."""
     # Validate children SS58 addresses
@@ -514,7 +521,7 @@ async def set_children(
             netuid=netuid,
             hotkey=wallet.hotkey.ss58_address,
             children_with_proportions=children_with_proportions,
-            prompt=True,
+            prompt=prompt,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
         )
@@ -543,7 +550,7 @@ async def set_children(
                 netuid=netuid,
                 hotkey=wallet.hotkey.ss58_address,
                 children_with_proportions=children_with_proportions,
-                prompt=False,
+                prompt=prompt,
                 wait_for_inclusion=True,
                 wait_for_finalization=False,
             )
@@ -558,6 +565,7 @@ async def revoke_children(
     netuid: Optional[int] = None,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = True,
+    prompt: bool = True,
 ):
     """
     Revokes the children hotkeys associated with a given network identifier (netuid).
@@ -569,7 +577,7 @@ async def revoke_children(
             netuid=netuid,
             hotkey=wallet.hotkey.ss58_address,
             children_with_proportions=[],
-            prompt=True,
+            prompt=prompt,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
         )
@@ -598,7 +606,7 @@ async def revoke_children(
                 netuid=netuid,
                 hotkey=wallet.hotkey.ss58_address,
                 children_with_proportions=[],
-                prompt=False,
+                prompt=prompt,
                 wait_for_inclusion=True,
                 wait_for_finalization=False,
             )
@@ -758,7 +766,7 @@ async def childkey_take(
                     netuid=netuid,
                     hotkey=wallet.hotkey.ss58_address,
                     take=take,
-                    prompt=False,
+                    prompt=prompt,
                     wait_for_inclusion=True,
                     wait_for_finalization=False,
                 )

bittensor_cli/src/commands/stake/stake.py

@@ -106,6 +106,7 @@ async def add_stake_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     # Default to wallet's own hotkey if the value is not passed.
@@ -312,6 +313,7 @@ async def add_stake_multiple_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     with console.status(
@@ -493,6 +495,7 @@ async def unstake_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     if hotkey_ss58 is None:
@@ -523,7 +526,7 @@ async def unstake_extrinsic(
         # Unstake it all.
         unstaking_balance = old_stake
     else:
-        unstaking_balance = amount
+        unstaking_balance = Balance.from_tao(amount)
 
     # Check enough to unstake.
     stake_on_uid = old_stake
@@ -561,7 +564,6 @@ async def unstake_extrinsic(
         f":satellite: Unstaking from chain: [white]{subtensor}[/white] ...",
         spinner="earth",
     ):
-        unstaking_balance = Balance.from_tao(unstaking_balance)
         call = await subtensor.substrate.compose_call(
             call_module="SubtensorModule",
             call_function="remove_stake",
@@ -664,6 +666,7 @@ async def unstake_multiple_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     with console.status(
@@ -1179,6 +1182,7 @@ async def stake_add(
             (wallet.hotkey_str, wallet.hotkey.ss58_address)
             for wallet in all_hotkeys_
             if wallet.hotkey_str not in exclude_hotkeys
+            and wallet.hotkey.ss58_address not in exclude_hotkeys
         ]  # definitely wallets
 
     elif include_hotkeys:
@@ -1346,6 +1350,7 @@ async def unstake(
             (wallet.hotkey_str, wallet.hotkey.ss58_address)
             for wallet in all_hotkeys_
             if wallet.hotkey_str not in exclude_hotkeys
+            and wallet.hotkey.ss58_address not in hotkeys_to_unstake_from
         ]  # definitely wallets
 
     elif include_hotkeys:

bittensor_cli/src/commands/subnets.py

@@ -103,6 +103,7 @@ async def register_subnetwork_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     with console.status(":satellite: Registering subnet...", spinner="earth"):
@@ -129,7 +130,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)}"
+                f":cross_mark: [red]Failed[/red]: {format_error_message(await response.error_message, substrate)}"
             )
             await asyncio.sleep(0.5)
             return False
@@ -399,6 +400,7 @@ async def pow_register(
     use_cuda,
     dev_id,
     threads_per_block,
+    prompt: bool,
 ):
     """Register neuron."""
 
@@ -406,7 +408,7 @@ async def pow_register(
         subtensor,
         wallet=wallet,
         netuid=netuid,
-        prompt=True,
+        prompt=prompt,
         tpb=threads_per_block,
         update_interval=update_interval,
         num_processes=processors,

bittensor_cli/src/commands/sudo.py

@@ -104,6 +104,7 @@ async def set_hyperparameter_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     extrinsic = HYPERPARAMS.get(parameter)

bittensor_cli/src/commands/wallets.py

@@ -4,10 +4,9 @@ import itertools
 import os
 import sys
 from collections import defaultdict
-from concurrent.futures import ProcessPoolExecutor
 from functools import partial
 from sys import getsizeof
-from typing import Any, Collection, Generator, Optional
+from typing import Collection, Generator, Optional
 
 import aiohttp
 from bittensor_wallet import Wallet
@@ -59,6 +58,13 @@ from bittensor_cli.src.bittensor.utils import (
 )
 
 
+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],
@@ -75,13 +81,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,
         )
+
+        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")
 
@@ -93,11 +107,16 @@ async def regen_coldkey_pub(
 ):
     """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,
         )
+        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")
 
@@ -120,13 +139,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,
         )
+        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")
 
@@ -221,16 +247,25 @@ def _get_coldkey_ss58_addresses_for_path(path: str) -> tuple[list[str], list[str
 
 
 async def wallet_balance(
-    wallet: Wallet, subtensor: SubtensorInterface, all_balances: bool
+    wallet: Optional[Wallet],
+    subtensor: SubtensorInterface,
+    all_balances: bool,
+    ss58_addresses: Optional[str] = None,
 ):
     """Retrieves the current balance of the specified wallet"""
-    if not all_balances:
+    if ss58_addresses:
+        coldkeys = ss58_addresses
+        wallet_names = [f"Provided Address {i + 1}" for i in range(len(ss58_addresses))]
+
+    elif not all_balances:
         if not wallet.coldkeypub_file.exists_on_device():
             err_console.print("[bold red]No wallets found.[/bold red]")
             return
 
     with console.status("Retrieving balances", spinner="aesthetic") as status:
-        if all_balances:
+        if ss58_addresses:
+            print_verbose(f"Fetching data for ss58 address: {ss58_addresses}", status)
+        elif all_balances:
             print_verbose("Fetching data for all wallets", status)
             coldkeys, wallet_names = _get_coldkey_ss58_addresses_for_path(wallet.path)
         else:
@@ -688,9 +723,11 @@ async def overview(
                 de_registered_neurons.append(de_registered_neuron)
 
                 # Add this hotkey to the wallets dict
-                wallet_ = Wallet(name=wallet)
-                wallet_.hotkey_ss58 = hotkey_addr
-                wallet.hotkey_str = hotkey_addr[:5]  # Max length of 5 characters
+                wallet_ = WalletLike(
+                    name=wallet.name,
+                    hotkey_ss58=hotkey_addr,
+                    hotkey_str=hotkey_addr[:5],
+                )
                 # Indicates a hotkey not on local machine but exists in stake_info obj on-chain
                 if hotkey_coldkey_to_hotkey_wallet.get(hotkey_addr) is None:
                     hotkey_coldkey_to_hotkey_wallet[hotkey_addr] = {}
@@ -753,8 +790,7 @@ async def overview(
             if not hotwallet:
                 # Indicates a mismatch between what the chain says the coldkey
                 # is for this hotkey and the local wallet coldkey-hotkey pair
-                hotwallet = Wallet(name=nn.coldkey[:7])
-                hotwallet.hotkey_str = nn.hotkey[:7]
+                hotwallet = WalletLike(name=nn.coldkey[:7], hotkey_str=nn.hotkey[:7])
 
             nn: NeuronInfoLite
             uid = nn.uid
@@ -1093,7 +1129,7 @@ def _map_hotkey_to_neurons(
 
 async def _fetch_neuron_for_netuid(
     netuid: int, subtensor: SubtensorInterface
-) -> tuple[int, dict[str, list[ScaleBytes]]]:
+) -> tuple[int, Optional[str]]:
     """
     Retrieves all neurons for a specified netuid
 
@@ -1103,18 +1139,13 @@ async def _fetch_neuron_for_netuid(
     :return: the original netuid, and a mapping of the neurons to their NeuronInfoLite objects
     """
 
-    async def neurons_lite_for_uid(uid: int) -> dict[Any, Any]:
-        call_definition = TYPE_REGISTRY["runtime_api"]["NeuronInfoRuntimeApi"][
-            "methods"
-        ]["get_neurons_lite"]
-        data = await subtensor.encode_params(
-            call_definition=call_definition, params=[uid]
-        )
+    async def neurons_lite_for_uid(uid: int) -> Optional[str]:
         block_hash = subtensor.substrate.last_block_hash
-        hex_bytes_result = await subtensor.substrate.rpc_request(
-            method="state_call",
-            params=["NeuronInfoRuntimeApi_get_neurons_lite", data, block_hash],
-            reuse_block_hash=True,
+        hex_bytes_result = await subtensor.query_runtime_api(
+            runtime_api="NeuronInfoRuntimeApi",
+            method="get_neurons_lite",
+            params=[uid],
+            block_hash=block_hash,
         )
 
         return hex_bytes_result
@@ -1125,7 +1156,7 @@ async def _fetch_neuron_for_netuid(
 
 async def _fetch_all_neurons(
     netuids: list[int], subtensor
-) -> list[tuple[int, list[ScaleBytes]]]:
+) -> list[tuple[int, Optional[str]]]:
     """Retrieves all neurons for each of the specified netuids"""
     return list(
         await asyncio.gather(
@@ -1134,50 +1165,21 @@ async def _fetch_all_neurons(
     )
 
 
-def _partial_decode(args):
-    """
-    Helper function for passing to ProcessPoolExecutor that decodes scale bytes based on a set return type and
-    rpc type registry, passing this back to the Executor with its specified netuid for easier mapping
-
-    :param args: (return type, scale bytes object, custom rpc type registry, netuid)
-
-    :return: (original netuid, decoded object)
-    """
-    return_type, as_scale_bytes, custom_rpc_type_registry_, netuid_ = args
-    decoded = decode_scale_bytes(return_type, as_scale_bytes, custom_rpc_type_registry_)
-    if decoded.startswith("0x"):
-        bytes_result = bytes.fromhex(decoded[2:])
-    else:
-        bytes_result = bytes.fromhex(decoded)
-
-    return netuid_, NeuronInfoLite.list_from_vec_u8(bytes_result)
-
-
 def _process_neurons_for_netuids(
-    netuids_with_all_neurons_hex_bytes: list[tuple[int, list[ScaleBytes]]],
+    netuids_with_all_neurons_hex_bytes: list[tuple[int, Optional[str]]],
 ) -> list[tuple[int, list[NeuronInfoLite]]]:
     """
-    Using multiprocessing to decode a list of hex-bytes neurons with their respective netuid
+    Decode a list of hex-bytes neurons with their respective netuid
 
     :param netuids_with_all_neurons_hex_bytes: netuids with hex-bytes neurons
     :return: netuids mapped to decoded neurons
     """
-
-    def make_map(res_):
-        netuid_, json_result = res_
-        hex_bytes_result = json_result["result"]
-        as_scale_bytes = scalecodec.ScaleBytes(hex_bytes_result)
-        return [return_type, as_scale_bytes, custom_rpc_type_registry, netuid_]
-
-    return_type = TYPE_REGISTRY["runtime_api"]["NeuronInfoRuntimeApi"]["methods"][
-        "get_neurons_lite"
-    ]["type"]
-
-    preprocessed = [make_map(r) for r in netuids_with_all_neurons_hex_bytes]
-    with ProcessPoolExecutor() as executor:
-        results = list(executor.map(_partial_decode, preprocessed))
-
-    all_results = [(netuid, result) for netuid, result in results]
+    all_results = [
+        (netuid, NeuronInfoLite.list_from_vec_u8(bytes.fromhex(result[2:])))
+        if result
+        else (netuid, [])
+        for netuid, result in netuids_with_all_neurons_hex_bytes
+    ]
     return all_results
 
 
@@ -1247,11 +1249,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,
+        wallet,
+        destination,
+        Balance.from_tao(amount),
+        transfer_all,
+        prompt=prompt,
     )
 
 
@@ -1405,13 +1413,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,
@@ -1610,6 +1619,7 @@ async def set_id(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     with console.status(