bittensor-cli 9.0.1__py3-none-any.whl → 9.0.2__py3-none-any.whl

bittensor_cli/__init__.py

@@ -16,8 +16,7 @@
 # DEALINGS IN THE SOFTWARE.
 
 from .cli import CLIManager
+from .version import __version__, __version_as_int__
 
 
-__version__ = "9.0.1"
-
-__all__ = ["CLIManager", "__version__"]
+__all__ = ["CLIManager"]

bittensor_cli/cli.py

@@ -26,7 +26,9 @@ from bittensor_cli.src import (
     WalletValidationTypes as WV,
     Constants,
     COLOR_PALETTE,
+    HYPERPARAMS,
 )
+from bittensor_cli.version import __version__, __version_as_int__
 from bittensor_cli.src.bittensor import utils
 from bittensor_cli.src.bittensor.balances import Balance
 from async_substrate_interface.errors import SubstrateRequestException
@@ -72,21 +74,8 @@ except ImportError:
         pass
 
 
-__version__ = "9.0.1"
 
 
-_core_version = re.match(r"^\d+\.\d+\.\d+", __version__).group(0)
-_version_split = _core_version.split(".")
-__version_info__ = tuple(int(part) for part in _version_split)
-_version_int_base = 1000
-assert max(__version_info__) < _version_int_base
-
-__version_as_int__: int = sum(
-    e * (_version_int_base**i) for i, e in enumerate(reversed(__version_info__))
-)
-assert __version_as_int__ < 2**31  # fits in int32
-__new_signature_version__ = 360
-
 _epilog = "Made with [bold red]:heart:[/bold red] by The Openτensor Foundaτion"
 
 np.set_printoptions(precision=8, suppress=True, floatmode="fixed")
@@ -124,7 +113,7 @@ class Options:
     )
     mnemonic = typer.Option(
         None,
-        help="Mnemonic used to regenerate your key. For example: horse cart dog ...",
+        help='Mnemonic used to regenerate your key. For example: "horse cart dog ..."',
     )
     seed = typer.Option(
         None, help="Seed hex string used to regenerate your key. For example: 0x1234..."
@@ -2130,6 +2119,7 @@ class CLIManager:
         # Example usage:
 
         [green]$[/green] btcli wallet regen_hotkey --seed 0x1234...
+        [green]$[/green] btcli wallet regen-hotkey --mnemonic "word1 word2 ... word12"
 
         [bold]Note[/bold]: This command is essential for users who need to regenerate their hotkey, possibly for security upgrades or key recovery.
         It should be used with caution to avoid accidental overwriting of existing keys.
@@ -3221,11 +3211,23 @@ class CLIManager:
                 else:
                     print_error("Invalid hotkey ss58 address.")
                     raise typer.Exit()
-            else:
-                hotkey_or_ss58 = Prompt.ask(
-                    "Enter the [blue]hotkey[/blue] name or [blue]ss58 address[/blue] to unstake all from",
-                    default=self.config.get("wallet_hotkey") or defaults.wallet.hotkey,
+            elif all_hotkeys:
+                wallet = self.wallet_ask(
+                    wallet_name,
+                    wallet_path,
+                    wallet_hotkey,
+                    ask_for=[WO.NAME, WO.PATH],
                 )
+            else:
+                if not hotkey_ss58_address and not wallet_hotkey:
+                    hotkey_or_ss58 = Prompt.ask(
+                        "Enter the [blue]hotkey[/blue] name or [blue]ss58 address[/blue] to unstake all from [dim](or enter 'all' to unstake from all hotkeys)[/dim]",
+                        default=self.config.get("wallet_hotkey")
+                        or defaults.wallet.hotkey,
+                    )
+                else:
+                    hotkey_or_ss58 = hotkey_ss58_address or wallet_hotkey
+
                 if is_valid_ss58_address(hotkey_or_ss58):
                     hotkey_ss58_address = hotkey_or_ss58
                     wallet = self.wallet_ask(
@@ -3234,6 +3236,14 @@ class CLIManager:
                         wallet_hotkey,
                         ask_for=[WO.NAME, WO.PATH],
                     )
+                elif hotkey_or_ss58 == "all":
+                    all_hotkeys = True
+                    wallet = self.wallet_ask(
+                        wallet_name,
+                        wallet_path,
+                        wallet_hotkey,
+                        ask_for=[WO.NAME, WO.PATH],
+                    )
                 else:
                     wallet_hotkey = hotkey_or_ss58
                     wallet = self.wallet_ask(
@@ -3249,6 +3259,9 @@ class CLIManager:
                     subtensor=self.initialize_chain(network),
                     hotkey_ss58_address=hotkey_ss58_address,
                     unstake_all_alpha=unstake_all_alpha,
+                    all_hotkeys=all_hotkeys,
+                    include_hotkeys=include_hotkeys,
+                    exclude_hotkeys=exclude_hotkeys,
                     prompt=prompt,
                 )
             )
@@ -3961,7 +3974,7 @@ class CLIManager:
         param_name: str = typer.Option(
             "", "--param", "--parameter", help="The subnet hyperparameter to set"
         ),
-        param_value: str = typer.Option(
+        param_value: Optional[str] = typer.Option(
             "", "--value", help="Value to set the hyperparameter to."
         ),
         quiet: bool = Options.quiet,
@@ -4010,9 +4023,12 @@ class CLIManager:
             param_value = f"{low_val},{high_val}"
 
         if not param_value:
-            param_value = Prompt.ask(
-                f"Enter the new value for [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{param_name}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] in the VALUE column format"
-            )
+            if HYPERPARAMS.get(param_name):
+                param_value = Prompt.ask(
+                    f"Enter the new value for [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{param_name}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] in the VALUE column format"
+                )
+            else:
+                param_value = None
 
         wallet = self.wallet_ask(
             wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]

bittensor_cli/src/__init__.py

@@ -672,7 +672,7 @@ HYPERPARAMS = {
     "commit_reveal_weights_enabled": ("sudo_set_commit_reveal_weights_enabled", False),
     "alpha_values": ("sudo_set_alpha_values", False),
     "liquid_alpha_enabled": ("sudo_set_liquid_alpha_enabled", False),
-    "network_registration_allowed": ("sudo_set_network_registration_allowed", False),
+    "registration_allowed": ("sudo_set_network_registration_allowed", False),
     "network_pow_registration_allowed": (
         "sudo_set_network_pow_registration_allowed",
         False,

bittensor_cli/src/bittensor/balances.py

@@ -76,7 +76,7 @@ class Balance:
         if self.unit == UNITS[0]:
             return f"{self.unit} {float(self.tao):,.4f}"
         else:
-            return f"{float(self.tao):,.4f} {self.unit}\u200e"
+            return f"\u200e{float(self.tao):,.4f} {self.unit}\u200e"
 
     def __rich__(self):
         return "[green]{}[/green][green]{}[/green][green].[/green][dim green]{}[/dim green]".format(

bittensor_cli/src/bittensor/chain_data.py

@@ -156,7 +156,7 @@ class SubnetHyperparameters(InfoBase):
     def _fix_decoded(
         cls, decoded: Union[dict, "SubnetHyperparameters"]
     ) -> "SubnetHyperparameters":
-        return SubnetHyperparameters(
+        return cls(
             rho=decoded.get("rho"),
             kappa=decoded.get("kappa"),
             immunity_period=decoded.get("immunity_period"),
@@ -197,6 +197,7 @@ class StakeInfo(InfoBase):
     stake: Balance  # Stake for the hotkey-coldkey pair
     locked: Balance  # Stake which is locked.
     emission: Balance  # Emission for the hotkey-coldkey pair
+    tao_emission: Balance  # TAO emission for the hotkey-coldkey pair
     drain: int
     is_registered: bool
 
@@ -208,11 +209,20 @@ class StakeInfo(InfoBase):
         stake = Balance.from_rao(decoded.get("stake")).set_unit(netuid)
         locked = Balance.from_rao(decoded.get("locked")).set_unit(netuid)
         emission = Balance.from_rao(decoded.get("emission")).set_unit(netuid)
+        tao_emission = Balance.from_rao(decoded.get("tao_emission"))
         drain = int(decoded.get("drain"))
         is_registered = bool(decoded.get("is_registered"))
 
-        return StakeInfo(
-            hotkey, coldkey, netuid, stake, locked, emission, drain, is_registered
+        return cls(
+            hotkey,
+            coldkey,
+            netuid,
+            stake,
+            locked,
+            emission,
+            tao_emission,
+            drain,
+            is_registered,
         )
 
 
@@ -293,7 +303,7 @@ class NeuronInfo(InfoBase):
         axon_info = decoded.get("axon_info", {})
         coldkey = decode_account_id(decoded.get("coldkey"))
         hotkey = decode_account_id(decoded.get("hotkey"))
-        return NeuronInfo(
+        return cls(
             hotkey=hotkey,
             coldkey=coldkey,
             uid=decoded.get("uid"),
@@ -555,7 +565,7 @@ class SubnetInfo(InfoBase):
 
     @classmethod
     def _fix_decoded(cls, decoded: "SubnetInfo") -> "SubnetInfo":
-        return SubnetInfo(
+        return cls(
             netuid=decoded.get("netuid"),
             rho=decoded.get("rho"),
             kappa=decoded.get("kappa"),
@@ -594,7 +604,7 @@ class SubnetIdentity(InfoBase):
 
     @classmethod
     def _fix_decoded(cls, decoded: dict) -> "SubnetIdentity":
-        return SubnetIdentity(
+        return cls(
             subnet_name=bytes(decoded["subnet_name"]).decode(),
             github_repo=bytes(decoded["github_repo"]).decode(),
             subnet_contact=bytes(decoded["subnet_contact"]).decode(),
@@ -828,7 +838,7 @@ class SubnetState(InfoBase):
     @classmethod
     def _fix_decoded(cls, decoded: Any) -> "SubnetState":
         netuid = decoded.get("netuid")
-        return SubnetState(
+        return cls(
             netuid=netuid,
             hotkeys=[decode_account_id(val) for val in decoded.get("hotkeys")],
             coldkeys=[decode_account_id(val) for val in decoded.get("coldkeys")],

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -112,8 +112,8 @@ class SubtensorInterface:
             f"[yellow]Connecting to Substrate:[/yellow][bold white] {self}..."
         ):
             try:
-                async with self.substrate:
-                    return self
+                await self.substrate.initialize()
+                return self
             except TimeoutError:  # TODO verify
                 err_console.print(
                     "\n[red]Error[/red]: Timeout occurred connecting to substrate. "
@@ -352,7 +352,7 @@ class SubtensorInterface:
         *ss58_addresses,
         block_hash: Optional[str] = None,
         reuse_block: bool = False,
-    ) -> dict[str, Balance]:
+    ) -> dict[str, tuple[Balance, Balance]]:
         """
         Returns the total stake held on a coldkey.
 
@@ -370,7 +370,8 @@ class SubtensorInterface:
 
         results = {}
         for ss58, stake_info_list in sub_stakes.items():
-            all_staked_tao = 0
+            total_tao_value = Balance(0)
+            total_swapped_tao_value = Balance(0)
             for sub_stake in stake_info_list:
                 if sub_stake.stake.rao == 0:
                     continue
@@ -381,19 +382,20 @@ class SubtensorInterface:
                     netuid
                 )
 
-                tao_locked = pool.tao_in
-
-                issuance = pool.alpha_out if pool.is_dynamic else tao_locked
-                tao_ownership = Balance(0)
+                # Without slippage
+                tao_value = pool.alpha_to_tao(alpha_value)
+                total_tao_value += tao_value
 
-                if alpha_value.tao > 0.00009 and issuance.tao != 0:
-                    tao_ownership = Balance.from_tao(
-                        (alpha_value.tao / issuance.tao) * tao_locked.tao
+                # With slippage
+                if netuid == 0:
+                    swapped_tao_value = tao_value
+                else:
+                    swapped_tao_value, _, _ = pool.alpha_to_tao_with_slippage(
+                        sub_stake.stake
                     )
+                total_swapped_tao_value += swapped_tao_value
 
-                all_staked_tao += tao_ownership.rao
-
-            results[ss58] = Balance.from_rao(all_staked_tao)
+            results[ss58] = (total_tao_value, total_swapped_tao_value)
         return results
 
     async def get_total_stake_for_hotkey(

bittensor_cli/src/commands/stake/add.py

@@ -107,9 +107,7 @@ async def stake_add(
                 )
                 return
             else:
-                err_out(
-                    f"\n{failure_prelude} with error: {format_error_message(e)}"
-                )
+                err_out(f"\n{failure_prelude} with error: {format_error_message(e)}")
             return
         else:
             await response.process_events()
@@ -180,9 +178,7 @@ 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)}"
-            )
+            err_out(f"\n{failure_prelude} with error: {format_error_message(e)}")
             return
         else:
             await response.process_events()

bittensor_cli/src/commands/stake/children_hotkeys.py

@@ -256,7 +256,7 @@ async def get_childkey_take(subtensor, hotkey: str, netuid: int) -> Optional[int
             params=[hotkey, netuid],
         )
         if childkey_take_:
-            return int(childkey_take_.value)
+            return int(childkey_take_)
 
     except SubstrateRequestException as e:
         err_console.print(f"Error querying ChildKeys: {format_error_message(e)}")

bittensor_cli/src/commands/stake/list.py

@@ -58,7 +58,6 @@ async def stake_list(
     def define_table(
         hotkey_name: str,
         rows: list[list[str]],
-        total_tao_ownership: Balance,
         total_tao_value: Balance,
         total_swapped_tao_value: Balance,
         live: bool = False,
@@ -130,6 +129,11 @@ async def stake_list(
             style=COLOR_PALETTE["POOLS"]["EMISSION"],
             justify="right",
         )
+        table.add_column(
+            f"[white]Emission \n({Balance.get_unit(0)}/block)",
+            style=COLOR_PALETTE["POOLS"]["EMISSION"],
+            justify="right",
+        )
         return table
 
     def create_table(hotkey_: str, substakes: list[StakeInfo]):
@@ -139,7 +143,6 @@ async def stake_list(
             else hotkey_
         )
         rows = []
-        total_tao_ownership = Balance(0)
         total_tao_value = Balance(0)
         total_swapped_tao_value = Balance(0)
         root_stakes = [s for s in substakes if s.netuid == 0]
@@ -155,14 +158,6 @@ async def stake_list(
             netuid = substake_.netuid
             pool = dynamic_info[netuid]
             symbol = f"{Balance.get_unit(netuid)}\u200e"
-            # TODO: what is this price var for?
-            price = (
-                "{:.4f}{}".format(
-                    pool.price.__float__(), f" τ/{Balance.get_unit(netuid)}\u200e"
-                )
-                if pool.is_dynamic
-                else (f" 1.0000 τ/{symbol} ")
-            )
 
             # Alpha value cell
             alpha_value = Balance.from_rao(int(substake_.stake.rao)).set_unit(netuid)
@@ -192,30 +187,11 @@ async def stake_list(
                     else f"{swapped_tao_value} ({slippage_percentage})"
                 )
 
-            # TAO locked cell
-            tao_locked = pool.tao_in
-
-            # Issuance cell
-            issuance = pool.alpha_out if pool.is_dynamic else tao_locked
-
             # Per block emission cell
             per_block_emission = substake_.emission.tao / (pool.tempo or 1)
+            per_block_tao_emission = substake_.tao_emission.tao / (pool.tempo or 1)
             # Alpha ownership and TAO ownership cells
             if alpha_value.tao > 0.00009:
-                if issuance.tao != 0:
-                    # TODO figure out why this alpha_ownership does nothing
-                    alpha_ownership = "{:.4f}".format(
-                        (alpha_value.tao / issuance.tao) * 100
-                    )
-                    tao_ownership = Balance.from_tao(
-                        (alpha_value.tao / issuance.tao) * tao_locked.tao
-                    )
-                    total_tao_ownership += tao_ownership
-                else:
-                    # TODO what's this var for?
-                    alpha_ownership = "0.0000"
-                    tao_ownership = Balance.from_tao(0)
-
                 stake_value = (
                     millify_tao(substake_.stake.tao)
                     if not verbose
@@ -243,15 +219,14 @@ async def stake_list(
                         # Removing this flag for now, TODO: Confirm correct values are here w.r.t CHKs
                         # if substake_.is_registered
                         # else f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]N/A",  # Emission(α/block)
+                        str(Balance.from_tao(per_block_tao_emission)),
                     ]
                 )
-        table = define_table(
-            name, rows, total_tao_ownership, total_tao_value, total_swapped_tao_value
-        )
+        table = define_table(name, rows, total_tao_value, total_swapped_tao_value)
         for row in rows:
             table.add_row(*row)
         console.print(table)
-        return total_tao_ownership, total_tao_value
+        return total_tao_value, total_swapped_tao_value
 
     def create_live_table(
         substakes: list,
@@ -263,7 +238,6 @@ async def stake_list(
         rows = []
         current_data = {}
 
-        total_tao_ownership = Balance(0)
         total_tao_value = Balance(0)
         total_swapped_tao_value = Balance(0)
 
@@ -324,17 +298,6 @@ async def stake_list(
             )
             total_swapped_tao_value += swapped_tao_value
 
-            # Calculate TAO ownership
-            tao_locked = pool.tao_in
-            issuance = pool.alpha_out if pool.is_dynamic else tao_locked
-            if alpha_value.tao > 0.00009 and issuance.tao != 0:
-                tao_ownership = Balance.from_tao(
-                    (alpha_value.tao / issuance.tao) * tao_locked.tao
-                )
-                total_tao_ownership += tao_ownership
-            else:
-                tao_ownership = Balance.from_tao(0)
-
             # Store current values for future delta tracking
             current_data[netuid] = {
                 "stake": alpha_value.tao,
@@ -342,7 +305,7 @@ async def stake_list(
                 "tao_value": tao_value.tao,
                 "swapped_value": swapped_tao_value.tao,
                 "emission": substake.emission.tao / (pool.tempo or 1),
-                "tao_ownership": tao_ownership.tao,
+                "tao_emission": substake.tao_emission.tao / (pool.tempo or 1),
             }
 
             # Get previous values for delta tracking
@@ -399,6 +362,16 @@ async def stake_list(
                 unit_first=unit_first,
                 precision=4,
             )
+
+            tao_emission_value = substake.tao_emission.tao / (pool.tempo or 1)
+            tao_emission_cell = format_cell(
+                tao_emission_value,
+                prev.get("tao_emission"),
+                unit="τ",
+                unit_first=unit_first,
+                precision=4,
+            )
+
             subnet_name_cell = (
                 f"[{COLOR_PALETTE['GENERAL']['SYMBOL']}]{symbol if netuid != 0 else 'τ'}[/{COLOR_PALETTE['GENERAL']['SYMBOL']}]"
                 f" {get_subnet_name(dynamic_info[netuid])}"
@@ -416,13 +389,13 @@ async def stake_list(
                     if substake.is_registered
                     else f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]NO",  # Registration status
                     emission_cell,  # Emission rate
+                    tao_emission_cell,  # TAO emission rate
                 ]
             )
 
         table = define_table(
             hotkey_name,
             rows,
-            total_tao_ownership,
             total_tao_value,
             total_swapped_tao_value,
             live=True,
@@ -458,7 +431,7 @@ async def stake_list(
         raise typer.Exit()
 
     if live:
-        # Select one hokkey for live monitoring
+        # Select one hotkey for live monitoring
         if len(hotkeys_to_substakes) > 1:
             console.print(
                 "\n[bold]Multiple hotkeys found. Please select one for live monitoring:[/bold]"
@@ -562,27 +535,29 @@ async def stake_list(
         # Iterate over each hotkey and make a table
         counter = 0
         num_hotkeys = len(hotkeys_to_substakes)
-        all_hotkeys_total_global_tao = Balance(0)
-        all_hotkeys_total_tao_value = Balance(0)
+        all_hks_swapped_tao_value = Balance(0)
+        all_hks_tao_value = Balance(0)
         for hotkey in hotkeys_to_substakes.keys():
             counter += 1
-            stake, value = create_table(hotkey, hotkeys_to_substakes[hotkey])
-            all_hotkeys_total_global_tao += stake
-            all_hotkeys_total_tao_value += value
+            tao_value, swapped_tao_value = create_table(
+                hotkey, hotkeys_to_substakes[hotkey]
+            )
+            all_hks_tao_value += tao_value
+            all_hks_swapped_tao_value += swapped_tao_value
 
             if num_hotkeys > 1 and counter < num_hotkeys and prompt:
                 console.print("\nPress Enter to continue to the next hotkey...")
                 input()
 
         total_tao_value = (
-            f"τ {millify_tao(all_hotkeys_total_tao_value.tao)}"
+            f"τ {millify_tao(all_hks_tao_value.tao)}"
             if not verbose
-            else all_hotkeys_total_tao_value
+            else all_hks_tao_value
         )
-        total_tao_ownership = (
-            f"τ {millify_tao(all_hotkeys_total_global_tao.tao)}"
+        total_swapped_tao_value = (
+            f"τ {millify_tao(all_hks_swapped_tao_value.tao)}"
             if not verbose
-            else all_hotkeys_total_global_tao
+            else all_hks_swapped_tao_value
         )
 
         console.print("\n\n")
@@ -590,8 +565,8 @@ async def stake_list(
             f"Wallet:\n"
             f"  Coldkey SS58: [{COLOR_PALETTE['GENERAL']['COLDKEY']}]{coldkey_address}[/{COLOR_PALETTE['GENERAL']['COLDKEY']}]\n"
             f"  Free Balance: [{COLOR_PALETTE['GENERAL']['BALANCE']}]{balance}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]\n"
-            f"  Total TAO ({Balance.unit}): [{COLOR_PALETTE['GENERAL']['BALANCE']}]{total_tao_ownership}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]\n"
-            f"  Total Value ({Balance.unit}): [{COLOR_PALETTE['GENERAL']['BALANCE']}]{total_tao_value}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]"
+            f"  Total TAO Value ({Balance.unit}): [{COLOR_PALETTE['GENERAL']['BALANCE']}]{total_tao_value}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]\n"
+            f"  Total TAO Swapped Value ({Balance.unit}): [{COLOR_PALETTE['GENERAL']['BALANCE']}]{total_swapped_tao_value}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]"
         )
         if not sub_stakes:
             console.print(

bittensor_cli/src/commands/stake/move.py

@@ -905,7 +905,7 @@ async def swap_stake(
         )
 
     if swap_all:
-        amount_to_swap = Balance.from_tao(current_stake).set_unit(origin_netuid)
+        amount_to_swap = current_stake.set_unit(origin_netuid)
     else:
         amount_to_swap = Balance.from_tao(amount).set_unit(origin_netuid)