bittensor-cli 9.9.0__py3-none-any.whl → 9.10.1__py3-none-any.whl

bittensor_cli/src/commands/subnets/price.py

@@ -10,6 +10,7 @@ import plotille
 import plotly.graph_objects as go
 
 from bittensor_cli.src import COLOR_PALETTE
+from bittensor_cli.src.bittensor.chain_data import DynamicInfo
 from bittensor_cli.src.bittensor.utils import (
     console,
     err_console,
@@ -27,7 +28,8 @@ async def price(
     subtensor: "SubtensorInterface",
     netuids: list[int],
     all_netuids: bool = False,
-    interval_hours: int = 24,
+    interval_hours: int = 4,
+    current_only: bool = False,
     html_output: bool = False,
     log_scale: bool = False,
     json_output: bool = False,
@@ -41,45 +43,96 @@ async def price(
     blocks_per_hour = int(3600 / 12)  # ~300 blocks per hour
     total_blocks = blocks_per_hour * interval_hours
 
-    with console.status(":chart_increasing: Fetching historical price data..."):
-        current_block_hash = await subtensor.substrate.get_chain_head()
-        current_block = await subtensor.substrate.get_block_number(current_block_hash)
+    if not current_only:
+        with console.status(":chart_increasing: Fetching historical price data..."):
+            current_block_hash = await subtensor.substrate.get_chain_head()
+            current_block = await subtensor.substrate.get_block_number(
+                current_block_hash
+            )
 
-        step = 300
-        start_block = max(0, current_block - total_blocks)
-        block_numbers = list(range(start_block, current_block + 1, step))
+            step = 300
+            start_block = max(0, current_block - total_blocks)
+            block_numbers = list(range(start_block, current_block + 1, step))
 
-        # Block hashes
-        block_hash_cors = [
-            subtensor.substrate.get_block_hash(bn) for bn in block_numbers
-        ]
-        block_hashes = await asyncio.gather(*block_hash_cors)
+            # Block hashes
+            block_hash_cors = [
+                subtensor.substrate.get_block_hash(bn) for bn in block_numbers
+            ]
+            block_hashes = await asyncio.gather(*block_hash_cors)
 
-        # We fetch all subnets when there is more than one netuid
-        if all_netuids or len(netuids) > 1:
-            subnet_info_cors = [subtensor.all_subnets(bh) for bh in block_hashes]
-        else:
-            # If there is only one netuid, we fetch the subnet info for that netuid
-            netuid = netuids[0]
-            subnet_info_cors = [subtensor.subnet(netuid, bh) for bh in block_hashes]
-        all_subnet_infos = await asyncio.gather(*subnet_info_cors)
+            # We fetch all subnets when there is more than one netuid
+            if all_netuids or len(netuids) > 1:
+                subnet_info_cors = [subtensor.all_subnets(bh) for bh in block_hashes]
+            else:
+                # If there is only one netuid, we fetch the subnet info for that netuid
+                netuid = netuids[0]
+                subnet_info_cors = [subtensor.subnet(netuid, bh) for bh in block_hashes]
+            all_subnet_infos = await asyncio.gather(*subnet_info_cors)
 
         subnet_data = _process_subnet_data(
             block_numbers, all_subnet_infos, netuids, all_netuids
         )
+        if not subnet_data:
+            err_console.print("[red]No valid price data found for any subnet[/red]")
+            return
 
-    if not subnet_data:
-        err_console.print("[red]No valid price data found for any subnet[/red]")
-        return
-
-    if html_output:
-        await _generate_html_output(
-            subnet_data, block_numbers, interval_hours, log_scale
+        if html_output:
+            await _generate_html_output(
+                subnet_data, block_numbers, interval_hours, log_scale
+            )
+        elif json_output:
+            json_console.print(json.dumps(_generate_json_output(subnet_data)))
+        else:
+            _generate_cli_output(subnet_data, block_numbers, interval_hours, log_scale)
+    else:
+        with console.status("Fetching current price data..."):
+            if all_netuids or len(netuids) > 1:
+                all_subnet_info = await subtensor.all_subnets()
+            else:
+                all_subnet_info = [await subtensor.subnet(netuid=netuids[0])]
+        subnet_data = _process_current_subnet_data(
+            all_subnet_info, netuids, all_netuids
         )
-    elif json_output:
-        json_console.print(json.dumps(_generate_json_output(subnet_data)))
+        if json_output:
+            json_console.print(json.dumps(_generate_json_output(subnet_data)))
+        else:
+            _generate_cli_output_current(subnet_data)
+
+
+def _process_current_subnet_data(subnet_infos: list[DynamicInfo], netuids, all_netuids):
+    subnet_data = {}
+    if all_netuids or len(netuids) > 1:
+        # Most recent data for statistics
+        for subnet_info in subnet_infos:
+            stats = {
+                "current_price": subnet_info.price,
+                "supply": subnet_info.alpha_in.tao + subnet_info.alpha_out.tao,
+                "market_cap": subnet_info.price.tao
+                * (subnet_info.alpha_in.tao + subnet_info.alpha_out.tao),
+                "emission": subnet_info.emission.tao,
+                "stake": subnet_info.alpha_out.tao,
+                "symbol": subnet_info.symbol,
+                "name": get_subnet_name(subnet_info),
+            }
+            subnet_data[subnet_info.netuid] = {
+                "stats": stats,
+            }
     else:
-        _generate_cli_output(subnet_data, block_numbers, interval_hours, log_scale)
+        subnet_info = subnet_infos[0]
+        stats = {
+            "current_price": subnet_info.price.tao,
+            "supply": subnet_info.alpha_in.tao + subnet_info.alpha_out.tao,
+            "market_cap": subnet_info.price.tao
+            * (subnet_info.alpha_in.tao + subnet_info.alpha_out.tao),
+            "emission": subnet_info.emission.tao,
+            "stake": subnet_info.alpha_out.tao,
+            "symbol": subnet_info.symbol,
+            "name": get_subnet_name(subnet_info),
+        }
+        subnet_data[subnet_info.netuid] = {
+            "stats": stats,
+        }
+    return subnet_data
 
 
 def _process_subnet_data(block_numbers, all_subnet_infos, netuids, all_netuids):
@@ -626,3 +679,46 @@ def _generate_cli_output(subnet_data, block_numbers, interval_hours, log_scale):
             )
 
         console.print(stats_text)
+
+
+def _generate_cli_output_current(subnet_data):
+    for netuid, data in subnet_data.items():
+        stats = data["stats"]
+
+        if netuid != 0:
+            console.print(
+                f"\n[{COLOR_PALETTE.G.SYM}]Subnet {netuid} - {stats['symbol']} "
+                f"[cyan]{stats['name']}[/cyan][/{COLOR_PALETTE.G.SYM}]\n"
+                f"Current: [blue]{stats['current_price']:.6f}{stats['symbol']}[/blue]\n"
+            )
+        else:
+            console.print(
+                f"\n[{COLOR_PALETTE.G.SYM}]Subnet {netuid} - {stats['symbol']} "
+                f"[cyan]{stats['name']}[/cyan][/{COLOR_PALETTE.G.SYM}]\n"
+                f"Current: [blue]{stats['symbol']} {stats['current_price']:.6f}[/blue]\n"
+            )
+
+        if netuid != 0:
+            stats_text = (
+                "\nLatest stats:\n"
+                f"Supply: [{COLOR_PALETTE.P.ALPHA_IN}]"
+                f"{stats['supply']:,.2f} {stats['symbol']}[/{COLOR_PALETTE.P.ALPHA_IN}]\n"
+                f"Market Cap: [steel_blue3]{stats['market_cap']:,.2f} {stats['symbol']} / 21M[/steel_blue3]\n"
+                f"Emission: [{COLOR_PALETTE.P.EMISSION}]"
+                f"{stats['emission']:,.2f} {stats['symbol']}[/{COLOR_PALETTE.P.EMISSION}]\n"
+                f"Stake: [{COLOR_PALETTE.S.TAO}]"
+                f"{stats['stake']:,.2f} {stats['symbol']}[/{COLOR_PALETTE.S.TAO}]"
+            )
+        else:
+            stats_text = (
+                "\nLatest stats:\n"
+                f"Supply: [{COLOR_PALETTE.P.ALPHA_IN}]"
+                f"{stats['symbol']} {stats['supply']:,.2f}[/{COLOR_PALETTE.P.ALPHA_IN}]\n"
+                f"Market Cap: [steel_blue3]{stats['symbol']} {stats['market_cap']:,.2f} / 21M[/steel_blue3]\n"
+                f"Emission: [{COLOR_PALETTE.P.EMISSION}]"
+                f"{stats['symbol']} {stats['emission']:,.2f}[/{COLOR_PALETTE.P.EMISSION}]\n"
+                f"Stake: [{COLOR_PALETTE.S.TAO}]"
+                f"{stats['symbol']} {stats['stake']:,.2f}[/{COLOR_PALETTE.S.TAO}]"
+            )
+
+        console.print(stats_text)

bittensor_cli/src/commands/subnets/subnets.py

@@ -36,6 +36,7 @@ from bittensor_cli.src.bittensor.utils import (
     unlock_key,
     blocks_to_duration,
     json_console,
+    get_hotkey_pub_ss58,
 )
 
 if TYPE_CHECKING:
@@ -114,7 +115,7 @@ async def register_subnetwork_extrinsic(
             return False, None
 
     call_params = {
-        "hotkey": wallet.hotkey.ss58_address,
+        "hotkey": get_hotkey_pub_ss58(wallet),
         "mechid": 1,
     }
     call_function = "register_network"
@@ -1654,7 +1655,7 @@ async def register(
             str(netuid),
             f"{Balance.get_unit(netuid)}",
             f"τ {current_recycle.tao:.4f}",
-            f"{wallet.hotkey.ss58_address}",
+            f"{get_hotkey_pub_ss58(wallet)}",
             f"{wallet.coldkeypub.ss58_address}",
         )
         console.print(table)

bittensor_cli/src/commands/sudo.py

@@ -26,6 +26,7 @@ from bittensor_cli.src.bittensor.utils import (
     json_console,
     string_to_u16,
     string_to_u64,
+    get_hotkey_pub_ss58,
 )
 
 if TYPE_CHECKING:
@@ -176,7 +177,7 @@ async def set_hyperparameter_extrinsic(
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
     prompt: bool = True,
-) -> bool:
+) -> tuple[bool, str]:
     """Sets a hyperparameter for a specific subnetwork.
 
     :param subtensor: initialized SubtensorInterface object
@@ -199,13 +200,14 @@ async def set_hyperparameter_extrinsic(
         params=[netuid],
     )
     if subnet_owner != wallet.coldkeypub.ss58_address:
-        err_console.print(
+        err_msg = (
             ":cross_mark: [red]This wallet doesn't own the specified subnet.[/red]"
         )
-        return False
+        err_console.print(err_msg)
+        return False, err_msg
 
-    if not unlock_key(wallet).success:
-        return False
+    if not (ulw := unlock_key(wallet)).success:
+        return False, ulw.message
 
     arbitrary_extrinsic = False
 
@@ -217,15 +219,14 @@ async def set_hyperparameter_extrinsic(
         )
         extrinsic = parameter
         if not arbitrary_extrinsic:
-            err_console.print(
-                ":cross_mark: [red]Invalid hyperparameter specified.[/red]"
-            )
-            return False
+            err_msg = ":cross_mark: [red]Invalid hyperparameter specified.[/red]"
+            err_console.print(err_msg)
+            return False, err_msg
     if sudo_ and prompt:
         if not Confirm.ask(
             "This hyperparam is only settable by root sudo users. If you are not, this will fail. Please confirm"
         ):
-            return False
+            return False, "This hyperparam is only settable by root sudo users"
 
     substrate = subtensor.substrate
     msg_value = value if not arbitrary_extrinsic else call_params
@@ -253,10 +254,11 @@ async def set_hyperparameter_extrinsic(
                 ]
 
                 if len(value) < len(non_netuid_fields):
-                    err_console.print(
+                    err_msg = (
                         "Not enough values provided in the list for all parameters"
                     )
-                    return False
+                    err_console.print(err_msg)
+                    return False, err_msg
 
                 call_params.update(
                     {name: val for name, val in zip(non_netuid_fields, value)}
@@ -289,20 +291,20 @@ async def set_hyperparameter_extrinsic(
         )
         if not success:
             err_console.print(f":cross_mark: [red]Failed[/red]: {err_msg}")
-            return False
+            return False, err_msg
         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
+            return True, ""
         # Successful registration, final check for membership
         else:
             console.print(
                 f":white_heavy_check_mark: "
                 f"[dark_sea_green3]Hyperparameter {parameter} changed to {value}[/dark_sea_green3]"
             )
-            return True
+            return True, ""
 
 
 async def _get_senate_members(
@@ -497,7 +499,7 @@ async def vote_senate_extrinsic(
             call_module="SubtensorModule",
             call_function="vote",
             call_params={
-                "hotkey": wallet.hotkey.ss58_address,
+                "hotkey": get_hotkey_pub_ss58(wallet),
                 "proposal": proposal_hash,
                 "index": proposal_idx,
                 "approve": vote,
@@ -513,9 +515,10 @@ async def vote_senate_extrinsic(
         # Successful vote, final check for data
         else:
             if vote_data := await subtensor.get_vote_data(proposal_hash):
+                hotkey_ss58 = get_hotkey_pub_ss58(wallet)
                 if (
-                    vote_data.ayes.count(wallet.hotkey.ss58_address) > 0
-                    or vote_data.nays.count(wallet.hotkey.ss58_address) > 0
+                    vote_data.ayes.count(hotkey_ss58) > 0
+                    or vote_data.nays.count(hotkey_ss58) > 0
                 ):
                     console.print(":white_heavy_check_mark: [green]Vote cast.[/green]")
                     return True
@@ -617,25 +620,26 @@ async def sudo_set_hyperparameter(
     param_value: Optional[str],
     prompt: bool,
     json_output: bool,
-):
+) -> tuple[bool, str]:
     """Set subnet hyperparameters."""
     is_allowed_value, value = allowed_value(param_name, param_value)
     if not is_allowed_value:
-        err_console.print(
+        err_msg = (
             f"Hyperparameter [dark_orange]{param_name}[/dark_orange] value is not within bounds. "
             f"Value is {param_value} but must be {value}"
         )
-        return False
-    success = await set_hyperparameter_extrinsic(
+        err_console.print(err_msg)
+        return False, err_msg
+    success, err_msg = await set_hyperparameter_extrinsic(
         subtensor, wallet, netuid, param_name, value, prompt=prompt
     )
     if json_output:
-        return success
+        return success, err_msg
     if success:
         console.print("\n")
         print_verbose("Fetching hyperparameters")
         await get_hyperparameters(subtensor, netuid=netuid)
-    return success
+    return success, err_msg
 
 
 async def get_hyperparameters(
@@ -859,10 +863,9 @@ async def senate_vote(
         return False
 
     print_verbose(f"Fetching senate status of {wallet.hotkey_str}")
-    if not await _is_senate_member(subtensor, hotkey_ss58=wallet.hotkey.ss58_address):
-        err_console.print(
-            f"Aborting: Hotkey {wallet.hotkey.ss58_address} isn't a senate member."
-        )
+    hotkey_ss58 = get_hotkey_pub_ss58(wallet)
+    if not await _is_senate_member(subtensor, hotkey_ss58=hotkey_ss58):
+        err_console.print(f"Aborting: Hotkey {hotkey_ss58} isn't a senate member.")
         return False
 
     # Unlock the wallet.
@@ -890,7 +893,7 @@ async def senate_vote(
 
 
 async def get_current_take(subtensor: "SubtensorInterface", wallet: Wallet):
-    current_take = await subtensor.current_take(wallet.hotkey.ss58_address)
+    current_take = await subtensor.current_take(get_hotkey_pub_ss58(wallet))
     return current_take
 
 
@@ -912,12 +915,13 @@ async def set_take(
             return False
 
         block_hash = await subtensor.substrate.get_chain_head()
+        hotkey_ss58 = get_hotkey_pub_ss58(wallet)
         netuids_registered = await subtensor.get_netuids_for_hotkey(
-            wallet.hotkey.ss58_address, block_hash=block_hash
+            hotkey_ss58, block_hash=block_hash
         )
         if not len(netuids_registered) > 0:
             err_console.print(
-                f"Hotkey [{COLOR_PALETTE.G.HK}]{wallet.hotkey.ss58_address}[/{COLOR_PALETTE.G.HK}] is not registered to"
+                f"Hotkey [{COLOR_PALETTE.G.HK}]{hotkey_ss58}[/{COLOR_PALETTE.G.HK}] is not registered to"
                 f" any subnet. Please register using [{COLOR_PALETTE.G.SUBHEAD}]`btcli subnets register`"
                 f"[{COLOR_PALETTE.G.SUBHEAD}] and try again."
             )
@@ -926,7 +930,7 @@ async def set_take(
         result: bool = await set_take_extrinsic(
             subtensor=subtensor,
             wallet=wallet,
-            delegate_ss58=wallet.hotkey.ss58_address,
+            delegate_ss58=hotkey_ss58,
             take=take,
         )
 

bittensor_cli/src/commands/wallets.py

@@ -3,7 +3,7 @@ import itertools
 import json
 import os
 from collections import defaultdict
-from typing import Generator, Optional
+from typing import Generator, Optional, Union
 
 import aiohttp
 from bittensor_wallet import Wallet, Keypair
@@ -48,6 +48,7 @@ from bittensor_cli.src.bittensor.utils import (
     WalletLike,
     blocks_to_duration,
     decode_account_id,
+    get_hotkey_pub_ss58,
 )
 
 
@@ -159,7 +160,7 @@ async def regen_coldkey(
                                 "name": new_wallet.name,
                                 "path": new_wallet.path,
                                 "hotkey": new_wallet.hotkey_str,
-                                "hotkey_ss58": new_wallet.hotkey.ss58_address,
+                                "hotkey_ss58": get_hotkey_pub_ss58(new_wallet),
                                 "coldkey_ss58": new_wallet.coldkeypub.ss58_address,
                             },
                             "error": "",
@@ -209,7 +210,7 @@ async def regen_coldkey_pub(
                                 "name": new_coldkeypub.name,
                                 "path": new_coldkeypub.path,
                                 "hotkey": new_coldkeypub.hotkey_str,
-                                "hotkey_ss58": new_coldkeypub.hotkey.ss58_address,
+                                "hotkey_ss58": get_hotkey_pub_ss58(new_coldkeypub),
                                 "coldkey_ss58": new_coldkeypub.coldkeypub.ss58_address,
                             },
                             "error": "",
@@ -255,7 +256,7 @@ async def regen_hotkey(
             console.print(
                 "\n✅ [dark_sea_green]Regenerated hotkey successfully!\n",
                 f"[dark_sea_green]Wallet name: ({new_hotkey_.name}), path: ({new_hotkey_.path}), "
-                f"hotkey ss58: ({new_hotkey_.hotkey.ss58_address})",
+                f"hotkey ss58: ({new_hotkey_.hotkeypub.ss58_address})",
             )
             if json_output:
                 json_console.print(
@@ -266,7 +267,7 @@ async def regen_hotkey(
                                 "name": new_hotkey_.name,
                                 "path": new_hotkey_.path,
                                 "hotkey": new_hotkey_.hotkey_str,
-                                "hotkey_ss58": new_hotkey_.hotkey.ss58_address,
+                                "hotkey_ss58": new_hotkey_.hotkeypub.ss58_address,
                                 "coldkey_ss58": new_hotkey_.coldkeypub.ss58_address,
                             },
                             "error": "",
@@ -287,6 +288,50 @@ async def regen_hotkey(
             )
 
 
+async def regen_hotkey_pub(
+    wallet: Wallet,
+    ss58_address: str,
+    public_key_hex: str,
+    overwrite: Optional[bool] = False,
+    json_output: bool = False,
+):
+    """Creates a new hotkeypub under this wallet."""
+    try:
+        new_hotkeypub = wallet.regenerate_hotkeypub(
+            ss58_address=ss58_address,
+            public_key=public_key_hex,
+            overwrite=overwrite,
+        )
+        if isinstance(new_hotkeypub, Wallet):
+            console.print(
+                "\n✅ [dark_sea_green]Regenerated coldkeypub successfully!\n",
+                f"[dark_sea_green]Wallet name: ({new_hotkeypub.name}), path: ({new_hotkeypub.path}), "
+                f"coldkey ss58: ({new_hotkeypub.coldkeypub.ss58_address})",
+            )
+            if json_output:
+                json_console.print(
+                    json.dumps(
+                        {
+                            "success": True,
+                            "data": {
+                                "name": new_hotkeypub.name,
+                                "path": new_hotkeypub.path,
+                                "hotkey": new_hotkeypub.hotkey_str,
+                                "hotkey_ss58": new_hotkeypub.hotkeypub.ss58_address,
+                                "coldkey_ss58": new_hotkeypub.coldkeypub.ss58_address,
+                            },
+                            "error": "",
+                        }
+                    )
+                )
+    except KeyFileError:
+        print_error("KeyFileError: File is not writable")
+        if json_output:
+            json_console.print(
+                '{"success": false, "error": "Keyfile is not writable", "data": null}'
+            )
+
+
 async def new_hotkey(
     wallet: Wallet,
     n_words: int,
@@ -323,7 +368,7 @@ async def new_hotkey(
                             "name": wallet.name,
                             "path": wallet.path,
                             "hotkey": wallet.hotkey_str,
-                            "hotkey_ss58": wallet.hotkey.ss58_address,
+                            "hotkey_ss58": get_hotkey_pub_ss58(wallet),
                             "coldkey_ss58": wallet.coldkeypub.ss58_address,
                         },
                         "error": "",
@@ -402,19 +447,26 @@ async def wallet_create(
     json_output: bool = False,
 ):
     """Creates a new wallet."""
-    output_dict = {"success": False, "error": "", "data": None}
+    output_dict: dict[str, Optional[Union[bool, str, dict]]] = {
+        "success": False,
+        "error": "",
+        "data": None,
+    }
+
     if uri:
         try:
             keypair = Keypair.create_from_uri(uri)
-            wallet.set_coldkey(keypair=keypair, encrypt=False, overwrite=False)
-            wallet.set_coldkeypub(keypair=keypair, encrypt=False, overwrite=False)
-            wallet.set_hotkey(keypair=keypair, encrypt=False, overwrite=False)
+            wallet.set_coldkey(keypair=keypair, encrypt=False, overwrite=overwrite)
+            wallet.set_coldkeypub(keypair=keypair, encrypt=False, overwrite=overwrite)
+            wallet.set_hotkey(keypair=keypair, encrypt=False, overwrite=overwrite)
+            wallet.set_hotkeypub(keypair=keypair, encrypt=False, overwrite=overwrite)
+            wallet.set_coldkeypub(keypair=keypair, encrypt=False, overwrite=overwrite)
             output_dict["success"] = True
             output_dict["data"] = {
                 "name": wallet.name,
                 "path": wallet.path,
                 "hotkey": wallet.hotkey_str,
-                "hotkey_ss58": wallet.hotkey.ss58_address,
+                "hotkey_ss58": wallet.hotkeypub.ss58_address,
                 "coldkey_ss58": wallet.coldkeypub.ss58_address,
             }
         except Exception as e:
@@ -455,7 +507,7 @@ async def wallet_create(
                 "name": wallet.name,
                 "path": wallet.path,
                 "hotkey": wallet.hotkey_str,
-                "hotkey_ss58": wallet.hotkey.ss58_address,
+                "hotkey_ss58": wallet.hotkeypub.ss58_address,
             }
         except KeyFileError as error:
             err = str(error)
@@ -794,13 +846,14 @@ async def wallet_list(wallet_path: str, json_output: bool):
             data = f"[bold red]Hotkey[/bold red][green] {hkey}[/green] (?)"
             hk_data = {"name": hkey.name, "ss58_address": "?"}
             if hkey:
+                hkey_ss58 = get_hotkey_pub_ss58(hkey)
                 try:
                     data = (
                         f"[bold red]Hotkey[/bold red] [green]{hkey.hotkey_str}[/green]  "
-                        f"ss58_address [green]{hkey.hotkey.ss58_address}[/green]\n"
+                        f"ss58_address [green]{hkey_ss58}[/green]\n"
                     )
                     hk_data["name"] = hkey.hotkey_str
-                    hk_data["ss58_address"] = hkey.hotkey.ss58_address
+                    hk_data["ss58_address"] = hkey_ss58
                 except UnicodeDecodeError:
                     pass
             wallet_tree.add(data)
@@ -1253,7 +1306,7 @@ def _get_hotkeys(
 
     def is_hotkey_matched(wallet: Wallet, item: str) -> bool:
         if is_valid_ss58_address(item):
-            return wallet.hotkey.ss58_address == item
+            return get_hotkey_pub_ss58(wallet) == item
         else:
             return wallet.hotkey_str == item
 
@@ -1285,9 +1338,10 @@ def _get_key_address(all_hotkeys: list[Wallet]) -> tuple[list[str], dict[str, Wa
     hotkey_coldkey_to_hotkey_wallet = {}
     for hotkey_wallet in all_hotkeys:
         if hotkey_wallet.coldkeypub:
-            if hotkey_wallet.hotkey.ss58_address not in hotkey_coldkey_to_hotkey_wallet:
-                hotkey_coldkey_to_hotkey_wallet[hotkey_wallet.hotkey.ss58_address] = {}
-            hotkey_coldkey_to_hotkey_wallet[hotkey_wallet.hotkey.ss58_address][
+            hotkey_ss58 = get_hotkey_pub_ss58(hotkey_wallet)
+            if hotkey_ss58 not in hotkey_coldkey_to_hotkey_wallet:
+                hotkey_coldkey_to_hotkey_wallet[hotkey_ss58] = {}
+            hotkey_coldkey_to_hotkey_wallet[hotkey_ss58][
                 hotkey_wallet.coldkeypub.ss58_address
             ] = hotkey_wallet
         else:
@@ -1471,7 +1525,7 @@ async def inspect(
                     if hotkey_names := [
                         w.hotkey_str
                         for w in hotkeys
-                        if w.hotkey.ss58_address == n.hotkey
+                        if get_hotkey_pub_ss58(w) == n.hotkey
                     ]:
                         hotkey_name = f"{hotkey_names[0]}-"
                     yield [""] * 5 + [

bittensor_cli/src/commands/weights.py

@@ -15,6 +15,7 @@ from bittensor_cli.src.bittensor.utils import (
     console,
     format_error_message,
     json_console,
+    get_hotkey_pub_ss58,
 )
 from bittensor_cli.src.bittensor.extrinsics.root import (
     convert_weights_and_uids_for_emit,
@@ -128,7 +129,7 @@ class SetWeightsExtrinsic:
 
         # Generate the hash of the weights
         commit_hash = generate_weight_hash(
-            address=self.wallet.hotkey.ss58_address,
+            address=get_hotkey_pub_ss58(self.wallet),
             netuid=self.netuid,
             uids=uids,
             values=weights,

{bittensor_cli-9.9.0.dist-info → bittensor_cli-9.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bittensor-cli
-Version: 9.9.0
+Version: 9.10.1
 Summary: Bittensor CLI
 Author: bittensor.com
 Project-URL: homepage, https://github.com/opentensor/btcli
@@ -11,7 +11,6 @@ Requires-Dist: wheel
 Requires-Dist: async-substrate-interface>=1.4.2
 Requires-Dist: aiohttp~=3.10.2
 Requires-Dist: backoff~=2.2.1
-Requires-Dist: click<8.2.0
 Requires-Dist: GitPython>=3.0.0
 Requires-Dist: netaddr~=1.3.0
 Requires-Dist: numpy<3.0.0,>=2.0.1
@@ -20,8 +19,9 @@ Requires-Dist: pycryptodome<4.0.0,>=3.0.0
 Requires-Dist: PyYAML~=6.0.1
 Requires-Dist: rich<15.0,>=13.7
 Requires-Dist: scalecodec==1.2.11
-Requires-Dist: typer<0.16,>=0.12
-Requires-Dist: bittensor-wallet>=3.0.7
+Requires-Dist: typer>=0.16
+Requires-Dist: bittensor-wallet>=4.0.0
+Requires-Dist: packaging
 Requires-Dist: plotille>=5.0.0
 Requires-Dist: plotly>=6.0.0
 Provides-Extra: cuda
@@ -71,7 +71,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/)