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

bittensor_cli/src/__init__.py

@@ -4,16 +4,18 @@ from typing import Any, Optional
 
 
 class Constants:
-    networks = ["local", "finney", "test", "archive"]
+    networks = ["local", "finney", "test", "archive", "subvortex"]
     finney_entrypoint = "wss://entrypoint-finney.opentensor.ai:443"
     finney_test_entrypoint = "wss://test.finney.opentensor.ai:443"
     archive_entrypoint = "wss://archive.chain.opentensor.ai:443"
-    local_entrypoint = "ws://127.0.0.1:9444"
+    subvortex_entrypoint = "ws://subvortex.info:9944"
+    local_entrypoint = "ws://127.0.0.1:9944"
     network_map = {
         "finney": finney_entrypoint,
         "test": finney_test_entrypoint,
         "archive": archive_entrypoint,
         "local": local_entrypoint,
+        "subvortex": subvortex_entrypoint,
     }
     delegates_detail_url = "https://raw.githubusercontent.com/opentensor/bittensor-delegates/main/public/delegates.json"
 

bittensor_cli/src/bittensor/async_substrate_interface.py

@@ -460,6 +460,9 @@ class Runtime:
         self.runtime_config = runtime_config
         self.metadata = metadata
 
+    def __str__(self):
+        return f"Runtime: {self.chain} | {self.config}"
+
     @property
     def implements_scaleinfo(self) -> bool:
         """
@@ -679,12 +682,12 @@ class Websocket:
 
     async def shutdown(self):
         async with self._lock:
-            self._receiving_task.cancel()
             try:
+                self._receiving_task.cancel()
                 await self._receiving_task
-            except asyncio.CancelledError:
+                await self.ws.close()
+            except (AttributeError, asyncio.CancelledError):
                 pass
-            await self.ws.close()
             self.ws = None
             self._initialized = False
             self._receiving_task = None
@@ -897,9 +900,10 @@ class AsyncSubstrateInterface:
 
         async def get_runtime(block_hash, block_id) -> Runtime:
             # Check if runtime state already set to current block
-            if (block_hash and block_hash == self.last_block_hash) or (
-                block_id and block_id == self.block_id
-            ):
+            if (
+                (block_hash and block_hash == self.last_block_hash)
+                or (block_id and block_id == self.block_id)
+            ) and self.metadata is not None:
                 return Runtime(
                     self.chain,
                     self.runtime_config,
@@ -945,9 +949,11 @@ class AsyncSubstrateInterface:
                 raise SubstrateRequestException(
                     f"No runtime information for block '{block_hash}'"
                 )
-
             # Check if runtime state already set to current block
-            if runtime_info.get("specVersion") == self.runtime_version:
+            if (
+                runtime_info.get("specVersion") == self.runtime_version
+                and self.metadata is not None
+            ):
                 return Runtime(
                     self.chain,
                     self.runtime_config,
@@ -962,16 +968,19 @@ class AsyncSubstrateInterface:
                 if self.runtime_version in self.__metadata_cache:
                     # Get metadata from cache
                     # self.debug_message('Retrieved metadata for {} from memory'.format(self.runtime_version))
-                    self.metadata = self.__metadata_cache[self.runtime_version]
+                    metadata = self.metadata = self.__metadata_cache[
+                        self.runtime_version
+                    ]
                 else:
-                    self.metadata = await self.get_block_metadata(
+                    metadata = self.metadata = await self.get_block_metadata(
                         block_hash=runtime_block_hash, decode=True
                     )
                     # self.debug_message('Retrieved metadata for {} from Substrate node'.format(self.runtime_version))
 
                     # Update metadata cache
                     self.__metadata_cache[self.runtime_version] = self.metadata
-
+            else:
+                metadata = self.metadata
             # Update type registry
             self.reload_type_registry(use_remote_preset=False, auto_discover=True)
 
@@ -1012,7 +1021,10 @@ class AsyncSubstrateInterface:
         if block_id and block_hash:
             raise ValueError("Cannot provide block_hash and block_id at the same time")
 
-        if not (runtime := self.runtime_cache.retrieve(block_id, block_hash)):
+        if (
+            not (runtime := self.runtime_cache.retrieve(block_id, block_hash))
+            or runtime.metadata is None
+        ):
             runtime = await get_runtime(block_hash, block_id)
             self.runtime_cache.add_item(block_id, block_hash, runtime)
         return runtime
@@ -1123,7 +1135,7 @@ class AsyncSubstrateInterface:
         -------
         StorageKey
         """
-        await self.init_runtime(block_hash=block_hash)
+        runtime = await self.init_runtime(block_hash=block_hash)
 
         return StorageKey.create_from_storage_function(
             pallet,
@@ -1707,9 +1719,7 @@ class AsyncSubstrateInterface:
         )
         result = await self._make_rpc_request(payloads, runtime=runtime)
         if "error" in result[payload_id][0]:
-            raise SubstrateRequestException(
-                result["rpc_request"][0]["error"]["message"]
-            )
+            raise SubstrateRequestException(result[payload_id][0]["error"]["message"])
         if "result" in result[payload_id][0]:
             return result[payload_id][0]
         else:
@@ -2274,7 +2284,7 @@ class AsyncSubstrateInterface:
         MetadataModuleConstants
         """
 
-        # await self.init_runtime(block_hash=block_hash)
+        await self.init_runtime(block_hash=block_hash)
 
         for module in self.metadata.pallets:
             if module_name == module.name and module.constants:

bittensor_cli/src/bittensor/extrinsics/registration.py

@@ -16,6 +16,7 @@ import random
 import time
 import typing
 from typing import Optional
+import subprocess
 
 import backoff
 from bittensor_wallet import Wallet
@@ -35,6 +36,7 @@ from bittensor_cli.src.bittensor.utils import (
     millify,
     get_human_readable,
     print_verbose,
+    print_error,
 )
 
 if typing.TYPE_CHECKING:
@@ -512,12 +514,13 @@ async def register_extrinsic(
     with console.status(
         f":satellite: Checking Account on [bold]subnet:{netuid}[/bold]...",
         spinner="aesthetic",
-    ):
+    ) as status:
         neuron = await get_neuron_for_pubkey_and_subnet()
         if not neuron.is_null:
-            # bittensor.logging.debug(
-            #     f"Wallet {wallet} is already registered on {neuron.netuid} with {neuron.uid}"
-            # )
+            print_error(
+                f"Wallet {wallet} is already registered on subnet {neuron.netuid} with uid {neuron.uid}",
+                status,
+            )
             return True
 
     if prompt:
@@ -611,28 +614,32 @@ async def register_extrinsic(
                         success, err_msg = True, ""
                     else:
                         await response.process_events()
-                        if not await response.is_success:
+                        success = await response.is_success
+                        if not success:
                             success, err_msg = (
                                 False,
-                                format_error_message(await response.error_message),
+                                format_error_message(
+                                    await response.error_message,
+                                    substrate=subtensor.substrate,
+                                ),
                             )
-
-                    if not success:
-                        # Look error here
-                        # https://github.com/opentensor/subtensor/blob/development/pallets/subtensor/src/errors.rs
-                        if "HotKeyAlreadyRegisteredInSubNet" in err_msg:
-                            console.print(
-                                f":white_heavy_check_mark: [green]Already Registered on "
-                                f"[bold]subnet:{netuid}[/bold][/green]"
+                            # Look error here
+                            # https://github.com/opentensor/subtensor/blob/development/pallets/subtensor/src/errors.rs
+
+                            if "HotKeyAlreadyRegisteredInSubNet" in err_msg:
+                                console.print(
+                                    f":white_heavy_check_mark: [green]Already Registered on "
+                                    f"[bold]subnet:{netuid}[/bold][/green]"
+                                )
+                                return True
+                            err_console.print(
+                                f":cross_mark: [red]Failed[/red]: {err_msg}"
                             )
-                            return True
-
-                        err_console.print(f":cross_mark: [red]Failed[/red]: {err_msg}")
-                        await asyncio.sleep(0.5)
+                            await asyncio.sleep(0.5)
 
                     # Successful registration, final check for neuron and pubkey
-                    else:
-                        console.print(":satellite: Checking Balance...")
+                    if success:
+                        console.print(":satellite: Checking Registration status...")
                         is_registered = await is_hotkey_registered(
                             subtensor,
                             netuid=netuid,
@@ -785,7 +792,8 @@ async def run_faucet_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]: "
+                    f"{format_error_message(await response.error_message, subtensor.substrate)}"
                 )
                 if attempts == max_allowed_attempts:
                     raise MaxAttemptsException
@@ -910,6 +918,9 @@ async def _block_solver(
     stop_event.clear()
 
     solution_queue = Queue()
+    if cuda:
+        num_processes = len(dev_id)
+
     finished_queues = [Queue() for _ in range(num_processes)]
     check_block = Lock()
 
@@ -919,7 +930,6 @@ async def _block_solver(
 
     if cuda:
         ## Create a worker per CUDA device
-        num_processes = len(dev_id)
         solvers = [
             _CUDASolver(
                 i,
@@ -1227,8 +1237,14 @@ def _terminate_workers_and_wait_for_exit(
         if isinstance(worker, Queue_Type):
             worker.join_thread()
         else:
-            worker.join()
-        worker.close()
+            try:
+                worker.join(3.0)
+            except subprocess.TimeoutExpired:
+                worker.terminate()
+        try:
+            worker.close()
+        except ValueError:
+            worker.terminate()
 
 
 # TODO verify this works with async
@@ -1626,6 +1642,7 @@ async def swap_hotkey_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     if prompt:

bittensor_cli/src/bittensor/extrinsics/root.py

@@ -20,15 +20,15 @@ import hashlib
 import time
 from typing import Union, List, TYPE_CHECKING
 
-from bittensor_wallet import Wallet
+from bittensor_wallet import Wallet, Keypair
 from bittensor_wallet.errors import KeyFileError
 import numpy as np
 from numpy.typing import NDArray
 from rich.prompt import Confirm
 from rich.table import Table, Column
 from scalecodec import ScaleBytes, U16, Vec
+from substrateinterface.exceptions import SubstrateRequestException
 
-from bittensor_wallet import Keypair
 from bittensor_cli.src.bittensor.subtensor_interface import SubtensorInterface
 from bittensor_cli.src.bittensor.extrinsics.registration import is_hotkey_registered
 from bittensor_cli.src.bittensor.utils import (
@@ -36,6 +36,7 @@ from bittensor_cli.src.bittensor.utils import (
     err_console,
     u16_normalized_float,
     print_verbose,
+    format_error_message,
 )
 
 if TYPE_CHECKING:
@@ -308,6 +309,7 @@ async def root_register_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     print_verbose(f"Checking if hotkey ({wallet.hotkey_str}) is registered on root")
@@ -428,6 +430,7 @@ async def set_root_weights_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     # First convert types.
@@ -481,7 +484,6 @@ async def set_root_weights_extrinsic(
             )
 
             success, error_message = await _do_set_weights()
-            console.print(success, error_message)
 
             if not wait_for_finalization and not wait_for_inclusion:
                 return True
@@ -490,9 +492,11 @@ async def set_root_weights_extrinsic(
                 console.print(":white_heavy_check_mark: [green]Finalized[/green]")
                 return True
             else:
-                err_console.print(f":cross_mark: [red]Failed[/red]: {error_message}")
+                fmt_err = format_error_message(error_message, subtensor.substrate)
+                err_console.print(f":cross_mark: [red]Failed[/red]: {fmt_err}")
                 return False
 
-    except Exception as e:
-        err_console.print(":cross_mark: [red]Failed[/red]: error:{}".format(e))
+    except SubstrateRequestException as e:
+        fmt_err = format_error_message(e, subtensor.substrate)
+        err_console.print(":cross_mark: [red]Failed[/red]: error:{}".format(fmt_err))
         return False

bittensor_cli/src/bittensor/extrinsics/transfer.py

@@ -3,6 +3,7 @@ import asyncio
 from bittensor_wallet import Wallet
 from bittensor_wallet.errors import KeyFileError
 from rich.prompt import Confirm
+from substrateinterface.exceptions import SubstrateRequestException
 
 from bittensor_cli.src import NETWORK_EXPLORER_MAP
 from bittensor_cli.src.bittensor.balances import Balance
@@ -14,6 +15,7 @@ from bittensor_cli.src.bittensor.utils import (
     format_error_message,
     get_explorer_url_for_network,
     is_valid_bittensor_address_or_public_key,
+    print_error,
 )
 
 
@@ -22,6 +24,7 @@ async def transfer_extrinsic(
     wallet: Wallet,
     destination: str,
     amount: Balance,
+    transfer_all: bool = False,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = False,
     keep_alive: bool = True,
@@ -33,6 +36,7 @@ async def transfer_extrinsic(
     :param wallet: Bittensor wallet object to make transfer from.
     :param destination: Destination public key address (ss58_address or ed25519) of recipient.
     :param amount: Amount to stake as Bittensor balance.
+    :param transfer_all: Whether to transfer all funds from this wallet to the destination address.
     :param wait_for_inclusion: If set, waits for the extrinsic to enter a block before returning `True`,
                                or returns `False` if the extrinsic fails to enter the block within the timeout.
     :param wait_for_finalization:  If set, waits for the extrinsic to be finalized on the chain before returning
@@ -59,11 +63,11 @@ async def transfer_extrinsic(
             payment_info = await subtensor.substrate.get_payment_info(
                 call=call, keypair=wallet.coldkeypub
             )
-        except Exception as e:
+        except SubstrateRequestException as e:
             payment_info = {"partialFee": int(2e7)}  # assume  0.02 Tao
             err_console.print(
                 f":cross_mark: [red]Failed to get payment info[/red]:[bold white]\n"
-                f"  {e}[/bold white]\n"
+                f"  {format_error_message(e, subtensor.substrate)}[/bold white]\n"
                 f"  Defaulting to default transfer fee: {payment_info['partialFee']}"
             )
 
@@ -97,7 +101,11 @@ async def transfer_extrinsic(
             block_hash_ = response.block_hash
             return True, block_hash_, ""
         else:
-            return False, "", format_error_message(await response.error_message)
+            return (
+                False,
+                "",
+                format_error_message(await response.error_message, subtensor.substrate),
+            )
 
     # Validate destination address.
     if not is_valid_bittensor_address_or_public_key(destination):
@@ -110,6 +118,7 @@ async def transfer_extrinsic(
     try:
         wallet.unlock_coldkey()
     except KeyFileError:
+        err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
     # Check balance.
@@ -121,7 +130,9 @@ async def transfer_extrinsic(
         print_verbose("Fetching existential and fee", status)
         block_hash = await subtensor.substrate.get_chain_head()
         account_balance_, existential_deposit = await asyncio.gather(
-            subtensor.get_balance(wallet.coldkeypub.ss58_address, block_hash=block_hash),
+            subtensor.get_balance(
+                wallet.coldkeypub.ss58_address, block_hash=block_hash
+            ),
             subtensor.get_existential_deposit(block_hash=block_hash),
         )
         account_balance = account_balance_[wallet.coldkeypub.ss58_address]
@@ -132,6 +143,12 @@ async def transfer_extrinsic(
         existential_deposit = Balance(0)
 
     # Check if we have enough balance.
+    if transfer_all is True:
+        amount = account_balance - fee - existential_deposit
+        if amount < Balance(0):
+            print_error("Not enough balance to transfer")
+            return False
+
     if account_balance < (amount + fee + existential_deposit):
         err_console.print(
             ":cross_mark: [bold red]Not enough balance[/bold red]:\n\n"
@@ -180,7 +197,7 @@ async def transfer_extrinsic(
             )
             console.print(
                 f"Balance:\n"
-                f"  [blue]{account_balance}[/blue] :arrow_right: [green]{new_balance[wallet.coldkey.ss58_address]}[/green]"
+                f"  [blue]{account_balance}[/blue] :arrow_right: [green]{new_balance[wallet.coldkeypub.ss58_address]}[/green]"
             )
             return True
 

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -111,18 +111,18 @@ class SubtensorInterface:
         return f"Network: {self.network}, Chain: {self.chain_endpoint}"
 
     async def __aenter__(self):
-        with console.status(
-            f"[yellow]Connecting to Substrate:[/yellow][bold white] {self}..."
-        ):
-            try:
+        try:
+            with console.status(
+                f"[yellow]Connecting to Substrate:[/yellow][bold white] {self}..."
+            ):
                 async with self.substrate:
                     return self
-            except TimeoutException:
-                err_console.print(
-                    "\n[red]Error[/red]: Timeout occurred connecting to substrate. "
-                    f"Verify your chain and network settings: {self}"
-                )
-                raise typer.Exit(code=1)
+        except TimeoutException:
+            err_console.print(
+                "\n[red]Error[/red]: Timeout occurred connecting to substrate. "
+                f"Verify your chain and network settings: {self}"
+            )
+            raise typer.Exit(code=1)
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await self.substrate.close()
@@ -283,7 +283,7 @@ class SubtensorInterface:
         self,
         runtime_api: str,
         method: str,
-        params: Optional[Union[list[list[int]], dict[str, int]]],
+        params: Optional[Union[list[list[int]], list[int], dict[str, int]]],
         block_hash: Optional[str] = None,
         reuse_block: Optional[bool] = False,
     ) -> Optional[str]:
@@ -927,9 +927,11 @@ class SubtensorInterface:
             if await response.is_success:
                 return True, ""
             else:
-                return False, format_error_message(await response.error_message)
+                return False, format_error_message(
+                    await response.error_message, substrate=self.substrate
+                )
         except SubstrateRequestException as e:
-            return False, e
+            return False, format_error_message(e, substrate=self.substrate)
 
     async def get_children(self, hotkey, netuid) -> tuple[bool, list, str]:
         """
@@ -959,7 +961,7 @@ class SubtensorInterface:
             else:
                 return True, [], ""
         except SubstrateRequestException as e:
-            return False, [], str(e)
+            return False, [], format_error_message(e, self.substrate)
 
     async def get_subnet_hyperparameters(
         self, netuid: int, block_hash: Optional[str] = None

bittensor_cli/src/bittensor/utils.py

@@ -1,3 +1,4 @@
+import ast
 import math
 import os
 import sqlite3
@@ -26,6 +27,9 @@ from bittensor_cli.src.bittensor.balances import Balance
 
 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)
@@ -439,7 +443,7 @@ def get_explorer_url_for_network(
         explorer_opentensor_url = "{root_url}/query/{block_hash}".format(
             root_url=explorer_root_urls.get("opentensor"), block_hash=block_hash
         )
-        explorer_taostats_url = "{root_url}/extrinsic/{block_hash}".format(
+        explorer_taostats_url = "{root_url}/hash/{block_hash}".format(
             root_url=explorer_root_urls.get("taostats"), block_hash=block_hash
         )
         explorer_urls["opentensor"] = explorer_opentensor_url
@@ -448,24 +452,87 @@ def get_explorer_url_for_network(
     return explorer_urls
 
 
-def format_error_message(error_message: dict) -> str:
+def format_error_message(
+    error_message: Union[dict, Exception], substrate: "AsyncSubstrateInterface"
+) -> str:
     """
-    Formats an error message from the Subtensor error information to using in extrinsics.
+    Formats an error message from the Subtensor error information for use in extrinsics.
 
-    :param error_message: A dictionary containing the error information from Subtensor.
+    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.
 
-    :return: A formatted error message string.
+    Returns:
+        str: A formatted error message string.
     """
-    err_type = "UnknownType"
     err_name = "UnknownError"
+    err_type = "UnknownType"
     err_description = "Unknown Description"
 
+    if isinstance(error_message, Exception):
+        # generally gotten through SubstrateRequestException args
+        new_error_message = None
+        for arg in error_message.args:
+            try:
+                d = ast.literal_eval(arg)
+                if isinstance(d, dict):
+                    if "error" in d:
+                        new_error_message = d["error"]
+                        break
+                    elif all(x in d for x in ["code", "message", "data"]):
+                        new_error_message = d
+                        break
+            except ValueError:
+                pass
+        if new_error_message is None:
+            return_val = " ".join(error_message.args)
+            return f"Subtensor returned: {return_val}"
+        else:
+            error_message = new_error_message
+
     if isinstance(error_message, dict):
-        err_type = error_message.get("type", err_type)
-        err_name = error_message.get("name", err_name)
-        err_docs = error_message.get("docs", [])
-        err_description = err_docs[0] if len(err_docs) > 0 else err_description
-    return f"Subtensor returned `{err_name} ({err_type})` error. This means: `{err_description}`"
+        # subtensor error structure
+        if (
+            error_message.get("code")
+            and error_message.get("message")
+            and error_message.get("data")
+        ):
+            err_name = "SubstrateRequestException"
+            err_type = error_message.get("message", "")
+            err_data = error_message.get("data", "")
+
+            # subtensor custom error marker
+            if err_data.startswith("Custom error:") and substrate:
+                if substrate.metadata:
+                    try:
+                        pallet = substrate.metadata.get_metadata_pallet(
+                            "SubtensorModule"
+                        )
+                        error_index = int(err_data.split("Custom error:")[-1])
+
+                        error_dict = pallet.errors[error_index].value
+                        err_type = error_dict.get("message", err_type)
+                        err_docs = error_dict.get("docs", [])
+                        err_description = err_docs[0] if err_docs else err_description
+                    except (AttributeError, IndexError):
+                        err_console.print(
+                            "Substrate pallets data unavailable. This is usually caused by an uninitialized substrate."
+                        )
+            else:
+                err_description = err_data
+
+        elif (
+            error_message.get("type")
+            and error_message.get("name")
+            and error_message.get("docs")
+        ):
+            err_type = error_message.get("type", err_type)
+            err_name = error_message.get("name", err_name)
+            err_docs = error_message.get("docs", [err_description])
+            err_description = err_docs[0] if err_docs else err_description
+
+    return f"Subtensor returned `{err_name}({err_type})` error. This means: '{err_description}'."
 
 
 def convert_blocks_to_time(blocks: int, block_time: int = 12) -> tuple[int, int, int]:
@@ -877,8 +944,6 @@ def validate_chain_endpoint(endpoint_url) -> tuple[bool, str]:
         )
     if not parsed.netloc:
         return False, "Invalid URL passed as the endpoint"
-    if not parsed.port:
-        return False, "No port specified in the URL"
     return True, ""