bittensor-cli 9.5.1__tar.gz → 9.7.0__tar.gz

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bittensor-cli
-Version: 9.5.1
+Version: 9.7.0
 Summary: Bittensor CLI
 Author: bittensor.com
 Project-URL: homepage, https://github.com/opentensor/btcli
@@ -71,10 +71,10 @@ Installation steps are described below. For a full documentation on how to use `
 
 ## Install on macOS and Linux
 
-You can install `btcli` on your local machine directly from source, or from PyPI. **Make sure you verify your installation after you install**:
+You can install `btcli` on your local machine directly from source, PyPI, or Homebrew. **Make sure you verify your installation after you install**:
 
 
-### Install from PyPI
+### Install from [PyPI](https://pypi.org/project/bittensor/)
 
 Run 
 ```
@@ -86,6 +86,12 @@ Alternatively, if you prefer to use [uv](https://pypi.org/project/uv/):
 uv pip install bittensor-cli
 ```
 
+### Install from [Homebrew](https://formulae.brew.sh/formula/btcli#default)
+
+```shell
+brew install btcli
+```
+
 ### Install from source
 
 1. Create and activate a virtual environment.

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/README.md

@@ -38,10 +38,10 @@ Installation steps are described below. For a full documentation on how to use `
 
 ## Install on macOS and Linux
 
-You can install `btcli` on your local machine directly from source, or from PyPI. **Make sure you verify your installation after you install**:
+You can install `btcli` on your local machine directly from source, PyPI, or Homebrew. **Make sure you verify your installation after you install**:
 
 
-### Install from PyPI
+### Install from [PyPI](https://pypi.org/project/bittensor/)
 
 Run 
 ```
@@ -53,6 +53,12 @@ Alternatively, if you prefer to use [uv](https://pypi.org/project/uv/):
 uv pip install bittensor-cli
 ```
 
+### Install from [Homebrew](https://formulae.brew.sh/formula/btcli#default)
+
+```shell
+brew install btcli
+```
+
 ### Install from source
 
 1. Create and activate a virtual environment.

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli/cli.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 import asyncio
 import curses
+import copy
 import importlib
 import json
 import os.path
@@ -10,7 +11,7 @@ import sys
 import traceback
 import warnings
 from pathlib import Path
-from typing import Coroutine, Optional
+from typing import Coroutine, Optional, Union
 from dataclasses import fields
 
 import rich
@@ -89,6 +90,23 @@ class Options:
     Re-usable typer args
     """
 
+    @classmethod
+    def edit_help(cls, option_name: str, help_text: str):
+        """
+        Edits the `help` attribute of a copied given Typer option in this class, returning
+        the modified Typer option.
+
+        Args:
+            option_name: the name of the option (e.g. "wallet_name")
+            help_text: New help text to be used (e.g. "Wallet's name")
+
+        Returns:
+            Modified Typer Option with new help text.
+        """
+        copied_attr = copy.copy(getattr(cls, option_name))
+        setattr(copied_attr, "help", help_text)
+        return copied_attr
+
     wallet_name = typer.Option(
         None,
         "--wallet-name",
@@ -1879,6 +1897,8 @@ class CLIManager:
         wallet_name: Optional[str] = Options.wallet_name,
         wallet_path: Optional[str] = Options.wallet_path,
         wallet_hotkey: Optional[str] = Options.wallet_hotkey,
+        netuid: Optional[int] = Options.netuid_not_req,
+        all_netuids: bool = Options.all_netuids,
         network: Optional[list[str]] = Options.network,
         destination_hotkey_name: Optional[str] = typer.Argument(
             None, help="Destination hotkey name."
@@ -1899,12 +1919,14 @@ class CLIManager:
 
         - Make sure that your original key pair (coldkeyA, hotkeyA) is already registered.
         - Make sure that you use a newly created hotkeyB in this command. A hotkeyB that is already registered cannot be used in this command.
+        - You can specify the netuid for which you want to swap the hotkey for. If it is not defined, the swap will be initiated for all subnets.
         - Finally, note that this command requires a fee of 1 TAO for recycling and this fee is taken from your wallet (coldkeyA).
 
         EXAMPLE
 
-        [green]$[/green] btcli wallet swap_hotkey destination_hotkey_name --wallet-name your_wallet_name --wallet-hotkey original_hotkey
+        [green]$[/green] btcli wallet swap_hotkey destination_hotkey_name --wallet-name your_wallet_name --wallet-hotkey original_hotkey --netuid 1
         """
+        netuid = get_optional_netuid(netuid, all_netuids)
         self.verbosity_handler(quiet, verbose, json_output)
         original_wallet = self.wallet_ask(
             wallet_name,
@@ -1928,7 +1950,7 @@ class CLIManager:
         self.initialize_chain(network)
         return self._run_command(
             wallets.swap_hotkey(
-                original_wallet, new_wallet, self.subtensor, prompt, json_output
+                original_wallet, new_wallet, self.subtensor, netuid, prompt, json_output
             )
         )
 
@@ -3202,7 +3224,11 @@ class CLIManager:
             help="When set, this command stakes to all hotkeys associated with the wallet. Do not use if specifying "
             "hotkeys in `--include-hotkeys`.",
         ),
-        netuid: Optional[int] = Options.netuid_not_req,
+        netuids: Optional[str] = Options.edit_help(
+            "netuids",
+            "Netuid(s) to for which to add stake. Specify multiple netuids by separating with a comma, e.g."
+            "`btcli st add -n 1,2,3",
+        ),
         all_netuids: bool = Options.all_netuids,
         wallet_name: str = Options.wallet_name,
         wallet_path: str = Options.wallet_path,
@@ -3242,42 +3268,65 @@ class CLIManager:
         6. Stake all balance to a subnet:
             [green]$[/green] btcli stake add --all --netuid 3
 
+        7. Stake the same amount to multiple subnets:
+            [green]$[/green] btcli stake add --amount 100 --netuids 4,5,6
+
         [bold]Safe Staking Parameters:[/bold]
         • [blue]--safe[/blue]: Enables rate tolerance checks
         • [blue]--tolerance[/blue]: Maximum % rate change allowed (0.05 = 5%)
         • [blue]--partial[/blue]: Complete partial stake if rates exceed tolerance
 
         """
+        netuids = netuids or []
         self.verbosity_handler(quiet, verbose, json_output)
         safe_staking = self.ask_safe_staking(safe_staking)
         if safe_staking:
             rate_tolerance = self.ask_rate_tolerance(rate_tolerance)
             allow_partial_stake = self.ask_partial_stake(allow_partial_stake)
             console.print("\n")
-        netuid = get_optional_netuid(netuid, all_netuids)
+
+        if netuids:
+            netuids = parse_to_list(
+                netuids, int, "Netuids must be ints separated by commas", False
+            )
+        else:
+            netuid_ = get_optional_netuid(None, all_netuids)
+            netuids = [netuid_] if netuid_ else None
+        if netuids:
+            for netuid_ in netuids:
+                # ensure no negative netuids make it into our list
+                validate_netuid(netuid_)
 
         if stake_all and amount:
             print_error(
                 "Cannot specify an amount and 'stake-all'. Choose one or the other."
             )
-            raise typer.Exit()
+            return
 
         if stake_all and not amount:
             if not Confirm.ask("Stake all the available TAO tokens?", default=False):
-                raise typer.Exit()
+                return
+
+        if (
+            stake_all
+            and (isinstance(netuids, list) and len(netuids) > 1)
+            or (netuids is None)
+        ):
+            print_error("Cannot stake all to multiple subnets.")
+            return
 
         if all_hotkeys and include_hotkeys:
             print_error(
                 "You have specified hotkeys to include and also the `--all-hotkeys` flag. The flag"
                 "should only be used standalone (to use all hotkeys) or with `--exclude-hotkeys`."
             )
-            raise typer.Exit()
+            return
 
         if include_hotkeys and exclude_hotkeys:
             print_error(
                 "You have specified options for both including and excluding hotkeys. Select one or the other."
             )
-            raise typer.Exit()
+            return
 
         if not wallet_hotkey and not all_hotkeys and not include_hotkeys:
             if not wallet_name:
@@ -3285,9 +3334,10 @@ class CLIManager:
                     "Enter the [blue]wallet name[/blue]",
                     default=self.config.get("wallet_name") or defaults.wallet.name,
                 )
-            if netuid is not None:
+            if netuids is not None:
                 hotkey_or_ss58 = Prompt.ask(
-                    "Enter the [blue]wallet hotkey[/blue] name or [blue]ss58 address[/blue] to stake to [dim](or Press Enter to view delegates)[/dim]",
+                    "Enter the [blue]wallet hotkey[/blue] name or [blue]ss58 address[/blue] to stake to [dim]"
+                    "(or Press Enter to view delegates)[/dim]",
                 )
             else:
                 hotkey_or_ss58 = Prompt.ask(
@@ -3299,10 +3349,18 @@ class CLIManager:
                 wallet = self.wallet_ask(
                     wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
                 )
+                if len(netuids) > 1:
+                    netuid_ = IntPrompt.ask(
+                        "Enter the netuid for which to show delegates",
+                        choices=[str(x) for x in netuids],
+                    )
+                else:
+                    netuid_ = netuids[0]
+
                 selected_hotkey = self._run_command(
                     subnets.show(
                         subtensor=self.initialize_chain(network),
-                        netuid=netuid,
+                        netuid=netuid_,
                         sort=False,
                         max_rows=12,
                         prompt=False,
@@ -3312,7 +3370,7 @@ class CLIManager:
                 )
                 if not selected_hotkey:
                     print_error("No delegate selected. Exiting.")
-                    raise typer.Exit()
+                    return
                 include_hotkeys = selected_hotkey
             elif is_valid_ss58_address(hotkey_or_ss58):
                 wallet = self.wallet_ask(
@@ -3373,8 +3431,8 @@ class CLIManager:
             )
             if free_balance == Balance.from_tao(0):
                 print_error("You dont have any balance to stake.")
-                raise typer.Exit()
-            if netuid is not None:
+                return
+            if netuids:
                 amount = FloatPrompt.ask(
                     f"Amount to [{COLORS.G.SUBHEAD_MAIN}]stake (TAO τ)"
                 )
@@ -3396,7 +3454,7 @@ class CLIManager:
             add_stake.stake_add(
                 wallet,
                 self.initialize_chain(network),
-                netuid,
+                netuids,
                 stake_all,
                 amount,
                 prompt,
@@ -4796,12 +4854,9 @@ class CLIManager:
     def subnets_price(
         self,
         network: Optional[list[str]] = Options.network,
-        netuids: str = typer.Option(
-            None,
-            "--netuids",
-            "--netuid",
-            "-n",
-            help="Netuid(s) to show the price for.",
+        netuids: str = Options.edit_help(
+            "netuids",
+            "Netuids to show the price for. Separate multiple netuids with a comma, for example: `-n 0,1,2`.",
         ),
         interval_hours: int = typer.Option(
             24,

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli/src/__init__.py

@@ -658,6 +658,8 @@ HYPERPARAMS = {
         "sudo_set_network_pow_registration_allowed",
         False,
     ),
+    "yuma3_enabled": ("sudo_set_yuma3_enabled", False),
+    "alpha_sigmoid_steepness": ("sudo_set_alpha_sigmoid_steepness", True),
 }
 
 # Help Panels for cli help

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli/src/bittensor/chain_data.py

@@ -177,6 +177,8 @@ class SubnetHyperparameters(InfoBase):
     alpha_high: int
     alpha_low: int
     liquid_alpha_enabled: bool
+    yuma3_enabled: bool
+    alpha_sigmoid_steepness: int
 
     @classmethod
     def _fix_decoded(
@@ -210,6 +212,8 @@ class SubnetHyperparameters(InfoBase):
             alpha_high=decoded.get("alpha_high"),
             alpha_low=decoded.get("alpha_low"),
             liquid_alpha_enabled=decoded.get("liquid_alpha_enabled"),
+            yuma3_enabled=decoded.get("yuma3_enabled"),
+            alpha_sigmoid_steepness=decoded.get("alpha_sigmoid_steepness"),
         )
 
 

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli/src/bittensor/extrinsics/registration.py

@@ -1611,7 +1611,8 @@ def _update_curr_block(
     """
     Update the current block data with the provided block information and difficulty.
 
-    This function updates the current block and its difficulty in a thread-safe manner. It sets the current block
+    This function updates the current block
+    and its difficulty in a thread-safe manner. It sets the current block
     number, hashes the block with the hotkey, updates the current block bytes, and packs the difficulty.
 
     :param curr_diff: Shared array to store the current difficulty.
@@ -1745,6 +1746,7 @@ async def swap_hotkey_extrinsic(
     subtensor: "SubtensorInterface",
     wallet: Wallet,
     new_wallet: Wallet,
+    netuid: Optional[int] = None,
     prompt: bool = False,
 ) -> bool:
     """
@@ -1756,43 +1758,81 @@ async def swap_hotkey_extrinsic(
     netuids_registered = await subtensor.get_netuids_for_hotkey(
         wallet.hotkey.ss58_address, block_hash=block_hash
     )
-    if not len(netuids_registered) > 0:
+    netuids_registered_new_hotkey = await subtensor.get_netuids_for_hotkey(
+        new_wallet.hotkey.ss58_address, block_hash=block_hash
+    )
+
+    if netuid is not None and netuid not in netuids_registered:
+        err_console.print(
+            f":cross_mark: [red]Failed[/red]: Original hotkey {wallet.hotkey.ss58_address} is not registered on subnet {netuid}"
+        )
+        return False
+
+    elif not len(netuids_registered) > 0:
         err_console.print(
-            f"Destination hotkey [dark_orange]{new_wallet.hotkey.ss58_address}[/dark_orange] is not registered. "
+            f"Original hotkey [dark_orange]{wallet.hotkey.ss58_address}[/dark_orange] is not registered on any subnet. "
             f"Please register and try again"
         )
         return False
 
+    if netuid is not None:
+        if netuid in netuids_registered_new_hotkey:
+            err_console.print(
+                f":cross_mark: [red]Failed[/red]: New hotkey {new_wallet.hotkey.ss58_address} "
+                f"is already registered on subnet {netuid}"
+            )
+            return False
+    else:
+        if len(netuids_registered_new_hotkey) > 0:
+            err_console.print(
+                f":cross_mark: [red]Failed[/red]: New hotkey {new_wallet.hotkey.ss58_address} "
+                f"is already registered on subnet(s) {netuids_registered_new_hotkey}"
+            )
+            return False
+
     if not unlock_key(wallet).success:
         return False
 
     if prompt:
         # Prompt user for confirmation.
-        if not Confirm.ask(
-            f"Do you want to swap [dark_orange]{wallet.name}[/dark_orange] hotkey \n\t"
-            f"[dark_orange]{wallet.hotkey.ss58_address}[/dark_orange] with hotkey \n\t"
-            f"[dark_orange]{new_wallet.hotkey.ss58_address}[/dark_orange]\n"
-            "This operation will cost [bold cyan]1 TAO t (recycled)[/bold cyan]"
-        ):
+        if netuid is not None:
+            confirm_message = (
+                f"Do you want to swap [dark_orange]{wallet.name}[/dark_orange] hotkey \n\t"
+                f"[dark_orange]{wallet.hotkey.ss58_address} ({wallet.hotkey_str})[/dark_orange] with hotkey \n\t"
+                f"[dark_orange]{new_wallet.hotkey.ss58_address} ({new_wallet.hotkey_str})[/dark_orange] on subnet {netuid}\n"
+                "This operation will cost [bold cyan]1 TAO (recycled)[/bold cyan]"
+            )
+        else:
+            confirm_message = (
+                f"Do you want to swap [dark_orange]{wallet.name}[/dark_orange] hotkey \n\t"
+                f"[dark_orange]{wallet.hotkey.ss58_address} ({wallet.hotkey_str})[/dark_orange] with hotkey \n\t"
+                f"[dark_orange]{new_wallet.hotkey.ss58_address} ({new_wallet.hotkey_str})[/dark_orange] on all subnets\n"
+                "This operation will cost [bold cyan]1 TAO (recycled)[/bold cyan]"
+            )
+
+        if not Confirm.ask(confirm_message):
             return False
     print_verbose(
-        f"Swapping {wallet.name}'s hotkey ({wallet.hotkey.ss58_address}) with "
-        f"{new_wallet.name}s hotkey ({new_wallet.hotkey.ss58_address})"
+        f"Swapping {wallet.name}'s hotkey ({wallet.hotkey.ss58_address} - {wallet.hotkey_str}) with "
+        f"{new_wallet.name}'s hotkey ({new_wallet.hotkey.ss58_address} - {new_wallet.hotkey_str})"
     )
     with console.status(":satellite: Swapping hotkeys...", spinner="aesthetic"):
+        call_params = {
+            "hotkey": wallet.hotkey.ss58_address,
+            "new_hotkey": new_wallet.hotkey.ss58_address,
+            "netuid": netuid,
+        }
+
         call = await subtensor.substrate.compose_call(
             call_module="SubtensorModule",
             call_function="swap_hotkey",
-            call_params={
-                "hotkey": wallet.hotkey.ss58_address,
-                "new_hotkey": new_wallet.hotkey.ss58_address,
-            },
+            call_params=call_params,
         )
         success, err_msg = await subtensor.sign_and_send_extrinsic(call, wallet)
 
         if success:
             console.print(
-                f"Hotkey {wallet.hotkey} swapped for new hotkey: {new_wallet.hotkey}"
+                f"Hotkey {wallet.hotkey.ss58_address} ({wallet.hotkey_str}) swapped for new hotkey: {new_wallet.hotkey.ss58_address} ({new_wallet.hotkey_str})"
             )
             return True
         else:

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli/src/bittensor/subtensor_interface.py

@@ -1128,14 +1128,22 @@ class SubtensorInterface:
         Understanding the hyperparameters is crucial for comprehending how subnets are configured and
         managed, and how they interact with the network's consensus and incentive mechanisms.
         """
-        result = await self.query_runtime_api(
-            runtime_api="SubnetInfoRuntimeApi",
-            method="get_subnet_hyperparams",
-            params=[netuid],
-            block_hash=block_hash,
+        main_result, yuma3_result, sigmoid_steepness = await asyncio.gather(
+            self.query_runtime_api(
+                runtime_api="SubnetInfoRuntimeApi",
+                method="get_subnet_hyperparams",
+                params=[netuid],
+                block_hash=block_hash,
+            ),
+            self.query("SubtensorModule", "Yuma3On", [netuid]),
+            self.query("SubtensorModule", "AlphaSigmoidSteepness", [netuid]),
         )
-
-        if not result:
+        result = {
+            **main_result,
+            **{"yuma3_enabled": yuma3_result},
+            **{"alpha_sigmoid_steepness": sigmoid_steepness},
+        }
+        if not main_result:
             return []
 
         return SubnetHyperparameters.from_any(result)

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli/src/bittensor/utils.py

@@ -3,7 +3,6 @@ from collections import namedtuple
 import math
 import os
 import sqlite3
-import platform
 import webbrowser
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Collection, Optional, Union, Callable
@@ -33,6 +32,9 @@ if TYPE_CHECKING:
     from bittensor_cli.src.bittensor.chain_data import SubnetHyperparameters
     from rich.prompt import PromptBase
 
+BT_DOCS_LINK = "https://docs.bittensor.com"
+
+
 console = Console()
 json_console = Console()
 err_console = Console(stderr=True)
@@ -527,10 +529,11 @@ def format_error_message(error_message: Union[dict, Exception]) -> str:
                     elif all(x in d for x in ["code", "message", "data"]):
                         new_error_message = d
                         break
-            except ValueError:
+            except (ValueError, TypeError, SyntaxError, MemoryError, RecursionError):
                 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
@@ -549,8 +552,7 @@ def format_error_message(error_message: Union[dict, Exception]) -> str:
             # subtensor custom error marker
             if err_data.startswith("Custom error:"):
                 err_description = (
-                    f"{err_data} | Please consult "
-                    f"https://docs.bittensor.com/subtensor-nodes/subtensor-error-messages"
+                    f"{err_data} | Please consult {BT_DOCS_LINK}/errors/custom"
                 )
             else:
                 err_description = err_data
@@ -563,10 +565,20 @@ def format_error_message(error_message: Union[dict, Exception]) -> str:
             err_type = error_message.get("type", err_type)
             err_name = error_message.get("name", err_name)
             err_docs = error_message.get("docs", [err_description])
-            if isinstance(err_docs, list):
-                err_description = " ".join(err_docs)
-            else:
-                err_description = err_docs
+            err_description = " ".join(err_docs)
+            err_description += (
+                f" | Please consult {BT_DOCS_LINK}/errors/subtensor#{err_name.lower()}"
+            )
+
+        elif error_message.get("code") and error_message.get("message"):
+            err_type = error_message.get("code", err_name)
+            err_name = "Custom type"
+            err_description = error_message.get("message", err_description)
+
+        else:
+            print_error(
+                f"String representation of real error_message: {str(error_message)}"
+            )
 
     return f"Subtensor returned `{err_name}({err_type})` error. This means: `{err_description}`."
 
@@ -706,11 +718,14 @@ def millify_tao(n: float, start_at: str = "K") -> str:
 
 def normalize_hyperparameters(
     subnet: "SubnetHyperparameters",
+    json_output: bool = False,
 ) -> list[tuple[str, str, str]]:
     """
     Normalizes the hyperparameters of a subnet.
 
     :param subnet: The subnet hyperparameters object.
+    :param json_output: Whether this normalisation will be for a JSON output or console string (determines whether
+        items get stringified or safe for JSON encoding)
 
     :return: A list of tuples containing the parameter name, value, and normalized value.
     """
@@ -724,6 +739,7 @@ def normalize_hyperparameters(
         "kappa": u16_normalized_float,
         "alpha_high": u16_normalized_float,
         "alpha_low": u16_normalized_float,
+        "alpha_sigmoid_steepness": u16_normalized_float,
         "min_burn": Balance.from_rao,
         "max_burn": Balance.from_rao,
     }
@@ -737,13 +753,17 @@ def normalize_hyperparameters(
                 norm_value = param_mappings[param](value)
                 if isinstance(norm_value, float):
                     norm_value = f"{norm_value:.{10}g}"
+                if isinstance(norm_value, Balance) and json_output:
+                    norm_value = norm_value.to_dict()
             else:
                 norm_value = value
         except Exception:
             # bittensor.logging.warning(f"Error normalizing parameter '{param}': {e}")
             norm_value = "-"
-
-        normalized_values.append((param, str(value), str(norm_value)))
+        if not json_output:
+            normalized_values.append((param, str(value), str(norm_value)))
+        else:
+            normalized_values.append((param, value, norm_value))
 
     return normalized_values
 

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli/src/commands/stake/add.py

@@ -31,7 +31,7 @@ if TYPE_CHECKING:
 async def stake_add(
     wallet: Wallet,
     subtensor: "SubtensorInterface",
-    netuid: Optional[int],
+    netuids: Optional[list[int]],
     stake_all: bool,
     amount: float,
     prompt: bool,
@@ -48,7 +48,7 @@ async def stake_add(
     Args:
         wallet: wallet object
         subtensor: SubtensorInterface object
-        netuid: the netuid to stake to (None indicates all subnets)
+        netuids: the netuids to stake to (None indicates all subnets)
         stake_all: whether to stake all available balance
         amount: specified amount of balance to stake
         prompt: whether to prompt the user
@@ -72,7 +72,7 @@ async def stake_add(
         hotkey_ss58_: str,
         price_limit: Balance,
         status=None,
-    ) -> bool:
+    ) -> tuple[bool, str]:
         err_out = partial(print_error, status=status)
         failure_prelude = (
             f":cross_mark: [red]Failed[/red] to stake {amount_} on Netuid {netuid_}"
@@ -104,25 +104,24 @@ async def stake_add(
             )
         except SubstrateRequestException as e:
             if "Custom error: 8" in str(e):
-                print_error(
-                    f"\n{failure_prelude}: Price exceeded tolerance limit. "
+                err_msg = (
+                    f"{failure_prelude}: Price exceeded tolerance limit. "
                     f"Transaction rejected because partial staking is disabled. "
-                    f"Either increase price tolerance or enable partial staking.",
-                    status=status,
+                    f"Either increase price tolerance or enable partial staking."
                 )
-                return False
+                print_error("\n" + err_msg, status=status)
             else:
-                err_out(f"\n{failure_prelude} with error: {format_error_message(e)}")
-            return False
+                err_msg = f"{failure_prelude} with error: {format_error_message(e)}"
+                err_out("\n" + err_msg)
+            return False, err_msg
         if not await response.is_success:
-            err_out(
-                f"\n{failure_prelude} with error: {format_error_message(await response.error_message)}"
-            )
-            return False
+            err_msg = f"{failure_prelude} with error: {format_error_message(await response.error_message)}"
+            err_out("\n" + err_msg)
+            return False, err_msg
         else:
             if json_output:
                 # the rest of this checking is not necessary if using json_output
-                return True
+                return True, ""
             block_hash = await subtensor.substrate.get_chain_head()
             new_balance, new_stake = await asyncio.gather(
                 subtensor.get_balance(wallet.coldkeypub.ss58_address, block_hash),
@@ -160,11 +159,11 @@ async def stake_add(
                 f":arrow_right: "
                 f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_stake}\n"
             )
-            return True
+            return True, ""
 
     async def stake_extrinsic(
         netuid_i, amount_, current, staking_address_ss58, status=None
-    ) -> bool:
+    ) -> tuple[bool, str]:
         err_out = partial(print_error, status=status)
         current_balance, next_nonce, call = await asyncio.gather(
             subtensor.get_balance(wallet.coldkeypub.ss58_address),
@@ -190,18 +189,18 @@ async def stake_add(
                 extrinsic, wait_for_inclusion=True, wait_for_finalization=False
             )
         except SubstrateRequestException as e:
-            err_out(f"\n{failure_prelude} with error: {format_error_message(e)}")
-            return False
+            err_msg = f"{failure_prelude} with error: {format_error_message(e)}"
+            err_out("\n" + err_msg)
+            return False, err_msg
         else:
             if not await response.is_success:
-                err_out(
-                    f"\n{failure_prelude} with error: {format_error_message(await response.error_message)}"
-                )
-                return False
+                err_msg = f"{failure_prelude} with error: {format_error_message(await response.error_message)}"
+                err_out("\n" + err_msg)
+                return False, err_msg
             else:
                 if json_output:
                     # the rest of this is not necessary if using json_output
-                    return True
+                    return True, ""
                 new_block_hash = await subtensor.substrate.get_chain_head()
                 new_balance, new_stake = await asyncio.gather(
                     subtensor.get_balance(
@@ -230,12 +229,10 @@ async def stake_add(
                     f":arrow_right: "
                     f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_stake}\n"
                 )
-                return True
+                return True, ""
 
     netuids = (
-        [int(netuid)]
-        if netuid is not None
-        else await subtensor.get_all_subnet_netuids()
+        netuids if netuids is not None else await subtensor.get_all_subnet_netuids()
     )
 
     hotkeys_to_stake_to = _get_hotkeys_to_stake_to(
@@ -419,13 +416,17 @@ async def stake_add(
             for _, staking_address in hotkeys_to_stake_to
         }
     successes = defaultdict(dict)
+    error_messages = defaultdict(dict)
     with console.status(f"\n:satellite: Staking on netuid(s): {netuids} ..."):
         # We can gather them all at once but balance reporting will be in race-condition.
         for (ni, staking_address), coroutine in stake_coroutines.items():
-            success = await coroutine
+            success, er_msg = await coroutine
             successes[ni][staking_address] = success
+            error_messages[ni][staking_address] = er_msg
     if json_output:
-        json_console.print(json.dumps({"staking_success": successes}))
+        json_console.print(
+            json.dumps({"staking_success": successes, "error_messages": error_messages})
+        )
 
 
 # Helper functions
@@ -445,10 +446,10 @@ def _prompt_stake_amount(
     while True:
         amount_input = Prompt.ask(
             f"\nEnter the amount to {action_name}"
-            f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{Balance.get_unit(netuid)}[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}] "
-            f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}](max: {current_balance})[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}] "
+            f"[{COLOR_PALETTE.S.STAKE_AMOUNT}]{Balance.get_unit(netuid)}[/{COLOR_PALETTE.S.STAKE_AMOUNT}] "
+            f"[{COLOR_PALETTE.S.STAKE_AMOUNT}](max: {current_balance})[/{COLOR_PALETTE.S.STAKE_AMOUNT}] "
             f"or "
-            f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]'all'[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}] "
+            f"[{COLOR_PALETTE.S.STAKE_AMOUNT}]'all'[/{COLOR_PALETTE.S.STAKE_AMOUNT}] "
             f"for entire balance"
         )
 
@@ -463,7 +464,7 @@ def _prompt_stake_amount(
             if amount > current_balance.tao:
                 console.print(
                     f"[red]Amount exceeds available balance of "
-                    f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{current_balance}[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]"
+                    f"[{COLOR_PALETTE.S.STAKE_AMOUNT}]{current_balance}[/{COLOR_PALETTE.S.STAKE_AMOUNT}]"
                     f"[/red]"
                 )
                 continue
@@ -542,10 +543,10 @@ def _define_stake_table(
         Table: An initialized rich Table object with appropriate columns
     """
     table = Table(
-        title=f"\n[{COLOR_PALETTE['GENERAL']['HEADER']}]Staking to:\n"
-        f"Wallet: [{COLOR_PALETTE['GENERAL']['COLDKEY']}]{wallet.name}[/{COLOR_PALETTE['GENERAL']['COLDKEY']}], "
-        f"Coldkey ss58: [{COLOR_PALETTE['GENERAL']['COLDKEY']}]{wallet.coldkeypub.ss58_address}[/{COLOR_PALETTE['GENERAL']['COLDKEY']}]\n"
-        f"Network: {subtensor.network}[/{COLOR_PALETTE['GENERAL']['HEADER']}]\n",
+        title=f"\n[{COLOR_PALETTE.G.HEADER}]Staking to:\n"
+        f"Wallet: [{COLOR_PALETTE.G.CK}]{wallet.name}[/{COLOR_PALETTE.G.CK}], "
+        f"Coldkey ss58: [{COLOR_PALETTE.G.CK}]{wallet.coldkeypub.ss58_address}[/{COLOR_PALETTE.G.CK}]\n"
+        f"Network: {subtensor.network}[/{COLOR_PALETTE.G.HEADER}]\n",
         show_footer=True,
         show_edge=False,
         header_style="bold white",
@@ -609,9 +610,13 @@ def _print_table_and_slippage(table: Table, max_slippage: float, safe_staking: b
 
     # Greater than 5%
     if max_slippage > 5:
-        message = f"[{COLOR_PALETTE['STAKE']['SLIPPAGE_TEXT']}]-------------------------------------------------------------------------------------------------------------------\n"
-        message += f"[bold]WARNING:[/bold]  The slippage on one of your operations is high: [{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}]{max_slippage} %[/{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}], this may result in a loss of funds.\n"
-        message += "-------------------------------------------------------------------------------------------------------------------\n"
+        message = (
+            f"[{COLOR_PALETTE.S.SLIPPAGE_TEXT}]" + ("-" * 115) + "\n"
+            f"[bold]WARNING:[/bold]  The slippage on one of your operations is high: "
+            f"[{COLOR_PALETTE.S.SLIPPAGE_PERCENT}]{max_slippage} %[/{COLOR_PALETTE.S.SLIPPAGE_PERCENT}], "
+            f"this may result in a loss of funds.\n" + ("-" * 115) + "\n"
+        )
+
         console.print(message)
 
     # Table description

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli/src/commands/subnets/subnets.py

@@ -2323,7 +2323,7 @@ async def get_start_schedule(
         print_error(f"Subnet {netuid} does not exist.")
         return None
     block_hash = await subtensor.substrate.get_chain_head()
-    registration_block, min_blocks_to_start, current_block = await asyncio.gather(
+    registration_block, min_blocks_to_start_, current_block = await asyncio.gather(
         subtensor.query(
             module="SubtensorModule",
             storage_function="NetworkRegisteredAt",
@@ -2337,6 +2337,7 @@ async def get_start_schedule(
         ),
         subtensor.substrate.get_block_number(block_hash=block_hash),
     )
+    min_blocks_to_start = getattr(min_blocks_to_start_, "value", min_blocks_to_start_)
 
     potential_start_block = registration_block + min_blocks_to_start
     if current_block < potential_start_block:

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli/src/commands/sudo.py

@@ -73,6 +73,13 @@ def allowed_value(
     return True, value
 
 
+def string_to_bool(val) -> bool:
+    try:
+        return {"true": True, "1": True, "0": False, "false": False}[val.lower()]
+    except KeyError:
+        return ValueError
+
+
 def search_metadata(
     param_name: str, value: Union[str, bool, float, list[float]], netuid: int, metadata
 ) -> tuple[bool, Optional[dict]]:
@@ -91,12 +98,6 @@ def search_metadata(
 
     """
 
-    def string_to_bool(val) -> bool:
-        try:
-            return {"true": True, "1": True, "0": False, "false": False}[val.lower()]
-        except KeyError:
-            return ValueError
-
     def type_converter_with_retry(type_, val, arg_name):
         try:
             if val is None:
@@ -112,37 +113,55 @@ def search_metadata(
 
     call_crafter = {"netuid": netuid}
 
-    for pallet in metadata.pallets:
-        if pallet.name == "AdminUtils":
-            for call in pallet.calls:
-                if call.name == param_name:
-                    if "netuid" not in [x.name for x in call.args]:
-                        return False, None
-                    call_args = [
-                        arg for arg in call.args if arg.value["name"] != "netuid"
-                    ]
-                    if len(call_args) == 1:
-                        arg = call_args[0].value
-                        call_crafter[arg["name"]] = type_converter_with_retry(
-                            arg["typeName"], value, arg["name"]
-                        )
-                    else:
-                        for arg_ in call_args:
-                            arg = arg_.value
-                            call_crafter[arg["name"]] = type_converter_with_retry(
-                                arg["typeName"], None, arg["name"]
-                            )
-                    return True, call_crafter
+    pallet = metadata.get_metadata_pallet("AdminUtils")
+    for call in pallet.calls:
+        if call.name == param_name:
+            if "netuid" not in [x.name for x in call.args]:
+                return False, None
+            call_args = [arg for arg in call.args if arg.value["name"] != "netuid"]
+            if len(call_args) == 1:
+                arg = call_args[0].value
+                call_crafter[arg["name"]] = type_converter_with_retry(
+                    arg["typeName"], value, arg["name"]
+                )
+            else:
+                for arg_ in call_args:
+                    arg = arg_.value
+                    call_crafter[arg["name"]] = type_converter_with_retry(
+                        arg["typeName"], None, arg["name"]
+                    )
+            return True, call_crafter
     else:
         return False, None
 
 
+def requires_bool(metadata, param_name) -> bool:
+    """
+    Determines whether a given hyperparam takes a single arg (besides netuid) that is of bool type.
+    """
+    pallet = metadata.get_metadata_pallet("AdminUtils")
+    for call in pallet.calls:
+        if call.name == param_name:
+            if "netuid" not in [x.name for x in call.args]:
+                return False, None
+            call_args = [arg for arg in call.args if arg.value["name"] != "netuid"]
+            if len(call_args) != 1:
+                return False
+            else:
+                arg = call_args[0].value
+                if arg["typeName"] == "bool":
+                    return True
+                else:
+                    return False
+    raise ValueError(f"{param_name} not found in pallet.")
+
+
 async def set_hyperparameter_extrinsic(
     subtensor: "SubtensorInterface",
     wallet: "Wallet",
     netuid: int,
     parameter: str,
-    value: Optional[Union[str, bool, float, list[float]]],
+    value: Optional[Union[str, float, list[float]]],
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
     prompt: bool = True,
@@ -221,15 +240,20 @@ async def set_hyperparameter_extrinsic(
                 ]
 
                 if len(value) < len(non_netuid_fields):
-                    raise ValueError(
+                    err_console.print(
                         "Not enough values provided in the list for all parameters"
                     )
+                    return False
 
                 call_params.update(
                     {str(name): val for name, val in zip(non_netuid_fields, value)}
                 )
 
             else:
+                if requires_bool(
+                    substrate.metadata, param_name=extrinsic
+                ) and isinstance(value, str):
+                    value = string_to_bool(value)
                 value_argument = extrinsic_params["fields"][
                     len(extrinsic_params["fields"]) - 1
                 ]
@@ -252,12 +276,13 @@ async def set_hyperparameter_extrinsic(
         )
         if not success:
             err_console.print(f":cross_mark: [red]Failed[/red]: {err_msg}")
-            await asyncio.sleep(0.5)
+            return False
         elif arbitrary_extrinsic:
             console.print(
                 f":white_heavy_check_mark: "
                 f"[dark_sea_green3]Hyperparameter {parameter} values changed to {call_params}[/dark_sea_green3]"
             )
+            return True
         # Successful registration, final check for membership
         else:
             console.print(
@@ -581,28 +606,11 @@ async def sudo_set_hyperparameter(
     json_output: bool,
 ):
     """Set subnet hyperparameters."""
-
-    normalized_value: Union[str, bool]
-    if param_name in [
-        "registration_allowed",
-        "network_pow_registration_allowed",
-        "commit_reveal_weights_enabled",
-        "liquid_alpha_enabled",
-    ]:
-        normalized_value = param_value.lower() in ["true", "1"]
-    elif param_value in ("True", "False"):
-        normalized_value = {
-            "True": True,
-            "False": False,
-        }[param_value]
-    else:
-        normalized_value = param_value
-
-    is_allowed_value, value = allowed_value(param_name, normalized_value)
+    is_allowed_value, value = allowed_value(param_name, param_value)
     if not is_allowed_value:
         err_console.print(
             f"Hyperparameter [dark_orange]{param_name}[/dark_orange] value is not within bounds. "
-            f"Value is {normalized_value} but must be {value}"
+            f"Value is {param_value} but must be {value}"
         )
         return False
     success = await set_hyperparameter_extrinsic(
@@ -625,8 +633,9 @@ async def get_hyperparameters(
     if not await subtensor.subnet_exists(netuid):
         print_error(f"Subnet with netuid {netuid} does not exist.")
         return False
-    subnet = await subtensor.get_subnet_hyperparameters(netuid)
-    subnet_info = await subtensor.subnet(netuid)
+    subnet, subnet_info = await asyncio.gather(
+        subtensor.get_subnet_hyperparameters(netuid), subtensor.subnet(netuid)
+    )
     if subnet_info is None:
         print_error(f"Subnet with netuid {netuid} does not exist.")
         return False
@@ -648,17 +657,18 @@ async def get_hyperparameters(
     )
     dict_out = []
 
-    normalized_values = normalize_hyperparameters(subnet)
-
+    normalized_values = normalize_hyperparameters(subnet, json_output=json_output)
     for param, value, norm_value in normalized_values:
-        table.add_row("  " + param, value, norm_value)
-        dict_out.append(
-            {
-                "hyperparameter": param,
-                "value": value,
-                "normalized_value": norm_value,
-            }
-        )
+        if not json_output:
+            table.add_row("  " + param, value, norm_value)
+        else:
+            dict_out.append(
+                {
+                    "hyperparameter": param,
+                    "value": value,
+                    "normalized_value": norm_value,
+                }
+            )
     if json_output:
         json_console.print(json.dumps(dict_out))
     else:

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli/src/commands/wallets.py

@@ -1632,6 +1632,7 @@ async def swap_hotkey(
     original_wallet: Wallet,
     new_wallet: Wallet,
     subtensor: SubtensorInterface,
+    netuid: Optional[int],
     prompt: bool,
     json_output: bool,
 ):
@@ -1640,6 +1641,7 @@ async def swap_hotkey(
         subtensor,
         original_wallet,
         new_wallet,
+        netuid=netuid,
         prompt=prompt,
     )
     if json_output:

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/bittensor_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bittensor-cli
-Version: 9.5.1
+Version: 9.7.0
 Summary: Bittensor CLI
 Author: bittensor.com
 Project-URL: homepage, https://github.com/opentensor/btcli
@@ -71,10 +71,10 @@ Installation steps are described below. For a full documentation on how to use `
 
 ## Install on macOS and Linux
 
-You can install `btcli` on your local machine directly from source, or from PyPI. **Make sure you verify your installation after you install**:
+You can install `btcli` on your local machine directly from source, PyPI, or Homebrew. **Make sure you verify your installation after you install**:
 
 
-### Install from PyPI
+### Install from [PyPI](https://pypi.org/project/bittensor/)
 
 Run 
 ```
@@ -86,6 +86,12 @@ Alternatively, if you prefer to use [uv](https://pypi.org/project/uv/):
 uv pip install bittensor-cli
 ```
 
+### Install from [Homebrew](https://formulae.brew.sh/formula/btcli#default)
+
+```shell
+brew install btcli
+```
+
 ### Install from source
 
 1. Create and activate a virtual environment.

{bittensor_cli-9.5.1 → bittensor_cli-9.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bittensor-cli"
-version = "9.5.1"
+version = "9.7.0"
 description = "Bittensor CLI"
 readme = "README.md"
 authors = [