Release/9.10.0

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 9.10.0 /2025-08-06
+* Sets default interval hours for subnets price to 4, bc of rate limiting. by @thewhaleking in https://github.com/opentensor/btcli/pull/568
+* Subnets Price --current + improvements by @thewhaleking in https://github.com/opentensor/btcli/pull/569
+* Reconfig Asyncio Runner by @thewhaleking in https://github.com/opentensor/btcli/pull/570
+* Show amount on `transfer --all` by @thewhaleking in https://github.com/opentensor/btcli/pull/571
+* Allows for typer>=0.16 and Click 8.2+ by @thewhaleking in https://github.com/opentensor/btcli/pull/572
+* BTCLI Config Updates by @thewhaleking in https://github.com/opentensor/btcli/pull/573
+* Added info about preinstalled macOS CPython by @thewhaleking in https://github.com/opentensor/btcli/pull/574
+* Click 8.2+/- compatibility by @thewhaleking in https://github.com/opentensor/btcli/pull/576
+* New command: `btcli w regen-hotkeypub` by @thewhaleking in https://github.com/opentensor/btcli/pull/575
+
+**Full Changelog**: https://github.com/opentensor/btcli/compare/v9.9.0...v9.10.0
+
 ## 9.9.0 /2025-07-28
 * Feat/wallet verify by @ibraheem-abe in https://github.com/opentensor/btcli/pull/561
 * Improved speed of query_all_identities and fetch_coldkey_hotkey_identities by @thewhaleking in https://github.com/opentensor/btcli/pull/560

README.md

@@ -38,7 +38,15 @@ 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, PyPI, or Homebrew. **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**.
+
+### For macOS users
+Note that the macOS preinstalled CPython installation is compiled with LibreSSL instead of OpenSSL. There are a number
+of issues with LibreSSL, and as such is not fully supported by the libraries used by btcli. Thus we highly recommend, if 
+you are using a Mac, to first install Python from [Homebrew](https://brew.sh/). Additionally, the Rust FFI bindings 
+[if installing from precompiled wheels (default)] require the Homebrew-installed OpenSSL pacakge. If you choose to use
+the preinstalled Python version from macOS, things may not work completely.
 
 
 ### Install from [PyPI](https://pypi.org/project/bittensor/)

bittensor_cli/src/bittensor/extrinsics/registration.py

@@ -39,6 +39,7 @@
     print_error,
     unlock_key,
     hex_to_bytes,
+    get_hotkey_pub_ss58,
 )
 
 if typing.TYPE_CHECKING:
@@ -490,7 +491,7 @@ async def register_extrinsic(
 
     async def get_neuron_for_pubkey_and_subnet():
         uid = await subtensor.query(
-            "SubtensorModule", "Uids", [netuid, wallet.hotkey.ss58_address]
+            "SubtensorModule", "Uids", [netuid, get_hotkey_pub_ss58(wallet)]
         )
         if uid is None:
             return NeuronInfo.get_null_neuron()
@@ -525,7 +526,7 @@ async def get_neuron_for_pubkey_and_subnet():
         if not Confirm.ask(
             f"Continue Registration?\n"
             f"  hotkey [{COLOR_PALETTE.G.HK}]({wallet.hotkey_str})[/{COLOR_PALETTE.G.HK}]:"
-            f"\t[{COLOR_PALETTE.G.HK}]{wallet.hotkey.ss58_address}[/{COLOR_PALETTE.G.HK}]\n"
+            f"\t[{COLOR_PALETTE.G.HK}]{get_hotkey_pub_ss58(wallet)}[/{COLOR_PALETTE.G.HK}]\n"
             f"  coldkey [{COLOR_PALETTE.G.CK}]({wallet.name})[/{COLOR_PALETTE.G.CK}]:"
             f"\t[{COLOR_PALETTE.G.CK}]{wallet.coldkeypub.ss58_address}[/{COLOR_PALETTE.G.CK}]\n"
             f"  network:\t\t[{COLOR_PALETTE.G.LINKS}]{subtensor.network}[/{COLOR_PALETTE.G.LINKS}]\n"
@@ -577,7 +578,7 @@ async def get_neuron_for_pubkey_and_subnet():
         if not pow_result:
             # might be registered already on this subnet
             is_registered = await is_hotkey_registered(
-                subtensor, netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
+                subtensor, netuid=netuid, hotkey_ss58=get_hotkey_pub_ss58(wallet)
             )
             if is_registered:
                 err_console.print(
@@ -598,7 +599,7 @@ async def get_neuron_for_pubkey_and_subnet():
                             "block_number": pow_result.block_number,
                             "nonce": pow_result.nonce,
                             "work": [int(byte_) for byte_ in pow_result.seal],
-                            "hotkey": wallet.hotkey.ss58_address,
+                            "hotkey": get_hotkey_pub_ss58(wallet),
                             "coldkey": wallet.coldkeypub.ss58_address,
                         },
                     )
@@ -639,7 +640,7 @@ async def get_neuron_for_pubkey_and_subnet():
                         is_registered = await is_hotkey_registered(
                             subtensor,
                             netuid=netuid,
-                            hotkey_ss58=wallet.hotkey.ss58_address,
+                            hotkey_ss58=get_hotkey_pub_ss58(wallet),
                         )
                         if is_registered:
                             console.print(
@@ -704,7 +705,7 @@ async def burned_register_extrinsic(
         spinner="aesthetic",
     ) as status:
         my_uid = await subtensor.query(
-            "SubtensorModule", "Uids", [netuid, wallet.hotkey.ss58_address]
+            "SubtensorModule", "Uids", [netuid, get_hotkey_pub_ss58(wallet)]
         )
         block_hash = await subtensor.substrate.get_chain_head()
 
@@ -751,7 +752,7 @@ async def burned_register_extrinsic(
             call_function="burned_register",
             call_params={
                 "netuid": netuid,
-                "hotkey": wallet.hotkey.ss58_address,
+                "hotkey": get_hotkey_pub_ss58(wallet),
             },
         )
         success, err_msg = await subtensor.sign_and_send_extrinsic(
@@ -773,10 +774,10 @@ async def burned_register_extrinsic(
                     reuse_block=False,
                 ),
                 subtensor.get_netuids_for_hotkey(
-                    wallet.hotkey.ss58_address, block_hash=block_hash
+                    get_hotkey_pub_ss58(wallet), block_hash=block_hash
                 ),
                 subtensor.query(
-                    "SubtensorModule", "Uids", [netuid, wallet.hotkey.ss58_address]
+                    "SubtensorModule", "Uids", [netuid, get_hotkey_pub_ss58(wallet)]
                 ),
             )
 
@@ -1146,7 +1147,7 @@ async def _block_solver(
 
     timeout = 0.15 if cuda else 0.15
     while netuid == -1 or not await is_hotkey_registered(
-        subtensor, netuid, wallet.hotkey.ss58_address
+        subtensor, netuid, get_hotkey_pub_ss58(wallet)
     ):
         # Wait until a solver finds a solution
         try:
@@ -1755,37 +1756,39 @@ async def swap_hotkey_extrinsic(
     :return: Success
     """
     block_hash = await subtensor.substrate.get_chain_head()
+    hk_ss58 = get_hotkey_pub_ss58(wallet)
     netuids_registered = await subtensor.get_netuids_for_hotkey(
-        wallet.hotkey.ss58_address, block_hash=block_hash
+        hk_ss58, block_hash=block_hash
     )
     netuids_registered_new_hotkey = await subtensor.get_netuids_for_hotkey(
-        new_wallet.hotkey.ss58_address, block_hash=block_hash
+        hk_ss58, 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}"
+            f":cross_mark: [red]Failed[/red]: Original hotkey {hk_ss58} is not registered on subnet {netuid}"
         )
         return False
 
     elif not len(netuids_registered) > 0:
         err_console.print(
-            f"Original hotkey [dark_orange]{wallet.hotkey.ss58_address}[/dark_orange] is not registered on any subnet. "
+            f"Original hotkey [dark_orange]{hk_ss58}[/dark_orange] is not registered on any subnet. "
             f"Please register and try again"
         )
         return False
 
+    new_hk_ss58 = get_hotkey_pub_ss58(new_wallet)
     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":cross_mark: [red]Failed[/red]: New hotkey {new_hk_ss58} "
                 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":cross_mark: [red]Failed[/red]: New hotkey {new_hk_ss58} "
                 f"is already registered on subnet(s) {netuids_registered_new_hotkey}"
             )
             return False
@@ -1798,28 +1801,28 @@ async def swap_hotkey_extrinsic(
         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"
+                f"[dark_orange]{hk_ss58} ({wallet.hotkey_str})[/dark_orange] with hotkey \n\t"
+                f"[dark_orange]{new_hk_ss58} ({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"
+                f"[dark_orange]{hk_ss58} ({wallet.hotkey_str})[/dark_orange] with hotkey \n\t"
+                f"[dark_orange]{new_hk_ss58} ({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} - {wallet.hotkey_str}) with "
-        f"{new_wallet.name}'s hotkey ({new_wallet.hotkey.ss58_address} - {new_wallet.hotkey_str})"
+        f"Swapping {wallet.name}'s hotkey ({hk_ss58} - {wallet.hotkey_str}) with "
+        f"{new_wallet.name}'s hotkey ({new_hk_ss58} - {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,
+            "hotkey": hk_ss58,
+            "new_hotkey": new_hk_ss58,
             "netuid": netuid,
         }
 
@@ -1832,7 +1835,8 @@ async def swap_hotkey_extrinsic(
 
         if success:
             console.print(
-                f"Hotkey {wallet.hotkey.ss58_address} ({wallet.hotkey_str}) swapped for new hotkey: {new_wallet.hotkey.ss58_address} ({new_wallet.hotkey_str})"
+                f"Hotkey {hk_ss58} ({wallet.hotkey_str}) swapped for new hotkey: "
+                f"{new_hk_ss58} ({new_wallet.hotkey_str})"
             )
             return True
         else:

bittensor_cli/src/bittensor/extrinsics/root.py

@@ -37,6 +37,7 @@
     print_verbose,
     format_error_message,
     unlock_key,
+    get_hotkey_pub_ss58,
 )
 
 if TYPE_CHECKING:
@@ -310,7 +311,7 @@ async def root_register_extrinsic(
 
     print_verbose(f"Checking if hotkey ({wallet.hotkey_str}) is registered on root")
     is_registered = await is_hotkey_registered(
-        subtensor, netuid=0, hotkey_ss58=wallet.hotkey.ss58_address
+        subtensor, netuid=0, hotkey_ss58=get_hotkey_pub_ss58(wallet)
     )
     if is_registered:
         console.print(
@@ -322,7 +323,7 @@ async def root_register_extrinsic(
         call = await subtensor.substrate.compose_call(
             call_module="SubtensorModule",
             call_function="root_register",
-            call_params={"hotkey": wallet.hotkey.ss58_address},
+            call_params={"hotkey": get_hotkey_pub_ss58(wallet)},
         )
         success, err_msg = await subtensor.sign_and_send_extrinsic(
             call,
@@ -341,7 +342,7 @@ async def root_register_extrinsic(
             uid = await subtensor.query(
                 module="SubtensorModule",
                 storage_function="Uids",
-                params=[0, wallet.hotkey.ss58_address],
+                params=[0, get_hotkey_pub_ss58(wallet)],
             )
             if uid is not None:
                 console.print(
@@ -391,7 +392,7 @@ async def _do_set_weights():
                 "weights": weight_vals,
                 "netuid": 0,
                 "version_key": version_key,
-                "hotkey": wallet.hotkey.ss58_address,
+                "hotkey": get_hotkey_pub_ss58(wallet),
             },
         )
         # Period dictates how long the extrinsic will stay as part of waiting pool
@@ -415,7 +416,7 @@ async def _do_set_weights():
             return False, await response.error_message
 
     my_uid = await subtensor.query(
-        "SubtensorModule", "Uids", [0, wallet.hotkey.ss58_address]
+        "SubtensorModule", "Uids", [0, get_hotkey_pub_ss58(wallet)]
     )
 
     if my_uid is None:

bittensor_cli/src/bittensor/extrinsics/transfer.py

@@ -172,7 +172,7 @@ async def do_transfer() -> tuple[bool, str, str]:
     if prompt:
         if not Confirm.ask(
             "Do you want to transfer:[bold white]\n"
-            f"  amount: [bright_cyan]{amount}[/bright_cyan]\n"
+            f"  amount: [bright_cyan]{amount if not transfer_all else account_balance}[/bright_cyan]\n"
             f"  from: [light_goldenrod2]{wallet.name}[/light_goldenrod2] : "
             f"[bright_magenta]{wallet.coldkey.ss58_address}\n[/bright_magenta]"
             f"  to: [bright_magenta]{destination}[/bright_magenta]\n  for fee: [bright_cyan]{fee}[/bright_cyan]"

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -39,6 +39,7 @@
     validate_chain_endpoint,
     u16_normalized_float,
     U16_MAX,
+    get_hotkey_pub_ss58,
 )
 
 SubstrateClass = (
@@ -666,7 +667,7 @@ async def filter_netuids_by_registered_hotkeys(
             for sublist in await asyncio.gather(
                 *[
                     self.get_netuids_for_hotkey(
-                        wallet.hotkey.ss58_address,
+                        get_hotkey_pub_ss58(wallet),
                         reuse_block=reuse_block,
                         block_hash=block_hash,
                     )

bittensor_cli/src/bittensor/utils.py

@@ -275,7 +275,7 @@ def get_hotkey_wallets_for_wallet(
                 (exists := hotkey_for_name.hotkey_file.exists_on_device())
                 and not hotkey_for_name.hotkey_file.is_encrypted()
                 # and hotkey_for_name.coldkeypub.ss58_address
-                and hotkey_for_name.hotkey.ss58_address
+                and get_hotkey_pub_ss58(hotkey_for_name)
             ):
                 hotkey_wallets.append(hotkey_for_name)
             elif (
@@ -1431,3 +1431,15 @@ def blocks_to_duration(blocks: int) -> str:
             results.append(f"{unit_count}{unit}")
     # Return only the first two non-zero units
     return " ".join(results[:2]) or "0s"
+
+
+def get_hotkey_pub_ss58(wallet: Wallet) -> str:
+    """
+    Helper fn to retrieve the hotkeypub ss58 of a wallet that may have been created before
+    bt-wallet 3.1.1 and thus not have a wallet hotkeypub. In this case, it will return the hotkey
+    SS58.
+    """
+    try:
+        return wallet.hotkeypub.ss58_address
+    except KeyFileError:
+        return wallet.hotkey.ss58_address

bittensor_cli/src/commands/stake/add.py

@@ -20,6 +20,7 @@
     print_verbose,
     unlock_key,
     json_console,
+    get_hotkey_pub_ss58,
 )
 from bittensor_wallet import Wallet
 
@@ -552,7 +553,7 @@ def _get_hotkeys_to_stake_to(
         # Stake to all hotkeys except excluded ones
         all_hotkeys_: list[Wallet] = get_hotkey_wallets_for_wallet(wallet=wallet)
         return [
-            (wallet.hotkey_str, wallet.hotkey.ss58_address)
+            (wallet.hotkey_str, get_hotkey_pub_ss58(wallet))
             for wallet in all_hotkeys_
             if wallet.hotkey_str not in (exclude_hotkeys or [])
         ]
@@ -572,7 +573,7 @@ def _get_hotkeys_to_stake_to(
                     name=wallet.name,
                     hotkey=hotkey_ss58_or_hotkey_name,
                 )
-                hotkeys.append((wallet_.hotkey_str, wallet_.hotkey.ss58_address))
+                hotkeys.append((wallet_.hotkey_str, get_hotkey_pub_ss58(wallet_)))
 
         return hotkeys
 
@@ -581,7 +582,7 @@ def _get_hotkeys_to_stake_to(
         f"Staking to hotkey: ({wallet.hotkey_str}) in wallet: ({wallet.name})"
     )
     assert wallet.hotkey is not None
-    return [(None, wallet.hotkey.ss58_address)]
+    return [(None, get_hotkey_pub_ss58(wallet))]
 
 
 def _define_stake_table(