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

bittensor_cli/src/__init__.py

@@ -4,12 +4,23 @@ from typing import Any, Optional
 
 
 class Constants:
-    networks = ["local", "finney", "test", "archive", "rao", "dev", "latent-lite"]
+    networks = [
+        "local",
+        "finney",
+        "test",
+        "archive",
+        "subvortex",
+        "rao",
+        "dev",
+        "latent-lite",
+    ]
     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"
+    subvortex_entrypoint = "ws://subvortex.info:9944"
+    local_entrypoint = "ws://127.0.0.1:9944"
     rao_entrypoint = "wss://rao.chain.opentensor.ai:443"
-    dev_entrypoint = "wss://dev.chain.opentensor.ai:443 "
+    dev_entrypoint = "wss://dev.chain.opentensor.ai:443"
     local_entrypoint = "ws://127.0.0.1:9944"
     latent_lite_entrypoint = "wss://lite.sub.latent.to:443"
     network_map = {
@@ -20,6 +31,7 @@ class Constants:
         "dev": dev_entrypoint,
         "rao": rao_entrypoint,
         "latent-lite": latent_lite_entrypoint,
+        "subvortex": subvortex_entrypoint,
     }
     delegates_detail_url = "https://raw.githubusercontent.com/opentensor/bittensor-delegates/main/public/delegates.json"
 
@@ -100,7 +112,7 @@ class Defaults:
         }
 
     class subtensor:
-        network = "test"
+        network = "finney"
         chain_endpoint = None
         _mock = False
 
@@ -631,28 +643,40 @@ NETWORK_EXPLORER_MAP = {
 
 
 HYPERPARAMS = {
-    "serving_rate_limit": "sudo_set_serving_rate_limit",
-    "min_difficulty": "sudo_set_min_difficulty",
-    "max_difficulty": "sudo_set_max_difficulty",
-    "weights_version": "sudo_set_weights_version_key",
-    "weights_rate_limit": "sudo_set_weights_set_rate_limit",
-    "max_weights_limit": "sudo_set_max_weight_limit",
-    "immunity_period": "sudo_set_immunity_period",
-    "min_allowed_weights": "sudo_set_min_allowed_weights",
-    "activity_cutoff": "sudo_set_activity_cutoff",
-    "network_registration_allowed": "sudo_set_network_registration_allowed",
-    "network_pow_registration_allowed": "sudo_set_network_pow_registration_allowed",
-    "min_burn": "sudo_set_min_burn",
-    "max_burn": "sudo_set_max_burn",
-    "adjustment_alpha": "sudo_set_adjustment_alpha",
-    "rho": "sudo_set_rho",
-    "kappa": "sudo_set_kappa",
-    "difficulty": "sudo_set_difficulty",
-    "bonds_moving_avg": "sudo_set_bonds_moving_average",
-    "commit_reveal_period": "sudo_set_commit_reveal_weights_interval",
-    "commit_reveal_weights_enabled": "sudo_set_commit_reveal_weights_enabled",
-    "alpha_values": "sudo_set_alpha_values",
-    "liquid_alpha_enabled": "sudo_set_liquid_alpha_enabled",
+    # btcli name: (subtensor method, root-only bool)
+    "rho": ("sudo_set_rho", False),
+    "kappa": ("sudo_set_kappa", False),
+    "immunity_period": ("sudo_set_immunity_period", False),
+    "min_allowed_weights": ("sudo_set_min_allowed_weights", False),
+    "max_weights_limit": ("sudo_set_max_weight_limit", False),
+    "tempo": ("sudo_set_tempo", True),
+    "min_difficulty": ("sudo_set_min_difficulty", False),
+    "max_difficulty": ("sudo_set_max_difficulty", False),
+    "weights_version": ("sudo_set_weights_version_key", False),
+    "weights_rate_limit": ("sudo_set_weights_set_rate_limit", False),
+    "adjustment_interval": ("sudo_set_adjustment_interval", True),
+    "activity_cutoff": ("sudo_set_activity_cutoff", False),
+    "target_regs_per_interval": ("sudo_set_target_registrations_per_interval", True),
+    "min_burn": ("sudo_set_min_burn", True),
+    "max_burn": ("sudo_set_max_burn", False),
+    "bonds_moving_avg": ("sudo_set_bonds_moving_average", False),
+    "max_regs_per_block": ("sudo_set_max_registrations_per_block", True),
+    "serving_rate_limit": ("sudo_set_serving_rate_limit", False),
+    "max_validators": ("sudo_set_max_allowed_validators", True),
+    "adjustment_alpha": ("sudo_set_adjustment_alpha", False),
+    "difficulty": ("sudo_set_difficulty", False),
+    "commit_reveal_period": (
+        "sudo_set_commit_reveal_weights_interval",
+        False,
+    ),
+    "commit_reveal_weights_enabled": ("sudo_set_commit_reveal_weights_enabled", False),
+    "alpha_values": ("sudo_set_alpha_values", False),
+    "liquid_alpha_enabled": ("sudo_set_liquid_alpha_enabled", False),
+    "network_registration_allowed": ("sudo_set_network_registration_allowed", False),
+    "network_pow_registration_allowed": (
+        "sudo_set_network_pow_registration_allowed",
+        False,
+    ),
 }
 
 # Help Panels for cli help
@@ -686,6 +710,7 @@ HELP_PANELS = {
         "INFO": "Subnet Information",
         "CREATION": "Subnet Creation & Management",
         "REGISTER": "Neuron Registration",
+        "IDENTITY": "Subnet Identity Management",
     },
     "WEIGHTS": {"COMMIT_REVEAL": "Commit / Reveal"},
 }

bittensor_cli/src/bittensor/chain_data.py

@@ -750,7 +750,9 @@ class DynamicInfo(InfoBase):
         )
         return alpha_returned, slippage, slippage_pct_float
 
-    def alpha_to_tao_with_slippage(self, alpha: Balance) -> tuple[Balance, Balance]:
+    def alpha_to_tao_with_slippage(
+        self, alpha: Balance
+    ) -> tuple[Balance, Balance, float]:
         """
         Returns an estimate of how much TAO would a staker receive if they unstake their alpha using the current pool state.
         Args:

bittensor_cli/src/bittensor/extrinsics/registration.py

@@ -18,9 +18,7 @@ import typing
 from typing import Optional
 import subprocess
 
-import backoff
 from bittensor_wallet import Wallet
-from bittensor_wallet.errors import KeyFileError
 from Crypto.Hash import keccak
 import numpy as np
 from rich.prompt import Confirm
@@ -39,6 +37,8 @@ from bittensor_cli.src.bittensor.utils import (
     get_human_readable,
     print_verbose,
     print_error,
+    unlock_key,
+    hex_to_bytes,
 )
 
 if typing.TYPE_CHECKING:
@@ -616,10 +616,7 @@ async def register_extrinsic(
                         if not success:
                             success, err_msg = (
                                 False,
-                                format_error_message(
-                                    await response.error_message,
-                                    substrate=subtensor.substrate,
-                                ),
+                                format_error_message(await response.error_message),
                             )
                             # Look error here
                             # https://github.com/opentensor/subtensor/blob/development/pallets/subtensor/src/errors.rs
@@ -697,11 +694,8 @@ async def burned_register_extrinsic(
              finalization/inclusion, the response is `True`.
     """
 
-    try:
-        wallet.unlock_coldkey()
-    except KeyFileError:
-        err_console.print("Error decrypting coldkey (possibly incorrect password)")
-        return False
+    if not (unlock_status := unlock_key(wallet, print_out=False)).success:
+        return False, unlock_status.message
 
     with console.status(
         f":satellite: Checking Account on [bold]subnet:{netuid}[/bold]...",
@@ -796,7 +790,7 @@ async def run_faucet_extrinsic(
     tpb: int = 256,
     num_processes: Optional[int] = None,
     update_interval: Optional[int] = None,
-    log_verbose: bool = False,
+    log_verbose: bool = True,
     max_successes: int = 3,
 ) -> tuple[bool, str]:
     r"""Runs a continual POW to get a faucet of TAO on the test net.
@@ -835,10 +829,8 @@ async def run_faucet_extrinsic(
         return False, "Requires torch"
 
     # Unlock coldkey
-    try:
-        wallet.unlock_coldkey()
-    except KeyFileError:
-        return False, "There was an error unlocking your coldkey"
+    if not (unlock_status := unlock_key(wallet, print_out=False)).success:
+        return False, unlock_status.message
 
     # Get previous balance.
     old_balance = await subtensor.get_balance(wallet.coldkeypub.ss58_address)
@@ -846,8 +838,12 @@ async def run_faucet_extrinsic(
     # Attempt rolling registration.
     attempts = 1
     successes = 1
+    pow_result: Optional[POWSolution]
     while True:
         try:
+            account_nonce = await subtensor.substrate.get_account_nonce(
+                wallet.coldkey.ss58_address
+            )
             pow_result = None
             while pow_result is None or await pow_result.is_stale(subtensor=subtensor):
                 # Solve latest POW.
@@ -856,7 +852,7 @@ async def run_faucet_extrinsic(
                         if prompt:
                             err_console.print("CUDA is not available.")
                         return False, "CUDA is not available."
-                    pow_result: Optional[POWSolution] = await create_pow(
+                    pow_result = await create_pow(
                         subtensor,
                         wallet,
                         -1,
@@ -869,7 +865,7 @@ async def run_faucet_extrinsic(
                         log_verbose=log_verbose,
                     )
                 else:
-                    pow_result: Optional[POWSolution] = await create_pow(
+                    pow_result = await create_pow(
                         subtensor,
                         wallet,
                         -1,
@@ -889,7 +885,7 @@ async def run_faucet_extrinsic(
                 },
             )
             extrinsic = await subtensor.substrate.create_signed_extrinsic(
-                call=call, keypair=wallet.coldkey
+                call=call, keypair=wallet.coldkey, nonce=account_nonce
             )
             response = await subtensor.substrate.submit_extrinsic(
                 extrinsic,
@@ -902,7 +898,7 @@ async def run_faucet_extrinsic(
             if not await response.is_success:
                 err_console.print(
                     f":cross_mark: [red]Failed[/red]: "
-                    f"{format_error_message(await response.error_message, subtensor.substrate)}"
+                    f"{format_error_message(await response.error_message)}"
                 )
                 if attempts == max_allowed_attempts:
                     raise MaxAttemptsException
@@ -974,7 +970,7 @@ async def _check_for_newest_block_and_update(
         block_number, difficulty, block_hash = await _get_block_with_retry(
             subtensor=subtensor, netuid=netuid
         )
-        block_bytes = bytes.fromhex(block_hash[2:])
+        block_bytes = hex_to_bytes(block_hash)
 
         update_curr_block(
             curr_diff,
@@ -1027,6 +1023,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()
 
@@ -1036,7 +1035,6 @@ async def _block_solver(
 
     if cuda:
         # Create a worker per CUDA device
-        num_processes = len(dev_id)
         solvers = [
             _CUDASolver(
                 i,
@@ -1079,7 +1077,7 @@ async def _block_solver(
         subtensor=subtensor, netuid=netuid
     )
 
-    block_bytes = bytes.fromhex(block_hash[2:])
+    block_bytes = hex_to_bytes(block_hash)
     old_block_number = block_number
     # Set to current block
     _update_curr_block(
@@ -1354,11 +1352,9 @@ def _terminate_workers_and_wait_for_exit(
             worker.terminate()
 
 
-# TODO verify this works with async
-@backoff.on_exception(backoff.constant, Exception, interval=1, max_tries=3)
 async def _get_block_with_retry(
     subtensor: "SubtensorInterface", netuid: int
-) -> tuple[int, int, bytes]:
+) -> tuple[int, int, str]:
     """
     Gets the current block number, difficulty, and block hash from the substrate node.
 
@@ -1370,10 +1366,9 @@ async def _get_block_with_retry(
     :raises Exception: If the block hash is None.
     :raises ValueError: If the difficulty is None.
     """
-    block_number = await subtensor.substrate.get_block_number(None)
-    block_hash = await subtensor.substrate.get_block_hash(
-        block_number
-    )  # TODO check if I need to do all this
+    block = await subtensor.substrate.get_block()
+    block_hash = block["header"]["hash"]
+    block_number = block["header"]["number"]
     try:
         difficulty = (
             1_000_000
@@ -1746,10 +1741,7 @@ async def swap_hotkey_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
 
     if prompt:

bittensor_cli/src/bittensor/extrinsics/root.py

@@ -21,7 +21,6 @@ import time
 from typing import Union, List, TYPE_CHECKING
 
 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
@@ -37,6 +36,7 @@ from bittensor_cli.src.bittensor.utils import (
     u16_normalized_float,
     print_verbose,
     format_error_message,
+    unlock_key,
 )
 
 if TYPE_CHECKING:
@@ -306,10 +306,7 @@ async def root_register_extrinsic(
              the response is `True`.
     """
 
-    try:
-        wallet.unlock_coldkey()
-    except KeyFileError:
-        err_console.print("Error decrypting coldkey (possibly incorrect password)")
+    if not unlock_key(wallet).success:
         return False
 
     print_verbose(f"Checking if hotkey ({wallet.hotkey_str}) is registered on root")
@@ -427,10 +424,7 @@ async def set_root_weights_extrinsic(
         err_console.print("Your hotkey is not registered to the root network")
         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
 
     # First convert types.
@@ -492,11 +486,11 @@ async def set_root_weights_extrinsic(
                 console.print(":white_heavy_check_mark: [green]Finalized[/green]")
                 return True
             else:
-                fmt_err = format_error_message(error_message, subtensor.substrate)
+                fmt_err = format_error_message(error_message)
                 err_console.print(f":cross_mark: [red]Failed[/red]: {fmt_err}")
                 return False
 
     except SubstrateRequestException as e:
-        fmt_err = format_error_message(e, subtensor.substrate)
+        fmt_err = format_error_message(e)
         err_console.print(":cross_mark: [red]Failed[/red]: error:{}".format(fmt_err))
         return False

bittensor_cli/src/bittensor/extrinsics/transfer.py

@@ -1,7 +1,6 @@
 import asyncio
 
 from bittensor_wallet import Wallet
-from bittensor_wallet.errors import KeyFileError
 from rich.prompt import Confirm
 from async_substrate_interface.errors import SubstrateRequestException
 
@@ -15,6 +14,8 @@ from bittensor_cli.src.bittensor.utils import (
     format_error_message,
     get_explorer_url_for_network,
     is_valid_bittensor_address_or_public_key,
+    print_error,
+    unlock_key,
 )
 
 
@@ -23,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,
@@ -34,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
@@ -63,9 +66,9 @@ async def transfer_extrinsic(
         except SubstrateRequestException as e:
             payment_info = {"partial_fee": int(2e7)}  # assume  0.02 Tao
             err_console.print(
-                f":cross_mark: [red]Failed to get payment info[/red]:\n"
-                f"  [bold white]{format_error_message(e)}[/bold white]\n"
-                f"  Defaulting to default transfer fee: {payment_info['partial_fee']}"
+                f":cross_mark: [red]Failed to get payment info[/red]:[bold white]\n"
+                f"  {format_error_message(e)}[/bold white]\n"
+                f"  Defaulting to default transfer fee: {payment_info['partialFee']}"
             )
 
         return Balance.from_rao(payment_info["partial_fee"])
@@ -98,11 +101,7 @@ async def transfer_extrinsic(
             block_hash_ = response.block_hash
             return True, block_hash_, ""
         else:
-            return (
-                False,
-                "",
-                format_error_message(await response.error_message, subtensor.substrate),
-            )
+            return False, "", format_error_message(await response.error_message)
 
     # Validate destination address.
     if not is_valid_bittensor_address_or_public_key(destination):
@@ -112,10 +111,7 @@ async def transfer_extrinsic(
         return False
     console.print(f"[dark_orange]Initiating transfer on network: {subtensor.network}")
     # Unlock wallet coldkey.
-    try:
-        wallet.unlock_coldkey()
-    except KeyFileError:
-        err_console.print("Error decrypting coldkey (possibly incorrect password)")
+    if not unlock_key(wallet).success:
         return False
 
     # Check balance.
@@ -139,6 +135,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"

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -402,7 +402,7 @@ class SubtensorInterface:
         netuids: Optional[list[int]] = None,
         block_hash: Optional[str] = None,
         reuse_block: bool = False,
-    ) -> dict[str, dict[int, "Balance"]]:
+    ) -> dict[str, dict[int, Balance]]:
         """
         Returns the total stake held on a hotkey.
 
@@ -1064,11 +1064,9 @@ class SubtensorInterface:
             if await response.is_success:
                 return True, ""
             else:
-                return False, format_error_message(
-                    await response.error_message, substrate=self.substrate
-                )
+                return False, format_error_message(await response.error_message)
         except SubstrateRequestException as e:
-            return False, format_error_message(e, substrate=self.substrate)
+            return False, format_error_message(e)
 
     async def get_children(self, hotkey, netuid) -> tuple[bool, list, str]:
         """
@@ -1098,7 +1096,7 @@ class SubtensorInterface:
             else:
                 return True, [], ""
         except SubstrateRequestException as e:
-            return False, [], format_error_message(e, self.substrate)
+            return False, [], format_error_message(e)
 
     async def get_subnet_hyperparameters(
         self, netuid: int, block_hash: Optional[str] = None