bittensor-cli 8.2.0rc9__tar.gz → 8.2.0rc11__tar.gz

{bittensor-cli-8.2.0rc9 → bittensor-cli-8.2.0rc11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bittensor-cli
-Version: 8.2.0rc9
+Version: 8.2.0rc11
 Summary: Bittensor CLI
 Home-page: https://github.com/opentensor/btcli
 Author: bittensor.com

{bittensor-cli-8.2.0rc9 → bittensor-cli-8.2.0rc11}/bittensor_cli/__init__.py

@@ -18,6 +18,6 @@
 from .cli import CLIManager
 
 
-__version__ = "8.2.0rc9"
+__version__ = "8.2.0rc11"
 
 __all__ = ["CLIManager", "__version__"]

{bittensor-cli-8.2.0rc9 → bittensor-cli-8.2.0rc11}/bittensor_cli/cli.py

@@ -62,7 +62,7 @@ except ImportError:
         pass
 
 
-__version__ = "8.2.0rc9"
+__version__ = "8.2.0rc11"
 
 
 _core_version = re.match(r"^\d+\.\d+\.\d+", __version__).group(0)
@@ -645,12 +645,13 @@ class CLIManager:
             "balance", rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"]
         )(self.wallet_balance)
         self.wallet_app.command(
-            "history", rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"]
+            "history",
+            rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"],
+            hidden=True,
         )(self.wallet_history)
         self.wallet_app.command(
             "overview",
             rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"],
-            hidden=True,
         )(self.wallet_overview)
         self.wallet_app.command(
             "transfer", rich_help_panel=HELP_PANELS["WALLET"]["OPERATIONS"]
@@ -748,10 +749,13 @@ class CLIManager:
         )(self.subnets_register)
         self.subnets_app.command(
             "metagraph", rich_help_panel=HELP_PANELS["SUBNETS"]["INFO"], hidden=True
-        )(self.subnets_show) #Aliased to `s show` for now
+        )(self.subnets_show)  # Aliased to `s show` for now
         self.subnets_app.command(
             "show", rich_help_panel=HELP_PANELS["SUBNETS"]["INFO"]
         )(self.subnets_show)
+        self.subnets_app.command(
+            "price", rich_help_panel=HELP_PANELS["SUBNETS"]["INFO"], hidden=True
+        )(self.subnets_price)
 
         # weights commands
         self.weights_app.command(
@@ -1409,12 +1413,6 @@ class CLIManager:
                 "Hotkeys names must be a comma-separated list, e.g., `--exclude-hotkeys hk1,hk2`.",
             )
 
-        # For Rao games
-        effective_network = get_effective_network(self.config, network)
-        if is_rao_network(effective_network):
-            print_error("This command is disabled on the 'rao' network.")
-            raise typer.Exit()
-
         return self._run_command(
             wallets.overview(
                 wallet,
@@ -1425,6 +1423,7 @@ class CLIManager:
                 include_hotkeys,
                 exclude_hotkeys,
                 netuids_filter=netuids,
+                verbose=verbose,
             )
         )
 
@@ -1600,6 +1599,8 @@ class CLIManager:
 
         [bold]Note[/bold]: The `inspect` command is for displaying information only and does not perform any transactions or state changes on the blockchain. It is intended to be used with Bittensor CLI and not as a standalone function in user code.
         """
+        print_error("This command is disabled on the 'rao' network.")
+        raise typer.Exit()
         self.verbosity_handler(quiet, verbose)
 
         if netuids:
@@ -1615,11 +1616,6 @@ class CLIManager:
         wallet = self.wallet_ask(
             wallet_name, wallet_path, wallet_hotkey, ask_for=ask_for, validate=validate
         )
-        # For Rao games
-        effective_network = get_effective_network(self.config, network)
-        if is_rao_network(effective_network):
-            print_error("This command is disabled on the 'rao' network.")
-            raise typer.Exit()
 
         self.initialize_chain(network)
         return self._run_command(
@@ -2791,7 +2787,7 @@ class CLIManager:
         [blue bold]Note[/blue bold]: This command is for users who wish to reallocate their stake or withdraw them from the network. It allows for flexible management of TAO stake across different neurons (hotkeys) on the network.
         """
         self.verbosity_handler(quiet, verbose)
-        # TODO: Coldkey related unstakes need to be updated. Patching for now. 
+        # TODO: Coldkey related unstakes need to be updated. Patching for now.
         unstake_all_alpha = False
         unstake_all = False
 
@@ -3562,6 +3558,28 @@ class CLIManager:
             )
         )
 
+    def subnets_price(
+        self,
+        network: Optional[list[str]] = Options.network,
+        netuid: int = Options.netuid,
+        interval_hours: int = typer.Option(
+            24,
+            "--interval-hours",
+            "--interval",
+            help="The number of hours to show the historical price for.",
+        ),
+    ):
+        """
+        Shows the historical price of a subnet for the past 24 hours.
+
+        EXAMPLE
+
+        [green]$[/green] btcli subnets price --netuid 1
+        """
+        return self._run_command(
+            subnets.price(self.initialize_chain(network), netuid, interval_hours)
+        )
+
     def subnets_show(
         self,
         network: Optional[list[str]] = Options.network,

{bittensor-cli-8.2.0rc9 → bittensor-cli-8.2.0rc11}/bittensor_cli/src/bittensor/chain_data.py

@@ -97,11 +97,13 @@ def decode_hex_identity(info_dictionary):
     return decoded_info
 
 
-def process_stake_data(stake_data):
+def process_stake_data(stake_data, netuid):
     decoded_stake_data = {}
     for account_id_bytes, stake_ in stake_data:
         account_id = decode_account_id(account_id_bytes)
-        decoded_stake_data.update({account_id: Balance.from_rao(stake_)})
+        decoded_stake_data.update(
+            {account_id: Balance.from_rao(stake_).set_unit(netuid)}
+        )
     return decoded_stake_data
 
 
@@ -371,7 +373,7 @@ class NeuronInfo:
     @classmethod
     def from_vec_u8(cls, vec_u8: bytes) -> "NeuronInfo":
         n = bt_decode.NeuronInfo.decode(vec_u8)
-        stake_dict = process_stake_data(n.stake)
+        stake_dict = process_stake_data(n.stake, n.netuid)
         total_stake = sum(stake_dict.values()) if stake_dict else Balance(0)
         axon_info = n.axon_info
         coldkey = decode_account_id(n.coldkey)
@@ -491,8 +493,12 @@ class NeuronInfoLite:
             prometheus_info = item.prometheus_info
             pruning_score = item.pruning_score
             rank = item.rank
-            stake_dict = process_stake_data(item.stake)
-            stake = sum(stake_dict.values()) if stake_dict else Balance(0)
+            stake_dict = process_stake_data(item.stake, item.netuid)
+            stake = (
+                sum(stake_dict.values())
+                if stake_dict
+                else Balance(0).set_unit(item.netuid)
+            )
             trust = item.trust
             uid = item.uid
             validator_permit = item.validator_permit
@@ -899,7 +905,7 @@ class DynamicInfo:
     def from_vec_u8(cls, vec_u8: list[int]) -> Optional["DynamicInfo"]:
         if len(vec_u8) == 0:
             return None
-        decoded = from_scale_encoding(vec_u8, ChainDataType.DynamicInfo, is_option=True)
+        decoded = from_scale_encoding(vec_u8, ChainDataType.DynamicInfo)
         if decoded is None:
             return None
         return DynamicInfo.fix_decoded_values(decoded)

{bittensor-cli-8.2.0rc9 → bittensor-cli-8.2.0rc11}/bittensor_cli/src/bittensor/subtensor_interface.py

@@ -1392,10 +1392,11 @@ class SubtensorInterface:
 
         return StakeInfo.list_of_tuple_from_vec_u8(bytes_result)  # type: ignore
 
-    async def get_all_subnet_dynamic_info(self) -> list["DynamicInfo"]:
+    async def get_all_subnet_dynamic_info(self, block_hash: Optional[str] = None) -> list["DynamicInfo"]:
         query = await self.substrate.runtime_call(
             "SubnetInfoRuntimeApi",
             "get_all_dynamic_info",
+            block_hash=block_hash,
         )
         subnets = DynamicInfo.list_from_vec_u8(bytes.fromhex(query.decode()[2:]))
         return subnets

{bittensor-cli-8.2.0rc9 → bittensor-cli-8.2.0rc11}/bittensor_cli/src/commands/stake/stake.py

@@ -10,11 +10,11 @@ from rich.prompt import Confirm, FloatPrompt, Prompt
 from rich.table import Table
 from rich import box
 from rich.progress import Progress, BarColumn, TextColumn
-from rich.console import Console, Group
+from rich.console import Group
 from rich.live import Live
 from substrateinterface.exceptions import SubstrateRequestException
 
-from bittensor_cli.src import COLOR_PALETTE, SUBNETS
+from bittensor_cli.src import COLOR_PALETTE
 from bittensor_cli.src.bittensor.balances import Balance
 from bittensor_cli.src.bittensor.chain_data import StakeInfo
 from bittensor_cli.src.bittensor.utils import (
@@ -1999,7 +1999,7 @@ async def stake_list(
         (
             substakes,
             registered_delegate_info,
-            dynamic_info,
+            _dynamic_info,
         ) = await asyncio.gather(
             subtensor.get_stake_info_for_coldkeys(
                 coldkey_ss58_list=[coldkey_address], block_hash=block_hash
@@ -2008,6 +2008,7 @@ async def stake_list(
             subtensor.get_all_subnet_dynamic_info(),
         )
         sub_stakes = substakes[coldkey_address]
+        dynamic_info = {info.netuid: info for info in _dynamic_info}
         return (
             sub_stakes,
             registered_delegate_info,
@@ -2195,9 +2196,7 @@ async def stake_list(
                         f"{stake_value} {symbol}"
                         if netuid != 0
                         else f"{symbol} {stake_value}",  # Stake (a)
-                        f"{millify_tao(pool.price.tao)} τ/{symbol}"
-                        if not verbose
-                        else f"{pool.price.tao:.4f} τ/{symbol}",  # Rate (t/a)
+                        f"{pool.price.tao:.4f} τ/{symbol}",  # Rate (t/a)
                         # f"τ {millify_tao(tao_ownership.tao)}" if not verbose else f"{tao_ownership}",  # TAO equiv
                         swap_value,  # Swap(α) -> τ
                         "YES"
@@ -2425,6 +2424,10 @@ async def stake_list(
             hotkeys_to_substakes[hotkey] = []
         hotkeys_to_substakes[hotkey].append(substake)
 
+    if not hotkeys_to_substakes:
+        print_error(f"No stakes found for coldkey ss58: ({coldkey_address})")
+        raise typer.Exit()
+
     if live:
         # Select one hokkey for live monitoring
         if len(hotkeys_to_substakes) > 1:
@@ -2483,7 +2486,6 @@ async def stake_list(
                         if stake.hotkey_ss58 == selected_hotkey
                     ]
 
-                    dynamic_info = {info.netuid: info for info in dynamic_info_}
                     block_number = await subtensor.substrate.get_block_number(None)
 
                     previous_block = current_block

{bittensor-cli-8.2.0rc9 → bittensor-cli-8.2.0rc11}/bittensor_cli/src/commands/subnets.py

@@ -3,18 +3,17 @@ import json
 import sqlite3
 from typing import TYPE_CHECKING, Optional, cast
 import typer
+import plotille
 
 from bittensor_wallet import Wallet
 from bittensor_wallet.errors import KeyFileError
 from rich.prompt import Confirm, Prompt
-from rich.console import Console, Group
-from rich.spinner import Spinner
-from rich.text import Text
+from rich.console import Group
 from rich.progress import Progress, BarColumn, TextColumn
 from rich.table import Column, Table
 from rich import box
 
-from bittensor_cli.src import COLOR_PALETTE, SUBNETS
+from bittensor_cli.src import COLOR_PALETTE
 from bittensor_cli.src.bittensor.balances import Balance
 from bittensor_cli.src.bittensor.chain_data import SubnetState
 from bittensor_cli.src.bittensor.extrinsics.registration import (
@@ -26,7 +25,6 @@ from rich.live import Live
 from bittensor_cli.src.bittensor.minigraph import MiniGraph
 from bittensor_cli.src.commands.wallets import set_id, get_id
 from bittensor_cli.src.bittensor.utils import (
-    RAO_PER_TAO,
     console,
     create_table,
     err_console,
@@ -228,7 +226,9 @@ async def subnets_list(
         if not verbose:
             percentage_string = f"τ {millify_tao(total_tao_emitted)}/{millify_tao(block_number)} ({formatted_percentage})"
         else:
-            percentage_string = f"τ {total_tao_emitted:.1f}/{block_number} ({formatted_percentage})"
+            percentage_string = (
+                f"τ {total_tao_emitted:.1f}/{block_number} ({formatted_percentage})"
+            )
         return total_tao_emitted, percentage_string
 
     def define_table(
@@ -323,11 +323,7 @@ async def subnets_list(
                 if not verbose
                 else f"{subnet.alpha_out.tao:,.4f}"
             )
-            price_value = (
-                f"{millify_tao(subnet.price.tao)}"
-                if not verbose
-                else f"{subnet.price.tao:,.4f}"
-            )
+            price_value = f"{subnet.price.tao:,.4f}"
 
             # Market Cap
             market_cap = (subnet.alpha_in.tao + subnet.alpha_out.tao) * subnet.price.tao
@@ -345,8 +341,8 @@ async def subnets_list(
                 if netuid != 0
                 else "-"
             )
-
             alpha_in_cell = f"{alpha_in_value} {symbol}" if netuid != 0 else "-"
+            liquidity_cell = f"{tao_in_cell}, {alpha_in_cell}"
 
             # Supply
             supply = subnet.alpha_in.tao + subnet.alpha_out.tao
@@ -360,7 +356,6 @@ async def subnets_list(
             )
             emission_cell = f"τ {emission_tao:,.4f}"
             price_cell = f"{price_value} τ/{symbol}"
-            liquidity_cell = f"{tao_in_cell}, {alpha_in_cell}"
             alpha_out_cell = (
                 f"{alpha_out_value} {symbol}"
                 if netuid != 0
@@ -534,7 +529,7 @@ async def subnets_list(
                 "supply": supply,
                 "blocks_since_last_step": subnet.blocks_since_last_step,
             }
-            prev = previous_data.get(netuid) if previous_data else {}
+            prev = previous_data.get(netuid, {}) if previous_data else {}
 
             # Prepare cells
             if netuid == 0:
@@ -559,7 +554,7 @@ async def subnets_list(
                 prev.get("price"),
                 unit=f"τ/{symbol}",
                 precision=4,
-                millify=True if not verbose else False,
+                millify=False,
             )
 
             alpha_out_cell = format_cell(
@@ -1055,9 +1050,7 @@ async def show(
             print_error(f"Subnet {netuid_} does not exist")
             raise typer.Exit()
         elif len(subnet_state.hotkeys) == 0:
-            print_error(
-                f"Subnet {netuid_} is currently empty with 0 UIDs registered."
-            )
+            print_error(f"Subnet {netuid_} is currently empty with 0 UIDs registered.")
             raise typer.Exit()
 
         # Define table properties
@@ -1158,7 +1151,7 @@ async def show(
             ):
                 if uid_identity == "~":
                     uid_identity = (
-                        f"[dark_sea_green3](*Owner controlled)[/dark_sea_green3]"
+                        "[dark_sea_green3](*Owner controlled)[/dark_sea_green3]"
                     )
                 else:
                     uid_identity = (
@@ -1176,7 +1169,9 @@ async def show(
                     f"{subnet_state.alpha_stake[idx].tao:.4f} {subnet_info.symbol}"
                     if verbose
                     else f"{millify_tao(subnet_state.alpha_stake[idx])} {subnet_info.symbol}",  # Alpha Stake
-                    f"τ {tao_stake.tao:.4f}" if verbose else f"τ {millify_tao(tao_stake)}",  # Tao Stake
+                    f"τ {tao_stake.tao:.4f}"
+                    if verbose
+                    else f"τ {millify_tao(tao_stake)}",  # Tao Stake
                     # str(subnet_state.dividends[idx]),
                     f"{Balance.from_tao(hotkey_block_emission).set_unit(netuid_).tao:.5f}",  # Dividends
                     f"{subnet_state.incentives[idx]:.4f}",  # Incentive
@@ -1302,22 +1297,22 @@ async def show(
                 # f"\n  Stake: [{COLOR_PALETTE['STAKE']['STAKE_ALPHA']}]{subnet_info.alpha_out.tao:,.5f} {subnet_info.symbol}[/{COLOR_PALETTE['STAKE']['STAKE_ALPHA']}]"
                 f"\n  Tempo: [{COLOR_PALETTE['STAKE']['STAKE_ALPHA']}]{subnet_info.blocks_since_last_step}/{subnet_info.tempo}[/{COLOR_PALETTE['STAKE']['STAKE_ALPHA']}]"
             )
-    #         console.print(
-    #             """
-    # Description:
-    #     The table displays the subnet participants and their metrics.
-    #     The columns are as follows:
-    #         - UID: The hotkey index in the subnet.
-    #         - TAO: The sum of all TAO balances for this hotkey accross all subnets. 
-    #         - Stake: The stake balance of this hotkey on this subnet.
-    #         - Weight: The stake-weight of this hotkey on this subnet. Computed as an average of the normalized TAO and Stake columns of this subnet.
-    #         - Dividends: Validating dividends earned by the hotkey.
-    #         - Incentives: Mining incentives earned by the hotkey (always zero in the RAO demo.)
-    #         - Emission: The emission accrued to this hokey on this subnet every block (in staking units).
-    #         - Hotkey: The hotkey ss58 address.
-    #         - Coldkey: The coldkey ss58 address.
-    # """
-            # )
+        #         console.print(
+        #             """
+        # Description:
+        #     The table displays the subnet participants and their metrics.
+        #     The columns are as follows:
+        #         - UID: The hotkey index in the subnet.
+        #         - TAO: The sum of all TAO balances for this hotkey accross all subnets.
+        #         - Stake: The stake balance of this hotkey on this subnet.
+        #         - Weight: The stake-weight of this hotkey on this subnet. Computed as an average of the normalized TAO and Stake columns of this subnet.
+        #         - Dividends: Validating dividends earned by the hotkey.
+        #         - Incentives: Mining incentives earned by the hotkey (always zero in the RAO demo.)
+        #         - Emission: The emission accrued to this hokey on this subnet every block (in staking units).
+        #         - Hotkey: The hotkey ss58 address.
+        #         - Coldkey: The coldkey ss58 address.
+        # """
+        # )
 
         if delegate_selection:
             while True:
@@ -2056,3 +2051,116 @@ async def metagraph_cmd(
                 table.add_row(*row)
 
         console.print(table)
+
+
+async def price(
+    subtensor: "SubtensorInterface",
+    netuid: int,
+    interval_hours: int = 24,
+):
+    """Plot historical subnet price data in the CLI."""
+
+    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)
+
+        # Block range
+        step = 300
+        start_block = max(0, current_block - total_blocks)
+        block_numbers = range(start_block, current_block + 1, step)
+
+        # Fetch all block hashes
+        block_hash_cors = [
+            subtensor.substrate.get_block_hash(bn) for bn in block_numbers
+        ]
+        block_hashes = await asyncio.gather(*block_hash_cors)
+
+        # Fetch subnet data for each block
+        subnet_info_cors = [
+            subtensor.get_subnet_dynamic_info(netuid, bh) for bh in block_hashes
+        ]
+        subnet_infos = await asyncio.gather(*subnet_info_cors)
+
+        prices = []
+        for subnet_info in subnet_infos:
+            prices.append(subnet_info.price.tao)
+
+    if not prices:
+        err_console.print(f"[red]No price data found for subnet {netuid}[/red]")
+        return
+
+    fig = plotille.Figure()
+    fig.width = 60
+    fig.height = 20
+    fig.color_mode = "rgb"
+    fig.background = None
+
+    block_numbers = list(range(current_block - total_blocks, current_block + 1, step))
+
+    def color_label(text):
+        return plotille.color(text, fg=(186, 233, 143), mode="rgb")  # Green
+
+    fig.x_label = color_label("Block")
+    fig.y_label = color_label(f"Price ({Balance.get_unit(netuid)})")
+
+    fig.set_x_limits(min_=min(block_numbers), max_=max(block_numbers))
+    fig.set_y_limits(min_=min(prices) * 0.95, max_=max(prices) * 1.05)
+
+    fig.plot(
+        block_numbers,
+        prices,
+        label=f"Subnet {netuid} Price",
+        interp="linear",
+        lc="bae98f",  # Green hex
+    )
+
+    subnet = subnet_infos[-1]
+    console.print(
+        f"\n[{COLOR_PALETTE['GENERAL']['SYMBOL']}]Subnet {netuid} - {subnet.symbol} [cyan]{get_subnet_name(subnet)}"
+    )
+    console.print(
+        f"Current: [blue]{prices[-1]:.6f}{Balance.get_unit(netuid)}"
+        if netuid != 0
+        else f"Current: [blue]{Balance.get_unit(netuid)} {prices[-1]:.6f}"
+    )
+    console.print(
+        f"{interval_hours}h High: [dark_sea_green3]{max(prices):.6f}{Balance.get_unit(netuid)}"
+        if netuid != 0
+        else f"{interval_hours}h High: [dark_sea_green3]{Balance.get_unit(netuid)} {max(prices):.6f}"
+    )
+    console.print(
+        f"{interval_hours}h Low: [red]{min(prices):.6f}{Balance.get_unit(netuid)}"
+        if netuid != 0
+        else f"{interval_hours}h Low: [red]{Balance.get_unit(netuid)} {min(prices):.6f}"
+    )
+
+    change_color = "dark_sea_green3" if prices[-1] > prices[0] else "red"
+    console.print(
+        f"{interval_hours}h Change: "
+        f"[{change_color}]{((prices[-1] - prices[0]) / prices[0] * 100):.2f}%\n"
+    )
+    print(fig.show())
+    console.print("\nLatest stats:")
+    console.print(
+        f"Supply: [{COLOR_PALETTE['POOLS']['ALPHA_IN']}]{subnet.alpha_in.tao + subnet.alpha_out.tao:,.2f} {Balance.get_unit(netuid)}"
+        if netuid != 0
+        else f"Supply: [{COLOR_PALETTE['POOLS']['ALPHA_IN']}]{Balance.get_unit(netuid)} {subnet.alpha_in.tao + subnet.alpha_out.tao:,.2f}"
+    )
+    console.print(
+        f"Market Cap: [steel_blue3]{subnet.price.tao * (subnet.alpha_in.tao + subnet.alpha_out.tao):,.2f} {Balance.get_unit(netuid)} / 21M"
+        if netuid != 0
+        else f"Market Cap: [steel_blue3]{Balance.get_unit(netuid)} {subnet.price.tao * (subnet.alpha_in.tao + subnet.alpha_out.tao):,.2f} / 21M"
+    )
+    console.print(
+        f"Emission: [{COLOR_PALETTE['POOLS']['EMISSION']}]{subnet.emission.tao:,.2f} {Balance.get_unit(netuid)}"
+        if netuid != 0
+        else f"Emission: [{COLOR_PALETTE['POOLS']['EMISSION']}]{Balance.get_unit(netuid)} {subnet.emission.tao:,.2f}"
+    )
+    console.print(
+        f"Stake: [{COLOR_PALETTE['STAKE']['TAO']}]{subnet.alpha_out.tao:,.2f} {Balance.get_unit(netuid)}"
+        if netuid != 0
+        else f"Stake: [{COLOR_PALETTE['STAKE']['TAO']}]{Balance.get_unit(netuid)} {subnet.alpha_out.tao:,.2f}"
+    )

{bittensor-cli-8.2.0rc9 → bittensor-cli-8.2.0rc11}/bittensor_cli/src/commands/sudo.py

@@ -9,7 +9,7 @@ from rich.table import Column, Table
 from rich.prompt import Confirm
 from scalecodec import GenericCall
 
-from bittensor_cli.src import HYPERPARAMS, DelegatesDetails, COLOR_PALETTE, SUBNETS
+from bittensor_cli.src import HYPERPARAMS, DelegatesDetails, COLOR_PALETTE
 from bittensor_cli.src.bittensor.chain_data import decode_account_id
 from bittensor_cli.src.bittensor.utils import (
     console,
@@ -445,7 +445,9 @@ async def set_take_extrinsic(
     if not success:
         err_console.print(err)
     else:
-        console.print(":white_heavy_check_mark: [dark_sea_green_3]Finalized[/dark_sea_green_3]")
+        console.print(
+            ":white_heavy_check_mark: [dark_sea_green_3]Finalized[/dark_sea_green_3]"
+        )
     return success
 
 
@@ -502,9 +504,9 @@ async def get_hyperparameters(subtensor: "SubtensorInterface", netuid: int):
         raise typer.Exit()
 
     table = Table(
-        Column("[white]HYPERPARAMETER", style=COLOR_PALETTE['SUDO']['HYPERPARAMETER']),
-        Column("[white]VALUE", style=COLOR_PALETTE['SUDO']['VALUE']),
-        Column("[white]NORMALIZED", style=COLOR_PALETTE['SUDO']['NORMALIZED']),
+        Column("[white]HYPERPARAMETER", style=COLOR_PALETTE["SUDO"]["HYPERPARAMETER"]),
+        Column("[white]VALUE", style=COLOR_PALETTE["SUDO"]["VALUE"]),
+        Column("[white]NORMALIZED", style=COLOR_PALETTE["SUDO"]["NORMALIZED"]),
         title=f"[{COLOR_PALETTE['GENERAL']['HEADER']}]\nSubnet Hyperparameters\n NETUID: "
         f"[{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{netuid}"
         f"{f' ({subnet_info.subnet_name})' if subnet_info.subnet_name is not None else ''}"
@@ -716,10 +718,14 @@ async def set_take(
             return False
         else:
             new_take = await get_current_take(subtensor, wallet)
-            console.print(f"New take is [{COLOR_PALETTE['POOLS']['RATE']}]{new_take * 100.:.2f}%")
+            console.print(
+                f"New take is [{COLOR_PALETTE['POOLS']['RATE']}]{new_take * 100.:.2f}%"
+            )
             return True
 
-    console.print(f"Setting take on [{COLOR_PALETTE['GENERAL']['LINKS']}]network: {subtensor.network}")
+    console.print(
+        f"Setting take on [{COLOR_PALETTE['GENERAL']['LINKS']}]network: {subtensor.network}"
+    )
 
     try:
         wallet.unlock_hotkey()

{bittensor-cli-8.2.0rc9 → bittensor-cli-8.2.0rc11}/bittensor_cli/src/commands/wallets.py

@@ -1,12 +1,7 @@
 import asyncio
-import binascii
 import itertools
 import os
-import sys
 from collections import defaultdict
-from concurrent.futures import ProcessPoolExecutor
-from functools import partial
-from sys import getsizeof
 from typing import Any, Collection, Generator, Optional
 
 import aiohttp
@@ -16,29 +11,23 @@ from bittensor_wallet.keyfile import Keyfile
 from fuzzywuzzy import fuzz
 from rich import box
 from rich.align import Align
-from rich.prompt import Confirm, Prompt
 from rich.table import Column, Table
 from rich.tree import Tree
 from rich.padding import Padding
-from rich.prompt import IntPrompt
 from scalecodec import ScaleBytes
-import scalecodec
 import typer
 
-from bittensor_cli.src import TYPE_REGISTRY, COLOR_PALETTE
+from bittensor_cli.src import COLOR_PALETTE
 from bittensor_cli.src.bittensor import utils
 from bittensor_cli.src.bittensor.balances import Balance
 from bittensor_cli.src.bittensor.chain_data import (
     DelegateInfo,
     NeuronInfoLite,
     StakeInfo,
-    custom_rpc_type_registry,
-    decode_account_id,
 )
 from bittensor_cli.src.bittensor.extrinsics.registration import (
     run_faucet_extrinsic,
     swap_hotkey_extrinsic,
-    is_hotkey_registered,
 )
 from bittensor_cli.src.bittensor.extrinsics.transfer import transfer_extrinsic
 from bittensor_cli.src.bittensor.networking import int_to_ip
@@ -47,7 +36,6 @@ from bittensor_cli.src.bittensor.utils import (
     RAO_PER_TAO,
     console,
     convert_blocks_to_time,
-    decode_scale_bytes,
     err_console,
     print_error,
     print_verbose,
@@ -55,10 +43,18 @@ from bittensor_cli.src.bittensor.utils import (
     get_hotkey_wallets_for_wallet,
     is_valid_ss58_address,
     validate_coldkey_presence,
-    retry_prompt,
+    get_subnet_name,
+    millify_tao,
 )
 
 
+class WalletLike:
+    def __init__(self, name=None, hotkey_ss58=None, hotkey_str=None):
+        self.name = name
+        self.hotkey_ss58 = hotkey_ss58
+        self.hotkey_str = hotkey_str
+
+
 async def regen_coldkey(
     wallet: Wallet,
     mnemonic: Optional[str],
@@ -603,17 +599,19 @@ async def overview(
     include_hotkeys: Optional[list[str]] = None,
     exclude_hotkeys: Optional[list[str]] = None,
     netuids_filter: Optional[list[int]] = None,
+    verbose: bool = False,
 ):
     """Prints an overview for the wallet's coldkey."""
 
     total_balance = Balance(0)
 
     # We are printing for every coldkey.
-    print_verbose("Fetching total balance for coldkey/s")
     block_hash = await subtensor.substrate.get_chain_head()
     all_hotkeys, total_balance = await _get_total_balance(
         total_balance, subtensor, wallet, all_wallets, block_hash=block_hash
     )
+    _dynamic_info = await subtensor.get_all_subnet_dynamic_info()
+    dynamic_info = {info.netuid: info for info in _dynamic_info}
 
     with console.status(
         f":satellite: Synchronizing with chain [white]{subtensor.network}[/white]",
@@ -621,9 +619,6 @@ async def overview(
     ) as status:
         # We are printing for a select number of hotkeys from all_hotkeys.
         if include_hotkeys or exclude_hotkeys:
-            print_verbose(
-                "Fetching for select hotkeys passed in 'include_hotkeys'", status
-            )
             all_hotkeys = _get_hotkeys(include_hotkeys, exclude_hotkeys, all_hotkeys)
 
         # Check we have keys to display.
@@ -633,17 +628,14 @@ async def overview(
 
         # Pull neuron info for all keys.
         neurons: dict[str, list[NeuronInfoLite]] = {}
-        print_verbose("Fetching subnet netuids", status)
         block, all_netuids = await asyncio.gather(
             subtensor.substrate.get_block_number(None),
             subtensor.get_all_subnet_netuids(),
         )
 
-        print_verbose("Filtering netuids by registered hotkeys", status)
         netuids = await subtensor.filter_netuids_by_registered_hotkeys(
             all_netuids, netuids_filter, all_hotkeys, reuse_block=True
         )
-        # bittensor.logging.debug(f"Netuids to check: {netuids}")
 
         for netuid in netuids:
             neurons[str(netuid)] = []
@@ -664,104 +656,17 @@ async def overview(
             )
         all_hotkeys, _ = validate_coldkey_presence(all_hotkeys)
 
-        print_verbose("Fetching key addresses", status)
         all_hotkey_addresses, hotkey_coldkey_to_hotkey_wallet = _get_key_address(
             all_hotkeys
         )
 
-        print_verbose("Pulling and processing neuron information for all keys", status)
         results = await _get_neurons_for_netuids(
             subtensor, netuids, all_hotkey_addresses
         )
         neurons = _process_neuron_results(results, neurons, netuids)
-        total_coldkey_stake_from_metagraph = await _calculate_total_coldkey_stake(
-            neurons
-        )
-
-        alerts_table = Table(show_header=True, header_style="bold magenta")
-        alerts_table.add_column("🥩 alert!")
-
-        coldkeys_to_check = []
-        ck_stakes = await subtensor.get_total_stake_for_coldkey(
-            *(
-                coldkey_wallet.coldkeypub.ss58_address
-                for coldkey_wallet in all_coldkey_wallets
-                if coldkey_wallet.coldkeypub
-            ),
-            block_hash=block_hash,
-        )
-        for coldkey_wallet in all_coldkey_wallets:
-            if coldkey_wallet.coldkeypub:
-                # Check if we have any stake with hotkeys that are not registered.
-                difference = (
-                    ck_stakes[coldkey_wallet.coldkeypub.ss58_address]
-                    - total_coldkey_stake_from_metagraph[
-                        coldkey_wallet.coldkeypub.ss58_address
-                    ]
-                )
-                if difference == 0:
-                    continue  # We have all our stake registered.
-
-                coldkeys_to_check.append(coldkey_wallet)
-                alerts_table.add_row(
-                    "Found [light_goldenrod2]{}[/light_goldenrod2] stake with coldkey [bright_magenta]{}[/bright_magenta] that is not registered.".format(
-                        abs(difference), coldkey_wallet.coldkeypub.ss58_address
-                    )
-                )
-
-        if coldkeys_to_check:
-            # We have some stake that is not with a registered hotkey.
-            if "-1" not in neurons:
-                neurons["-1"] = []
-
-        print_verbose("Checking coldkeys for de-registered stake", status)
-        results = await asyncio.gather(
-            *[
-                _get_de_registered_stake_for_coldkey_wallet(
-                    subtensor, all_hotkey_addresses, coldkey_wallet
-                )
-                for coldkey_wallet in coldkeys_to_check
-            ]
-        )
-
-        for result in results:
-            coldkey_wallet, de_registered_stake, err_msg = result
-            if err_msg is not None:
-                err_console.print(err_msg)
-
-            if len(de_registered_stake) == 0:
-                continue  # We have no de-registered stake with this coldkey.
-
-            de_registered_neurons = []
-            for hotkey_addr, our_stake in de_registered_stake:
-                # Make a neuron info lite for this hotkey and coldkey.
-                de_registered_neuron = NeuronInfoLite.get_null_neuron()
-                de_registered_neuron.hotkey = hotkey_addr
-                de_registered_neuron.coldkey = coldkey_wallet.coldkeypub.ss58_address
-                de_registered_neuron.total_stake = Balance(our_stake)
-                de_registered_neurons.append(de_registered_neuron)
-
-                # Add this hotkey to the wallets dict
-                wallet_ = Wallet(name=wallet)
-                wallet_.hotkey_ss58 = hotkey_addr
-                wallet.hotkey_str = hotkey_addr[:5]  # Max length of 5 characters
-                # Indicates a hotkey not on local machine but exists in stake_info obj on-chain
-                if hotkey_coldkey_to_hotkey_wallet.get(hotkey_addr) is None:
-                    hotkey_coldkey_to_hotkey_wallet[hotkey_addr] = {}
-                hotkey_coldkey_to_hotkey_wallet[hotkey_addr][
-                    coldkey_wallet.coldkeypub.ss58_address
-                ] = wallet_
-
-            # Add neurons to overview.
-            neurons["-1"].extend(de_registered_neurons)
-
         # Setup outer table.
         grid = Table.grid(pad_edge=True)
 
-        # If there are any alerts, add them to the grid
-        if len(alerts_table.rows) > 0:
-            grid.add_row(alerts_table)
-
         # Add title
         if not all_wallets:
             title = "[underline dark_orange]Wallet[/underline dark_orange]\n"
@@ -780,9 +685,6 @@ async def overview(
             )
         )
         # Generate rows per netuid
-        hotkeys_seen = set()
-        total_neurons = 0
-        total_stake = 0.0
         tempos = await asyncio.gather(
             *[
                 subtensor.get_hyperparameter("Tempo", netuid, block_hash)
@@ -790,7 +692,6 @@ async def overview(
             ]
         )
     for netuid, subnet_tempo in zip(netuids, tempos):
-        last_subnet = netuid == netuids[-1]
         table_data = []
         total_rank = 0.0
         total_trust = 0.0
@@ -799,6 +700,8 @@ async def overview(
         total_incentive = 0.0
         total_dividends = 0.0
         total_emission = 0
+        total_stake = 0
+        total_neurons = 0
 
         for nn in neurons[str(netuid)]:
             hotwallet = hotkey_coldkey_to_hotkey_wallet.get(nn.hotkey, {}).get(
@@ -807,8 +710,7 @@ async def overview(
             if not hotwallet:
                 # Indicates a mismatch between what the chain says the coldkey
                 # is for this hotkey and the local wallet coldkey-hotkey pair
-                hotwallet = Wallet(name=nn.coldkey[:7])
-                hotwallet.hotkey_str = nn.hotkey[:7]
+                hotwallet = WalletLike(name=nn.coldkey[:7], hotkey_str=nn.hotkey[:7])
 
             nn: NeuronInfoLite
             uid = nn.uid
@@ -820,7 +722,7 @@ async def overview(
             validator_trust = nn.validator_trust
             incentive = nn.incentive
             dividends = nn.dividends
-            emission = int(nn.emission / (subnet_tempo + 1) * 1e9)
+            emission = int(nn.emission / (subnet_tempo + 1) * 1e9)  # Per block
             last_update = int(block - nn.last_update)
             validator_permit = nn.validator_permit
             row = [
@@ -828,14 +730,14 @@ async def overview(
                 hotwallet.hotkey_str,
                 str(uid),
                 str(active),
-                "{:.5f}".format(stake),
-                "{:.5f}".format(rank),
-                "{:.5f}".format(trust),
-                "{:.5f}".format(consensus),
-                "{:.5f}".format(incentive),
-                "{:.5f}".format(dividends),
-                "{:_}".format(emission),
-                "{:.5f}".format(validator_trust),
+                f"{stake:.4f}" if verbose else millify_tao(stake),
+                f"{rank:.4f}" if verbose else millify_tao(rank),
+                f"{trust:.4f}" if verbose else millify_tao(trust),
+                f"{consensus:.4f}" if verbose else millify_tao(consensus),
+                f"{incentive:.4f}" if verbose else millify_tao(incentive),
+                f"{dividends:.4f}" if verbose else millify_tao(dividends),
+                f"{emission:.4f}",
+                f"{validator_trust:.4f}" if verbose else millify_tao(validator_trust),
                 "*" if validator_permit else "",
                 str(last_update),
                 (
@@ -853,23 +755,15 @@ async def overview(
             total_dividends += dividends
             total_emission += emission
             total_validator_trust += validator_trust
-
-            if (nn.hotkey, nn.coldkey) not in hotkeys_seen:
-                # Don't double count stake on hotkey-coldkey pairs.
-                hotkeys_seen.add((nn.hotkey, nn.coldkey))
-                total_stake += stake
-
-            # netuid -1 are neurons that are de-registered.
-            if netuid != "-1":
-                total_neurons += 1
+            total_stake += stake
+            total_neurons += 1
 
             table_data.append(row)
 
         # Add subnet header
-        if netuid == "-1":
-            grid.add_row("Deregistered Neurons")
-        else:
-            grid.add_row(f"Subnet: [dark_orange]{netuid}[/dark_orange]")
+        grid.add_row(
+            f"Subnet: [dark_orange]{netuid}: {get_subnet_name(dynamic_info[netuid])} {dynamic_info[netuid].symbol}[/dark_orange]"
+        )
         width = console.width
         table = Table(
             show_footer=False,
@@ -878,45 +772,34 @@ async def overview(
             expand=True,
             width=width - 5,
         )
-        if last_subnet:
-            table.add_column(
-                "[white]COLDKEY", str(total_neurons), style="bold bright_cyan", ratio=2
-            )
-            table.add_column(
-                "[white]HOTKEY", str(total_neurons), style="bright_cyan", ratio=2
-            )
-        else:
-            # No footer for non-last subnet.
-            table.add_column("[white]COLDKEY", style="bold bright_cyan", ratio=2)
-            table.add_column("[white]HOTKEY", style="bright_cyan", ratio=2)
+
+        table.add_column("[white]COLDKEY", style="bold bright_cyan", ratio=2)
+        table.add_column("[white]HOTKEY", style="bright_cyan", ratio=2)
         table.add_column(
             "[white]UID", str(total_neurons), style="rgb(42,161,152)", ratio=1
         )
         table.add_column(
             "[white]ACTIVE", justify="right", style="#8787ff", no_wrap=True, ratio=1
         )
-        if last_subnet:
-            table.add_column(
-                "[white]STAKE(\u03c4)",
-                "\u03c4{:.5f}".format(total_stake),
-                footer_style="bold white",
-                justify="right",
-                style="dark_orange",
-                no_wrap=True,
-                ratio=1,
-            )
-        else:
-            # No footer for non-last subnet.
-            table.add_column(
-                "[white]STAKE(\u03c4)",
-                justify="right",
-                style="dark_orange",
-                no_wrap=True,
-                ratio=1.5,
-            )
+
+        _total_stake_formatted = (
+            f"{total_stake:.4f}" if verbose else millify_tao(total_stake)
+        )
+        table.add_column(
+            "[white]STAKE(\u03c4)"
+            if netuid == 0
+            else f"[white]STAKE({Balance.get_unit(netuid)})",
+            f"{_total_stake_formatted} {Balance.get_unit(netuid)}"
+            if netuid != 0
+            else f"{Balance.get_unit(netuid)} {_total_stake_formatted}",
+            justify="right",
+            style="dark_orange",
+            no_wrap=True,
+            ratio=1.5,
+        )
         table.add_column(
             "[white]RANK",
-            "{:.5f}".format(total_rank),
+            f"{total_rank:.4f}",
             justify="right",
             style="medium_purple",
             no_wrap=True,
@@ -924,7 +807,7 @@ async def overview(
         )
         table.add_column(
             "[white]TRUST",
-            "{:.5f}".format(total_trust),
+            f"{total_trust:.4f}",
             justify="right",
             style="green",
             no_wrap=True,
@@ -932,7 +815,7 @@ async def overview(
         )
         table.add_column(
             "[white]CONSENSUS",
-            "{:.5f}".format(total_consensus),
+            f"{total_consensus:.4f}",
             justify="right",
             style="rgb(42,161,152)",
             no_wrap=True,
@@ -940,7 +823,7 @@ async def overview(
         )
         table.add_column(
             "[white]INCENTIVE",
-            "{:.5f}".format(total_incentive),
+            f"{total_incentive:.4f}",
             justify="right",
             style="#5fd7ff",
             no_wrap=True,
@@ -948,7 +831,7 @@ async def overview(
         )
         table.add_column(
             "[white]DIVIDENDS",
-            "{:.5f}".format(total_dividends),
+            f"{total_dividends:.4f}",
             justify="right",
             style="#8787d7",
             no_wrap=True,
@@ -956,7 +839,7 @@ async def overview(
         )
         table.add_column(
             "[white]EMISSION(\u03c1)",
-            "\u03c1{:_}".format(total_emission),
+            f"\u03c1{total_emission}",
             justify="right",
             style="#d7d7ff",
             no_wrap=True,
@@ -964,7 +847,7 @@ async def overview(
         )
         table.add_column(
             "[white]VTRUST",
-            "{:.5f}".format(total_validator_trust),
+            f"{total_validator_trust:.4f}",
             justify="right",
             style="magenta",
             no_wrap=True,
@@ -1283,6 +1166,8 @@ async def inspect(
         delegates_: list[tuple[DelegateInfo, Balance]],
     ) -> Generator[list[str], None, None]:
         for d_, staked in delegates_:
+            if not staked.tao > 0:
+                continue
             if d_.hotkey_ss58 in registered_delegate_info:
                 delegate_name = registered_delegate_info[d_.hotkey_ss58].display
             else:
@@ -1292,7 +1177,11 @@ async def inspect(
                 + [
                     str(delegate_name),
                     str(staked),
-                    str(d_.total_daily_return.tao * (staked.tao / d_.total_stake.tao)),
+                    str(
+                        d_.total_daily_return.tao * (staked.tao / d_.total_stake.tao)
+                        if d_.total_stake.tao != 0
+                        else 0
+                    ),
                 ]
                 + [""] * 4
             )

{bittensor-cli-8.2.0rc9 → bittensor-cli-8.2.0rc11}/bittensor_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bittensor-cli
-Version: 8.2.0rc9
+Version: 8.2.0rc11
 Summary: Bittensor CLI
 Home-page: https://github.com/opentensor/btcli
 Author: bittensor.com