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

bittensor_cli/cli.py

@@ -817,6 +817,9 @@ class CLIManager:
         self.wallet_app.command(
             "sign", rich_help_panel=HELP_PANELS["WALLET"]["OPERATIONS"]
         )(self.wallet_sign)
+        self.wallet_app.command(
+            "verify", rich_help_panel=HELP_PANELS["WALLET"]["OPERATIONS"]
+        )(self.wallet_verify)
 
         # stake commands
         self.stake_app.command(
@@ -1889,6 +1892,12 @@ class CLIManager:
         transfer_all: bool = typer.Option(
             False, "--all", prompt=False, help="Transfer all available balance."
         ),
+        allow_death: bool = typer.Option(
+            False,
+            "--allow-death",
+            prompt=False,
+            help="Transfer balance even if the resulting balance falls below the existential deposit.",
+        ),
         period: int = Options.period,
         wallet_name: str = Options.wallet_name,
         wallet_path: str = Options.wallet_path,
@@ -1932,7 +1941,7 @@ class CLIManager:
         subtensor = self.initialize_chain(network)
         if transfer_all and amount:
             print_error("Cannot specify an amount and '--all' flag.")
-            raise typer.Exit()
+            return False
         elif transfer_all:
             amount = 0
         elif not amount:
@@ -1944,6 +1953,7 @@ class CLIManager:
                 destination=destination_ss58_address,
                 amount=amount,
                 transfer_all=transfer_all,
+                allow_death=allow_death,
                 era=period,
                 prompt=prompt,
                 json_output=json_output,
@@ -3091,6 +3101,59 @@ class CLIManager:
 
         return self._run_command(wallets.sign(wallet, message, use_hotkey, json_output))
 
+    def wallet_verify(
+        self,
+        message: Optional[str] = typer.Option(
+            None, "--message", "-m", help="The message that was signed"
+        ),
+        signature: Optional[str] = typer.Option(
+            None, "--signature", "-s", help="The signature to verify (hex format)"
+        ),
+        public_key_or_ss58: Optional[str] = typer.Option(
+            None,
+            "--address",
+            "-a",
+            "--public-key",
+            "-p",
+            help="SS58 address or public key (hex) of the signer",
+        ),
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+        json_output: bool = Options.json_output,
+    ):
+        """
+        Verify a message signature using the signer's public key or SS58 address.
+
+        This command allows you to verify that a message was signed by the owner of a specific address.
+
+        USAGE
+
+        Provide the original message, the signature (in hex format), and either the SS58 address
+        or public key of the signer to verify the signature.
+
+        EXAMPLES
+
+        [green]$[/green] btcli wallet verify --message "Hello world" --signature "0xabc123..." --address "5GrwvaEF..."
+
+        [green]$[/green] btcli wallet verify -m "Test message" -s "0xdef456..." -p "0x1234abcd..."
+        """
+        self.verbosity_handler(quiet, verbose, json_output)
+
+        if not public_key_or_ss58:
+            public_key_or_ss58 = Prompt.ask(
+                "Enter the [blue]address[/blue] (SS58 or hex format)"
+            )
+
+        if not message:
+            message = Prompt.ask("Enter the [blue]message[/blue]")
+
+        if not signature:
+            signature = Prompt.ask("Enter the [blue]signature[/blue]")
+
+        return self._run_command(
+            wallets.verify(message, signature, public_key_or_ss58, json_output)
+        )
+
     def wallet_swap_coldkey(
         self,
         wallet_name: Optional[str] = Options.wallet_name,

bittensor_cli/src/bittensor/extrinsics/transfer.py

@@ -26,9 +26,9 @@ async def transfer_extrinsic(
     amount: Balance,
     era: int = 3,
     transfer_all: bool = False,
+    allow_death: bool = False,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = False,
-    keep_alive: bool = True,
     prompt: bool = False,
 ) -> bool:
     """Transfers funds from this wallet to the destination public key address.
@@ -39,11 +39,11 @@ async def transfer_extrinsic(
     :param amount: Amount to stake as Bittensor balance.
     :param era: Length (in blocks) for which the transaction should be valid.
     :param transfer_all: Whether to transfer all funds from this wallet to the destination address.
+    :param allow_death: Whether to allow for falling below the existential deposit when performing this transfer.
     :param wait_for_inclusion: If set, waits for the extrinsic to enter a block before returning `True`,
                                or returns `False` if the extrinsic fails to enter the block within the timeout.
     :param wait_for_finalization:  If set, waits for the extrinsic to be finalized on the chain before returning
                                    `True`, or returns `False` if the extrinsic fails to be finalized within the timeout.
-    :param keep_alive: If set, keeps the account alive by keeping the balance above the existential deposit.
     :param prompt: If `True`, the call waits for confirmation from the user before proceeding.
     :return: success: Flag is `True` if extrinsic was finalized or included in the block. If we did not wait for
                       finalization / inclusion, the response is `True`, regardless of its inclusion.
@@ -57,8 +57,8 @@ async def transfer_extrinsic(
         """
         call = await subtensor.substrate.compose_call(
             call_module="Balances",
-            call_function="transfer_keep_alive",
-            call_params={"dest": destination, "value": amount.rao},
+            call_function=call_function,
+            call_params=call_params,
         )
 
         try:
@@ -82,8 +82,8 @@ async def transfer_extrinsic(
         """
         call = await subtensor.substrate.compose_call(
             call_module="Balances",
-            call_function="transfer_keep_alive",
-            call_params={"dest": destination, "value": amount.rao},
+            call_function=call_function,
+            call_params=call_params,
         )
         extrinsic = await subtensor.substrate.create_signed_extrinsic(
             call=call, keypair=wallet.coldkey, era={"period": era}
@@ -115,6 +115,20 @@ async def transfer_extrinsic(
     if not unlock_key(wallet).success:
         return False
 
+    call_params = {"dest": destination}
+    if transfer_all:
+        call_function = "transfer_all"
+        if allow_death:
+            call_params["keep_alive"] = False
+        else:
+            call_params["keep_alive"] = True
+    else:
+        call_params["value"] = amount.rao
+        if allow_death:
+            call_function = "transfer_allow_death"
+        else:
+            call_function = "transfer_keep_alive"
+
     # Check balance.
     with console.status(
         f":satellite: Checking balance and fees on chain [white]{subtensor.network}[/white]",
@@ -131,23 +145,26 @@ async def transfer_extrinsic(
         )
         fee = await get_transfer_fee()
 
-    if not keep_alive:
-        # Check if the transfer should keep_alive the account
+    if allow_death:
+        # Check if the transfer should keep alive the account
         existential_deposit = Balance(0)
 
-    # Check if we have enough balance.
-    if transfer_all is True:
-        amount = account_balance - fee - existential_deposit
-        if amount < Balance(0):
-            print_error("Not enough balance to transfer")
-            return False
-
-    if account_balance < (amount + fee + existential_deposit):
+    if account_balance < (amount + fee + existential_deposit) and not allow_death:
         err_console.print(
             ":cross_mark: [bold red]Not enough balance[/bold red]:\n\n"
             f"  balance: [bright_cyan]{account_balance}[/bright_cyan]\n"
             f"  amount: [bright_cyan]{amount}[/bright_cyan]\n"
-            f"  for fee: [bright_cyan]{fee}[/bright_cyan]"
+            f"  for fee: [bright_cyan]{fee}[/bright_cyan]\n"
+            f"   would bring you under the existential deposit: [bright_cyan]{existential_deposit}[/bright_cyan].\n"
+            f"You can try again with `--allow-death`."
+        )
+        return False
+    elif account_balance < (amount + fee) and allow_death:
+        print_error(
+            ":cross_mark: [bold red]Not enough balance[/bold red]:\n\n"
+            f"  balance: [bright_red]{account_balance}[/bright_red]\n"
+            f"  amount: [bright_red]{amount}[/bright_red]\n"
+            f"  for fee: [bright_red]{fee}[/bright_red]"
         )
         return False
 

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -3,7 +3,9 @@ import os
 from typing import Optional, Any, Union, TypedDict, Iterable
 
 import aiohttp
+from async_substrate_interface.utils.storage import StorageKey
 from bittensor_wallet import Wallet
+from bittensor_wallet.bittensor_wallet import Keypair
 from bittensor_wallet.utils import SS58_FORMAT
 from scalecodec import GenericCall
 from async_substrate_interface.errors import SubstrateRequestException
@@ -881,9 +883,10 @@ class SubtensorInterface:
             storage_function="IdentitiesV2",
             block_hash=block_hash,
             reuse_block_hash=reuse_block,
+            fully_exhaust=True,
         )
         all_identities = {}
-        async for ss58_address, identity in identities:
+        for ss58_address, identity in identities.records:
             all_identities[decode_account_id(ss58_address[0])] = decode_hex_identity(
                 identity.value
             )
@@ -939,22 +942,22 @@ class SubtensorInterface:
         :param reuse_block: Whether to reuse the last-used blockchain block hash.
         :return: Dict with 'coldkeys' and 'hotkeys' as keys.
         """
-
-        coldkey_identities = await self.query_all_identities()
+        if block_hash is None:
+            block_hash = await self.substrate.get_chain_head()
+        coldkey_identities = await self.query_all_identities(block_hash=block_hash)
         identities = {"coldkeys": {}, "hotkeys": {}}
-        if not coldkey_identities:
-            return identities
-        query = await self.substrate.query_multiple(  # TODO probably more efficient to do this with query_multi
-            params=list(coldkey_identities.keys()),
-            module="SubtensorModule",
-            storage_function="OwnedHotkeys",
-            block_hash=block_hash,
-            reuse_block_hash=reuse_block,
-        )
+        sks = [
+            await self.substrate.create_storage_key(
+                "SubtensorModule", "OwnedHotkeys", [ck], block_hash=block_hash
+            )
+            for ck in coldkey_identities.keys()
+        ]
+        query = await self.substrate.query_multi(sks, block_hash=block_hash)
 
-        for coldkey_ss58, hotkeys in query.items():
+        storage_key: StorageKey
+        for storage_key, hotkeys in query:
+            coldkey_ss58 = storage_key.params[0]
             coldkey_identity = coldkey_identities.get(coldkey_ss58)
-            hotkeys = [decode_account_id(hotkey[0]) for hotkey in hotkeys or []]
 
             identities["coldkeys"][coldkey_ss58] = {
                 "identity": coldkey_identity,
@@ -1455,6 +1458,8 @@ class SubtensorInterface:
             ),
             self.get_subnet_price(netuid=netuid, block_hash=block_hash),
         )
+        if not result:
+            raise ValueError(f"Subnet {netuid} not found")
         subnet_ = DynamicInfo.from_any(result)
         subnet_.price = price
         return subnet_
@@ -1484,6 +1489,19 @@ class SubtensorInterface:
 
         return [decode_account_id(hotkey[0]) for hotkey in owned_hotkeys or []]
 
+    async def get_extrinsic_fee(self, call: GenericCall, keypair: Keypair) -> Balance:
+        """
+        Determines the fee for the extrinsic call.
+        Args:
+            call: Created extrinsic call
+            keypair: The keypair that would sign the extrinsic (usually you would just want to use the *pub for this)
+
+        Returns:
+            Balance object representing the fee for this extrinsic.
+        """
+        fee_dict = await self.substrate.get_payment_info(call, keypair)
+        return Balance.from_rao(fee_dict["partial_fee"])
+
     async def get_stake_fee(
         self,
         origin_hotkey_ss58: Optional[str],

bittensor_cli/src/commands/stake/add.py

@@ -65,6 +65,45 @@ async def stake_add(
         bool: True if stake operation is successful, False otherwise
     """
 
+    async def get_stake_extrinsic_fee(
+        netuid_: int,
+        amount_: Balance,
+        staking_address_: str,
+        safe_staking_: bool,
+        price_limit: Optional[Balance] = None,
+    ):
+        """
+        Quick method to get the extrinsic fee for adding stake depending on the args supplied.
+        Args:
+            netuid_: The netuid where the stake will be added
+            amount_: the amount of stake to add
+            staking_address_: the hotkey ss58 to stake to
+            safe_staking_: whether to use safe staking
+            price_limit: rate with tolerance
+
+        Returns:
+            Balance object representing the extrinsic fee for adding stake.
+        """
+        call_fn = "add_stake" if not safe_staking_ else "add_stake_limit"
+        call_params = {
+            "hotkey": staking_address_,
+            "netuid": netuid_,
+            "amount_staked": amount_.rao,
+        }
+        if safe_staking_:
+            call_params.update(
+                {
+                    "limit_price": price_limit,
+                    "allow_partial": allow_partial_stake,
+                }
+            )
+        call = await subtensor.substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function=call_fn,
+            call_params=call_params,
+        )
+        return await subtensor.get_extrinsic_fee(call, wallet.coldkeypub)
+
     async def safe_stake_extrinsic(
         netuid_: int,
         amount_: Balance,
@@ -87,7 +126,7 @@ async def stake_add(
                     "hotkey": hotkey_ss58_,
                     "netuid": netuid_,
                     "amount_staked": amount_.rao,
-                    "limit_price": price_limit,
+                    "limit_price": price_limit.rao,
                     "allow_partial": allow_partial_stake,
                 },
             ),
@@ -332,19 +371,6 @@ async def stake_add(
             # Temporary workaround - calculations without slippage
             current_price_float = float(subnet_info.price.tao)
             rate = 1.0 / current_price_float
-            received_amount = rate * amount_to_stake
-
-            # Add rows for the table
-            base_row = [
-                str(netuid),  # netuid
-                f"{hotkey[1]}",  # hotkey
-                str(amount_to_stake),  # amount
-                str(rate)
-                + f" {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",  # rate
-                str(received_amount.set_unit(netuid)),  # received
-                str(stake_fee),  # fee
-                # str(slippage_pct),  # slippage
-            ]
 
             # If we are staking safe, add price tolerance
             if safe_staking:
@@ -356,21 +382,45 @@ async def stake_add(
                     rate_with_tolerance = f"{_rate_with_tolerance:.4f}"
                     price_with_tolerance = Balance.from_tao(
                         price_with_tolerance
-                    ).rao  # Actual price to pass to extrinsic
+                    )  # Actual price to pass to extrinsic
                 else:
                     rate_with_tolerance = "1"
                     price_with_tolerance = Balance.from_rao(1)
+                extrinsic_fee = await get_stake_extrinsic_fee(
+                    netuid_=netuid,
+                    amount_=amount_to_stake,
+                    staking_address_=hotkey[1],
+                    safe_staking_=safe_staking,
+                    price_limit=price_with_tolerance,
+                )
                 prices_with_tolerance.append(price_with_tolerance)
-
-                base_row.extend(
-                    [
-                        f"{rate_with_tolerance} {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",
-                        f"[{'dark_sea_green3' if allow_partial_stake else 'red'}]"
-                        # safe staking
-                        f"{allow_partial_stake}[/{'dark_sea_green3' if allow_partial_stake else 'red'}]",
-                    ]
+                row_extension = [
+                    f"{rate_with_tolerance} {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",
+                    f"[{'dark_sea_green3' if allow_partial_stake else 'red'}]"
+                    # safe staking
+                    f"{allow_partial_stake}[/{'dark_sea_green3' if allow_partial_stake else 'red'}]",
+                ]
+            else:
+                extrinsic_fee = await get_stake_extrinsic_fee(
+                    netuid_=netuid,
+                    amount_=amount_to_stake,
+                    staking_address_=hotkey[1],
+                    safe_staking_=safe_staking,
                 )
-
+                row_extension = []
+            received_amount = rate * (amount_to_stake - stake_fee - extrinsic_fee)
+            # Add rows for the table
+            base_row = [
+                str(netuid),  # netuid
+                f"{hotkey[1]}",  # hotkey
+                str(amount_to_stake),  # amount
+                str(rate)
+                + f" {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",  # rate
+                str(received_amount.set_unit(netuid)),  # received
+                str(stake_fee),  # fee
+                str(extrinsic_fee),
+                # str(slippage_pct),  # slippage
+            ] + row_extension
             rows.append(tuple(base_row))
 
     # Define and print stake table + slippage warning
@@ -569,17 +619,17 @@ def _define_stake_table(
         "Hotkey", justify="center", style=COLOR_PALETTE["GENERAL"]["HOTKEY"]
     )
     table.add_column(
-        f"Amount ({Balance.get_unit(0)})",
+        "Amount (τ)",
         justify="center",
         style=COLOR_PALETTE["POOLS"]["TAO"],
     )
     table.add_column(
-        f"Rate (per {Balance.get_unit(0)})",
+        "Rate (per τ)",
         justify="center",
         style=COLOR_PALETTE["POOLS"]["RATE"],
     )
     table.add_column(
-        "Received",
+        "Est. Received",
         justify="center",
         style=COLOR_PALETTE["POOLS"]["TAO_EQUIV"],
     )
@@ -588,6 +638,11 @@ def _define_stake_table(
         justify="center",
         style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
     )
+    table.add_column(
+        "Extrinsic Fee (τ)",
+        justify="center",
+        style=COLOR_PALETTE.STAKE.TAO,
+    )
     # TODO: Uncomment when slippage is reimplemented for v3
     # table.add_column(
     #     "Slippage", justify="center", style=COLOR_PALETTE["STAKE"]["SLIPPAGE_PERCENT"]

bittensor_cli/src/commands/stake/move.py

@@ -33,12 +33,15 @@ async def display_stake_movement_cross_subnets(
     destination_hotkey: str,
     amount_to_move: Balance,
     stake_fee: Balance,
+    extrinsic_fee: Balance,
 ) -> tuple[Balance, str]:
     """Calculate and display stake movement information"""
 
     if origin_netuid == destination_netuid:
         subnet = await subtensor.subnet(origin_netuid)
-        received_amount_tao = subnet.alpha_to_tao(amount_to_move - stake_fee)
+        received_amount_tao = (
+            subnet.alpha_to_tao(amount_to_move - stake_fee) - extrinsic_fee
+        )
         received_amount = subnet.tao_to_alpha(received_amount_tao)
 
         if received_amount < Balance.from_tao(0).set_unit(destination_netuid):
@@ -62,7 +65,9 @@ async def display_stake_movement_cross_subnets(
         price_destination = dynamic_destination.price.tao
         rate = price_origin / (price_destination or 1)
 
-        received_amount_tao = dynamic_origin.alpha_to_tao(amount_to_move - stake_fee)
+        received_amount_tao = (
+            dynamic_origin.alpha_to_tao(amount_to_move - stake_fee) - extrinsic_fee
+        )
         received_amount = dynamic_destination.tao_to_alpha(received_amount_tao)
         received_amount.set_unit(destination_netuid)
 
@@ -81,14 +86,14 @@ async def display_stake_movement_cross_subnets(
     # Create and display table
     table = Table(
         title=(
-            f"\n[{COLOR_PALETTE['GENERAL']['HEADER']}]"
+            f"\n[{COLOR_PALETTE.G.HEADER}]"
             f"Moving stake from: "
-            f"[{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{Balance.get_unit(origin_netuid)}(Netuid: {origin_netuid})"
-            f"[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] "
+            f"[{COLOR_PALETTE.G.SUBHEAD}]{Balance.get_unit(origin_netuid)}(Netuid: {origin_netuid})"
+            f"[/{COLOR_PALETTE.G.SUBHEAD}] "
             f"to: "
-            f"[{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{Balance.get_unit(destination_netuid)}(Netuid: {destination_netuid})"
-            f"[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}]\nNetwork: {subtensor.network}\n"
-            f"[/{COLOR_PALETTE['GENERAL']['HEADER']}]"
+            f"[{COLOR_PALETTE.G.SUBHEAD}]{Balance.get_unit(destination_netuid)}(Netuid: {destination_netuid})"
+            f"[/{COLOR_PALETTE.G.SUBHEAD}]\nNetwork: {subtensor.network}\n"
+            f"[/{COLOR_PALETTE.G.HEADER}]"
         ),
         show_footer=True,
         show_edge=False,
@@ -132,6 +137,9 @@ async def display_stake_movement_cross_subnets(
         justify="center",
         style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
     )
+    table.add_column(
+        "Extrinsic Fee (τ)", justify="center", style=COLOR_PALETTE.STAKE.TAO
+    )
 
     table.add_row(
         f"{Balance.get_unit(origin_netuid)}({origin_netuid})",
@@ -142,6 +150,7 @@ async def display_stake_movement_cross_subnets(
         price_str,
         str(received_amount),
         str(stake_fee.set_unit(origin_netuid)),
+        str(extrinsic_fee),
     )
 
     console.print(table)
@@ -165,10 +174,10 @@ def prompt_stake_amount(
     while True:
         amount_input = Prompt.ask(
             f"\nEnter the amount to {action_name} "
-            f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{Balance.get_unit(netuid)}[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}] "
-            f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}](max: {current_balance})[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}] "
+            f"[{COLOR_PALETTE.S.STAKE_AMOUNT}]{Balance.get_unit(netuid)}[/{COLOR_PALETTE.S.STAKE_AMOUNT}] "
+            f"[{COLOR_PALETTE.S.STAKE_AMOUNT}](max: {current_balance})[/{COLOR_PALETTE.S.STAKE_AMOUNT}] "
             f"or "
-            f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]'all'[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}] "
+            f"[{COLOR_PALETTE.S.STAKE_AMOUNT}]'all'[/{COLOR_PALETTE.S.STAKE_AMOUNT}] "
             f"for entire balance"
         )
 
@@ -183,7 +192,7 @@ def prompt_stake_amount(
             if amount > current_balance.tao:
                 console.print(
                     f"[red]Amount exceeds available balance of "
-                    f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{current_balance}[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]"
+                    f"[{COLOR_PALETTE.S.STAKE_AMOUNT}]{current_balance}[/{COLOR_PALETTE.S.STAKE_AMOUNT}]"
                     f"[/red]"
                 )
                 continue
@@ -270,8 +279,8 @@ async def stake_move_transfer_selection(
 
     # Display available netuids for selected hotkey
     table = Table(
-        title=f"\n[{COLOR_PALETTE['GENERAL']['HEADER']}]Available Stakes for Hotkey\n[/{COLOR_PALETTE['GENERAL']['HEADER']}]"
-        f"[{COLOR_PALETTE['GENERAL']['HOTKEY']}]{origin_hotkey_ss58}[/{COLOR_PALETTE['GENERAL']['HOTKEY']}]\n",
+        title=f"\n[{COLOR_PALETTE.G.HEADER}]Available Stakes for Hotkey\n[/{COLOR_PALETTE.G.HEADER}]"
+        f"[{COLOR_PALETTE.G.HK}]{origin_hotkey_ss58}[/{COLOR_PALETTE.G.HK}]\n",
         show_edge=False,
         header_style="bold white",
         border_style="bright_black",
@@ -279,7 +288,7 @@ async def stake_move_transfer_selection(
         width=len(origin_hotkey_ss58) + 20,
     )
     table.add_column("Netuid", style="cyan")
-    table.add_column("Stake Amount", style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"])
+    table.add_column("Stake Amount", style=COLOR_PALETTE.STAKE.STAKE_AMOUNT)
 
     available_netuids = []
     for netuid in origin_hotkey_info["netuids"]:
@@ -347,8 +356,8 @@ async def stake_swap_selection(
 
     # Display available stakes
     table = Table(
-        title=f"\n[{COLOR_PALETTE['GENERAL']['HEADER']}]Available Stakes for Hotkey\n[/{COLOR_PALETTE['GENERAL']['HEADER']}]"
-        f"[{COLOR_PALETTE['GENERAL']['HOTKEY']}]{wallet.hotkey_str}: {wallet.hotkey.ss58_address}[/{COLOR_PALETTE['GENERAL']['HOTKEY']}]\n",
+        title=f"\n[{COLOR_PALETTE.G.HEADER}]Available Stakes for Hotkey\n[/{COLOR_PALETTE.G.HEADER}]"
+        f"[{COLOR_PALETTE.G.HK}]{wallet.hotkey_str}: {wallet.hotkey.ss58_address}[/{COLOR_PALETTE.G.HK}]\n",
         show_edge=False,
         header_style="bold white",
         border_style="bright_black",
@@ -366,7 +375,7 @@ async def stake_swap_selection(
     for idx, (netuid, stake_info) in enumerate(sorted(hotkey_stakes.items())):
         subnet_info = subnet_dict[netuid]
         subnet_name_cell = (
-            f"[{COLOR_PALETTE['GENERAL']['SYMBOL']}]{subnet_info.symbol if netuid != 0 else 'τ'}[/{COLOR_PALETTE['GENERAL']['SYMBOL']}]"
+            f"[{COLOR_PALETTE.G.SYM}]{subnet_info.symbol if netuid != 0 else 'τ'}[/{COLOR_PALETTE.G.SYM}]"
             f" {get_subnet_name(subnet_info)}"
         )
 
@@ -498,14 +507,28 @@ async def move_stake(
         )
         return False
 
-    stake_fee = await subtensor.get_stake_fee(
-        origin_hotkey_ss58=origin_hotkey,
-        origin_netuid=origin_netuid,
-        origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
-        destination_hotkey_ss58=destination_hotkey,
-        destination_netuid=destination_netuid,
-        destination_coldkey_ss58=wallet.coldkeypub.ss58_address,
-        amount=amount_to_move_as_balance.rao,
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="move_stake",
+        call_params={
+            "origin_hotkey": origin_hotkey,
+            "origin_netuid": origin_netuid,
+            "destination_hotkey": destination_hotkey,
+            "destination_netuid": destination_netuid,
+            "alpha_amount": amount_to_move_as_balance.rao,
+        },
+    )
+    stake_fee, extrinsic_fee = await asyncio.gather(
+        subtensor.get_stake_fee(
+            origin_hotkey_ss58=origin_hotkey,
+            origin_netuid=origin_netuid,
+            origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
+            destination_hotkey_ss58=destination_hotkey,
+            destination_netuid=destination_netuid,
+            destination_coldkey_ss58=wallet.coldkeypub.ss58_address,
+            amount=amount_to_move_as_balance.rao,
+        ),
+        subtensor.get_extrinsic_fee(call, wallet.coldkeypub),
     )
 
     # Display stake movement details
@@ -519,6 +542,7 @@ async def move_stake(
                 destination_hotkey=destination_hotkey,
                 amount_to_move=amount_to_move_as_balance,
                 stake_fee=stake_fee,
+                extrinsic_fee=extrinsic_fee,
             )
         except ValueError:
             return False
@@ -529,20 +553,10 @@ async def move_stake(
     if not unlock_key(wallet).success:
         return False
     with console.status(
-        f"\n:satellite: Moving [blue]{amount_to_move_as_balance}[/blue] from [blue]{origin_hotkey}[/blue] on netuid: [blue]{origin_netuid}[/blue] \nto "
+        f"\n:satellite: Moving [blue]{amount_to_move_as_balance}[/blue] from [blue]{origin_hotkey}[/blue] on netuid: "
+        f"[blue]{origin_netuid}[/blue] \nto "
         f"[blue]{destination_hotkey}[/blue] on netuid: [blue]{destination_netuid}[/blue] ..."
     ):
-        call = await subtensor.substrate.compose_call(
-            call_module="SubtensorModule",
-            call_function="move_stake",
-            call_params={
-                "origin_hotkey": origin_hotkey,
-                "origin_netuid": origin_netuid,
-                "destination_hotkey": destination_hotkey,
-                "destination_netuid": destination_netuid,
-                "alpha_amount": amount_to_move_as_balance.rao,
-            },
-        )
         extrinsic = await subtensor.substrate.create_signed_extrinsic(
             call=call, keypair=wallet.coldkey, era={"period": era}
         )
@@ -677,19 +691,33 @@ async def transfer_stake(
     if amount_to_transfer > current_stake:
         err_console.print(
             f"[red]Not enough stake to transfer[/red]:\n"
-            f"Stake balance: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{current_stake}[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}] < "
-            f"Transfer amount: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{amount_to_transfer}[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]"
+            f"Stake balance: [{COLOR_PALETTE.S.STAKE_AMOUNT}]{current_stake}[/{COLOR_PALETTE.S.STAKE_AMOUNT}] < "
+            f"Transfer amount: [{COLOR_PALETTE.S.STAKE_AMOUNT}]{amount_to_transfer}[/{COLOR_PALETTE.S.STAKE_AMOUNT}]"
         )
         return False
 
-    stake_fee = await subtensor.get_stake_fee(
-        origin_hotkey_ss58=origin_hotkey,
-        origin_netuid=origin_netuid,
-        origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
-        destination_hotkey_ss58=origin_hotkey,
-        destination_netuid=dest_netuid,
-        destination_coldkey_ss58=dest_coldkey_ss58,
-        amount=amount_to_transfer.rao,
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="transfer_stake",
+        call_params={
+            "destination_coldkey": dest_coldkey_ss58,
+            "hotkey": origin_hotkey,
+            "origin_netuid": origin_netuid,
+            "destination_netuid": dest_netuid,
+            "alpha_amount": amount_to_transfer.rao,
+        },
+    )
+    stake_fee, extrinsic_fee = await asyncio.gather(
+        subtensor.get_stake_fee(
+            origin_hotkey_ss58=origin_hotkey,
+            origin_netuid=origin_netuid,
+            origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
+            destination_hotkey_ss58=origin_hotkey,
+            destination_netuid=dest_netuid,
+            destination_coldkey_ss58=dest_coldkey_ss58,
+            amount=amount_to_transfer.rao,
+        ),
+        subtensor.get_extrinsic_fee(call, wallet.coldkeypub),
     )
 
     # Display stake movement details
@@ -703,6 +731,7 @@ async def transfer_stake(
                 destination_hotkey=origin_hotkey,
                 amount_to_move=amount_to_transfer,
                 stake_fee=stake_fee,
+                extrinsic_fee=extrinsic_fee,
             )
         except ValueError:
             return False
@@ -715,18 +744,6 @@ async def transfer_stake(
         return False
 
     with console.status("\n:satellite: Transferring stake ..."):
-        call = await subtensor.substrate.compose_call(
-            call_module="SubtensorModule",
-            call_function="transfer_stake",
-            call_params={
-                "destination_coldkey": dest_coldkey_ss58,
-                "hotkey": origin_hotkey,
-                "origin_netuid": origin_netuid,
-                "destination_netuid": dest_netuid,
-                "alpha_amount": amount_to_transfer.rao,
-            },
-        )
-
         extrinsic = await subtensor.substrate.create_signed_extrinsic(
             call=call, keypair=wallet.coldkey, era={"period": era}
         )
@@ -846,19 +863,32 @@ async def swap_stake(
     if amount_to_swap > current_stake:
         err_console.print(
             f"[red]Not enough stake to swap[/red]:\n"
-            f"Stake balance: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{current_stake}[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}] < "
-            f"Swap amount: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{amount_to_swap}[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]"
+            f"Stake balance: [{COLOR_PALETTE.S.STAKE_AMOUNT}]{current_stake}[/{COLOR_PALETTE.S.STAKE_AMOUNT}] < "
+            f"Swap amount: [{COLOR_PALETTE.S.STAKE_AMOUNT}]{amount_to_swap}[/{COLOR_PALETTE.S.STAKE_AMOUNT}]"
         )
         return False
 
-    stake_fee = await subtensor.get_stake_fee(
-        origin_hotkey_ss58=hotkey_ss58,
-        origin_netuid=origin_netuid,
-        origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
-        destination_hotkey_ss58=hotkey_ss58,
-        destination_netuid=destination_netuid,
-        destination_coldkey_ss58=wallet.coldkeypub.ss58_address,
-        amount=amount_to_swap.rao,
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="swap_stake",
+        call_params={
+            "hotkey": hotkey_ss58,
+            "origin_netuid": origin_netuid,
+            "destination_netuid": destination_netuid,
+            "alpha_amount": amount_to_swap.rao,
+        },
+    )
+    stake_fee, extrinsic_fee = await asyncio.gather(
+        subtensor.get_stake_fee(
+            origin_hotkey_ss58=hotkey_ss58,
+            origin_netuid=origin_netuid,
+            origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
+            destination_hotkey_ss58=hotkey_ss58,
+            destination_netuid=destination_netuid,
+            destination_coldkey_ss58=wallet.coldkeypub.ss58_address,
+            amount=amount_to_swap.rao,
+        ),
+        subtensor.get_extrinsic_fee(call, wallet.coldkeypub),
     )
 
     # Display stake movement details
@@ -872,6 +902,7 @@ async def swap_stake(
                 destination_hotkey=hotkey_ss58,
                 amount_to_move=amount_to_swap,
                 stake_fee=stake_fee,
+                extrinsic_fee=extrinsic_fee,
             )
         except ValueError:
             return False
@@ -887,17 +918,6 @@ async def swap_stake(
         f"\n:satellite: Swapping stake from netuid [blue]{origin_netuid}[/blue] "
         f"to netuid [blue]{destination_netuid}[/blue]..."
     ):
-        call = await subtensor.substrate.compose_call(
-            call_module="SubtensorModule",
-            call_function="swap_stake",
-            call_params={
-                "hotkey": hotkey_ss58,
-                "origin_netuid": origin_netuid,
-                "destination_netuid": destination_netuid,
-                "alpha_amount": amount_to_swap.rao,
-            },
-        )
-
         extrinsic = await subtensor.substrate.create_signed_extrinsic(
             call=call, keypair=wallet.coldkey, era={"period": era}
         )

bittensor_cli/src/commands/stake/remove.py

@@ -47,6 +47,7 @@ async def unstake(
     era: int,
 ):
     """Unstake from hotkey(s)."""
+
     with console.status(
         f"Retrieving subnet data & identities from {subtensor.network}...",
         spinner="earth",
@@ -82,7 +83,7 @@ async def unstake(
             hotkey_to_unstake_all = hotkeys_to_unstake_from[0]
             unstake_all_alpha = Confirm.ask(
                 "\nDo you want to:\n"
-                "[blue]Yes[/blue]: Unstake from all subnets and automatically restake to subnet 0 (root)\n"
+                "[blue]Yes[/blue]: Unstake from all subnets and automatically re-stake to subnet 0 (root)\n"
                 "[blue]No[/blue]: Unstake everything (including subnet 0)",
                 default=True,
             )
@@ -210,8 +211,38 @@ async def unstake(
 
             try:
                 current_price = subnet_info.price.tao
+                if safe_staking:
+                    if subnet_info.is_dynamic:
+                        price_with_tolerance = current_price * (1 - rate_tolerance)
+                        rate_with_tolerance = price_with_tolerance
+                        price_limit = Balance.from_tao(
+                            rate_with_tolerance
+                        )  # Actual price to pass to extrinsic
+                    else:
+                        price_limit = Balance.from_rao(1)
+                    extrinsic_fee = await _get_extrinsic_fee(
+                        "unstake_safe",
+                        wallet,
+                        subtensor,
+                        hotkey_ss58=staking_address_ss58,
+                        amount=amount_to_unstake_as_balance,
+                        netuid=netuid,
+                        price_limit=price_limit,
+                        allow_partial_stake=allow_partial_stake,
+                    )
+                else:
+                    extrinsic_fee = await _get_extrinsic_fee(
+                        "unstake",
+                        wallet,
+                        subtensor,
+                        hotkey_ss58=staking_address_ss58,
+                        netuid=netuid,
+                        amount=amount_to_unstake_as_balance,
+                    )
                 rate = current_price
-                received_amount = amount_to_unstake_as_balance * rate
+                received_amount = (
+                    (amount_to_unstake_as_balance - stake_fee) * rate
+                ) - extrinsic_fee
             except ValueError:
                 continue
             total_received_amount += received_amount
@@ -233,8 +264,9 @@ async def unstake(
                 staking_address_name,  # Hotkey Name
                 str(amount_to_unstake_as_balance),  # Amount to Unstake
                 f"{subnet_info.price.tao:.6f}"
-                + f"({Balance.get_unit(0)}/{Balance.get_unit(netuid)})",  # Rate
+                + f"(τ/{Balance.get_unit(netuid)})",  # Rate
                 str(stake_fee.set_unit(netuid)),  # Fee
+                str(extrinsic_fee),  # Extrinsic fee
                 str(received_amount),  # Received Amount
                 # slippage_pct,  # Slippage Percent
             ]
@@ -431,10 +463,15 @@ async def unstake_all(
             style=COLOR_PALETTE["POOLS"]["RATE"],
         )
         table.add_column(
-            f"Fee ({Balance.unit})",
+            f"Fee ({Balance.get_unit(1)})",
             justify="center",
             style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
         )
+        table.add_column(
+            "Extrinsic Fee (τ)",
+            justify="center",
+            style=COLOR_PALETTE.STAKE.TAO,
+        )
         table.add_column(
             f"Received ({Balance.unit})",
             justify="center",
@@ -467,8 +504,17 @@ async def unstake_all(
 
             try:
                 current_price = subnet_info.price.tao
+                extrinsic_type = (
+                    "unstake_all" if not unstake_all_alpha else "unstake_all_alpha"
+                )
+                extrinsic_fee = await _get_extrinsic_fee(
+                    extrinsic_type,
+                    wallet,
+                    subtensor,
+                    hotkey_ss58=stake.hotkey_ss58,
+                )
                 rate = current_price
-                received_amount = stake_amount * rate - stake_fee
+                received_amount = ((stake_amount - stake_fee) * rate) - extrinsic_fee
 
                 if received_amount < Balance.from_tao(0):
                     print_error("Not enough Alpha to pay the transaction fee.")
@@ -485,6 +531,7 @@ async def unstake_all(
                 f"{float(subnet_info.price):.6f}"
                 + f"({Balance.get_unit(0)}/{Balance.get_unit(stake.netuid)})",
                 str(stake_fee),
+                str(extrinsic_fee),
                 str(received_amount),
             )
     console.print(table)
@@ -830,6 +877,63 @@ async def _unstake_all_extrinsic(
         err_out(f"{failure_prelude} with error: {str(e)}")
 
 
+async def _get_extrinsic_fee(
+    _type: str,
+    wallet: Wallet,
+    subtensor: "SubtensorInterface",
+    hotkey_ss58: str,
+    netuid: Optional[int] = None,
+    amount: Optional[Balance] = None,
+    price_limit: Optional[Balance] = None,
+    allow_partial_stake: bool = False,
+) -> Balance:
+    """
+    Retrieves the extrinsic fee for a given unstaking call.
+    Args:
+        _type: 'unstake', 'unstake_safe', 'unstake_all', 'unstake_all_alpha' depending on the specific
+            extrinsic to be called
+        wallet: Wallet object
+        subtensor: SubtensorInterface object
+        hotkey_ss58: the hotkey ss58 to unstake from
+        netuid: the netuid from which to remove the stake
+        amount: the amount of stake to remove
+        price_limit: the price limit
+        allow_partial_stake: whether to allow partial unstaking
+
+    Returns:
+        Balance object representing the extrinsic fee.
+    """
+    lookup_table = {
+        "unstake": lambda: (
+            "remove_stake",
+            {
+                "hotkey": hotkey_ss58,
+                "netuid": netuid,
+                "amount_unstaked": amount.rao,
+            },
+        ),
+        "unstake_safe": lambda: (
+            "remove_stake_limit",
+            {
+                "hotkey": hotkey_ss58,
+                "netuid": netuid,
+                "amount_unstaked": amount.rao,
+                "limit_price": price_limit,
+                "allow_partial": allow_partial_stake,
+            },
+        ),
+        "unstake_all": lambda: ("unstake_all", {"hotkey": hotkey_ss58}),
+        "unstake_all_alpha": lambda: ("unstake_all_alpha", {"hotkey": hotkey_ss58}),
+    }
+    call_fn, call_params = lookup_table[_type]()
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function=call_fn,
+        call_params=call_params,
+    )
+    return await subtensor.get_extrinsic_fee(call, wallet.coldkeypub)
+
+
 # Helpers
 async def _unstake_selection(
     dynamic_info,
@@ -1184,7 +1288,7 @@ def _create_unstake_table(
         style=COLOR_PALETTE["POOLS"]["TAO"],
     )
     table.add_column(
-        f"Rate ({Balance.get_unit(0)}/{Balance.get_unit(1)})",
+        f"Rate (τ/{Balance.get_unit(1)})",
         justify="center",
         style=COLOR_PALETTE["POOLS"]["RATE"],
     )
@@ -1194,7 +1298,10 @@ def _create_unstake_table(
         style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
     )
     table.add_column(
-        f"Received ({Balance.get_unit(0)})",
+        "Extrinsic Fee (τ)", justify="center", style=COLOR_PALETTE.STAKE.TAO
+    )
+    table.add_column(
+        "Received (τ)",
         justify="center",
         style=COLOR_PALETTE["POOLS"]["TAO_EQUIV"],
         footer=str(total_received_amount),

bittensor_cli/src/commands/wallets.py

@@ -1408,6 +1408,7 @@ async def transfer(
     destination: str,
     amount: float,
     transfer_all: bool,
+    allow_death: bool,
     era: int,
     prompt: bool,
     json_output: bool,
@@ -1419,6 +1420,7 @@ async def transfer(
         destination=destination,
         amount=Balance.from_tao(amount),
         transfer_all=transfer_all,
+        allow_death=allow_death,
         era=era,
         prompt=prompt,
     )
@@ -1800,10 +1802,96 @@ async def sign(
         )
 
     signed_message = keypair.sign(message.encode("utf-8")).hex()
-    console.print("[dark_sea_green3]Message signed successfully:")
+    signer_address = keypair.ss58_address
+    console.print("[dark_sea_green3]Message signed successfully!\n")
+
     if json_output:
-        json_console.print(json.dumps({"signed_message": signed_message}))
-    console.print(signed_message)
+        json_console.print(
+            json.dumps(
+                {"signed_message": signed_message, "signer_address": signer_address}
+            )
+        )
+    else:
+        console.print(f"[yellow]Signature:[/yellow]\n{signed_message}")
+        console.print(f"[yellow]Signer address:[/yellow] {signer_address}")
+
+
+async def verify(
+    message: str,
+    signature: str,
+    public_key_or_ss58: str,
+    json_output: bool = False,
+):
+    """Verify a message signature using a public key or SS58 address."""
+
+    if is_valid_ss58_address(public_key_or_ss58):
+        print_verbose(f"[blue]SS58 address detected:[/blue] {public_key_or_ss58}")
+        keypair = Keypair(ss58_address=public_key_or_ss58)
+        signer_address = public_key_or_ss58
+    else:
+        try:
+            public_key_hex = public_key_or_ss58.strip().lower()
+            if public_key_hex.startswith("0x"):
+                public_key_hex = public_key_hex[2:]
+            if len(public_key_hex) == 64:
+                bytes.fromhex(public_key_hex)
+                print_verbose("[blue]Hex public key detected[/blue] (64 characters)")
+                keypair = Keypair(public_key=public_key_hex)
+                signer_address = keypair.ss58_address
+                print_verbose(
+                    f"[blue]Corresponding SS58 address:[/blue] {signer_address}"
+                )
+            else:
+                raise ValueError("Public key must be 32 bytes (64 hex characters)")
+
+        except (ValueError, TypeError) as e:
+            if json_output:
+                json_console.print(
+                    json.dumps(
+                        {
+                            "verified": False,
+                            "error": f"Invalid public key or SS58 address: {str(e)}",
+                        }
+                    )
+                )
+            else:
+                err_console.print(
+                    f":cross_mark: Invalid SS58 address or hex public key (64 chars, with or without 0x prefix)- {str(e)}"
+                )
+            return False
+
+    try:
+        signature_bytes = bytes.fromhex(signature.strip().lower().replace("0x", ""))
+    except ValueError as e:
+        if json_output:
+            json_console.print(
+                json.dumps(
+                    {
+                        "verified": False,
+                        "error": f"Invalid signature format: {str(e)}",
+                    }
+                )
+            )
+        else:
+            err_console.print(f"[red]:cross_mark: Invalid signature format: {str(e)}")
+        return False
+
+    is_valid = keypair.verify(message.encode("utf-8"), signature_bytes)
+
+    if json_output:
+        json_console.print(
+            json.dumps(
+                {"verified": is_valid, "signer": signer_address, "message": message}
+            )
+        )
+    else:
+        if is_valid:
+            console.print("[dark_sea_green3]Signature is valid!\n")
+            console.print(f"[yellow]Signer:[/yellow] {signer_address}")
+        else:
+            err_console.print(":cross_mark: [red]Signature verification failed!")
+
+    return is_valid
 
 
 async def schedule_coldkey_swap(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bittensor-cli
-Version: 9.8.7
+Version: 9.9.0
 Summary: Bittensor CLI
 Author: bittensor.com
 Project-URL: homepage, https://github.com/opentensor/btcli
@@ -8,7 +8,7 @@ Project-URL: Repository, https://github.com/opentensor/btcli
 Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: wheel
-Requires-Dist: async-substrate-interface>=1.1.0
+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

{bittensor_cli-9.8.7.dist-info → bittensor_cli-9.9.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 bittensor_cli/__init__.py,sha256=Lpv4NkbAQgwrfqFOnTMuR_S-fqGdaWCSLhxnFnGTHM0,1232
-bittensor_cli/cli.py,sha256=Q2AzvNEUz080lc7Usz-Dg2kFjQYCNERXnE1cWTWQubw,232741
+bittensor_cli/cli.py,sha256=lG3LyOXXiOOEIPgiW9qnqmKnH2wa598iJ6pf-eNCveg,234995
 bittensor_cli/doc_generation_helper.py,sha256=GexqjEIKulWg84hpNBEchJ840oOgOi7DWpt447nsdNI,91
 bittensor_cli/version.py,sha256=dU1xsa3mG5FPdhzvqlzDByNcCHmzcFQH3q1pQr4u76g,720
 bittensor_cli/src/__init__.py,sha256=QCR6kt9rbUiLC4gkvczl47eg725nqSFK4Xr7_mz3e_s,33171
@@ -8,12 +8,12 @@ bittensor_cli/src/bittensor/balances.py,sha256=q5KkxF8wmUguWAFddEKstfDKTxPe5ISHp
 bittensor_cli/src/bittensor/chain_data.py,sha256=_GATOCacWMN2jRurzn3hffJiq_l7AznGRkKePTAflwQ,44420
 bittensor_cli/src/bittensor/minigraph.py,sha256=BIzmSVLfBYiRAeGD_i1LAC8Cw7zxp38a91SIFEPMqYc,10479
 bittensor_cli/src/bittensor/networking.py,sha256=pZLMs8YXpZzDMLXWMBb_Bj6TVkm_q9khyY-lnbwVMuE,462
-bittensor_cli/src/bittensor/subtensor_interface.py,sha256=iPpM0mGsRwc7iejBI9oChpFd8DgEw13-Yb1fflQyCb8,61886
+bittensor_cli/src/bittensor/subtensor_interface.py,sha256=37BB5dfcRE6QrAKwuYs9XlaLs36xHrhJ3wCsWd-rXek,62672
 bittensor_cli/src/bittensor/utils.py,sha256=WfxxQnekVy7nbB2jsPrRC4E7SFIvAjDJJjq3glhKMSc,48270
 bittensor_cli/src/bittensor/extrinsics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bittensor_cli/src/bittensor/extrinsics/registration.py,sha256=7ybqpJ7-Z_PTgj4boCOFxgfjMBCHv0JE7MNpJzJmyDc,66360
 bittensor_cli/src/bittensor/extrinsics/root.py,sha256=C9WPssL2HpNK8u_IFPPr8TrdFgbLPTfkbAYzalfmbRM,19188
-bittensor_cli/src/bittensor/extrinsics/transfer.py,sha256=tKXC7DTvaR15Lh20FWtoRMkEWQdNFQcXstZCEw9sWHM,8567
+bittensor_cli/src/bittensor/extrinsics/transfer.py,sha256=S4HFvgwhUk-NQ26FOkg8m1ggAJ50jgPsW_isdAdS_rc,9235
 bittensor_cli/src/bittensor/templates/main-filters.j2,sha256=ZM0l2exr6FKqw86GRyHHtw-h8Y5Ckgx-SPc-48gZoxI,914
 bittensor_cli/src/bittensor/templates/main-header.j2,sha256=aZwB9NeEjNr0pM5mPYTYeky_031zAu6yErIMiwTPcwE,1684
 bittensor_cli/src/bittensor/templates/neuron-details.j2,sha256=O_Mhg2E04BzW_cSGIldObhVTSRX29gDNqnimW4ty9rY,4848
@@ -30,22 +30,22 @@ bittensor_cli/src/bittensor/templates/view.js,sha256=QIPnPp9SuYS9wcl7cwL8nFzd8id
 bittensor_cli/src/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bittensor_cli/src/commands/sudo.py,sha256=zyv4sJM7sH73_c-mgskcnF2kQfJBJ8_xF74WrZFv7rY,33820
 bittensor_cli/src/commands/view.py,sha256=9lx6vfOkel8KIefUhDNaBS_j5lNR2djcRFRbK4mbnDE,12535
-bittensor_cli/src/commands/wallets.py,sha256=v6JDcWhP_CcBruboixKM1XMqhUKL6GbllGd39wHKbBs,71646
+bittensor_cli/src/commands/wallets.py,sha256=SIcEf7AkxonUAM3zYEaQUJTczCIY6iFtR3sTunhB1C8,74745
 bittensor_cli/src/commands/weights.py,sha256=BCJm_mlw0pVK4YEZuEMqQBpvvOoB7B1rzdvMeN3uTfM,16503
 bittensor_cli/src/commands/liquidity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bittensor_cli/src/commands/liquidity/liquidity.py,sha256=AXCjBvQb2gakP8n1z81npYkZ_QF5CQy7r82AMtQwXzk,21692
 bittensor_cli/src/commands/liquidity/utils.py,sha256=egfZHnvBMc8ydntAHnU6V5Zyi-wLkomjNuucUj73aZQ,6361
 bittensor_cli/src/commands/stake/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bittensor_cli/src/commands/stake/add.py,sha256=oEpWFnRWazaFsbKn06o4gwQ1JfFmn4AwxRNecimI3js,27614
+bittensor_cli/src/commands/stake/add.py,sha256=jdNOilpEsq8f7vJUQH1qFdiQ-HbSg6siYQl_CQdtlh0,29731
 bittensor_cli/src/commands/stake/children_hotkeys.py,sha256=lMiV-Z3SGZUEapdy0LRthFLx0RlFK0KVxytE47ybdEc,31746
 bittensor_cli/src/commands/stake/list.py,sha256=tzjhiJucXgOGaw7TGt420nGosH85AEjvOimP1XXV3Xs,29038
-bittensor_cli/src/commands/stake/move.py,sha256=X8rphxkL5BBHJSNpNqY_o3fffCpSI0-yX03SlNXfX_A,34857
-bittensor_cli/src/commands/stake/remove.py,sha256=DX7yPXs5n8Gp3O_Fwz8cMYI8CAiRp16gbKLwSCAoYmM,47341
+bittensor_cli/src/commands/stake/move.py,sha256=RJiY_oSQUV-ZO04Y_PosrDqfz0JfdQX4ioB74f_7lU8,35144
+bittensor_cli/src/commands/stake/remove.py,sha256=Xf_BWihl--4WGKPl6Wz4VkWus3JKEikHQKA0tbQTetM,51318
 bittensor_cli/src/commands/subnets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bittensor_cli/src/commands/subnets/price.py,sha256=akXkbilWjQYqTYvtOhXngX_cVkU0Mv-Gl3kjce6dtl0,21490
 bittensor_cli/src/commands/subnets/subnets.py,sha256=ZeR7gxjtxi9eQdPLlIOmw3jDxDPnteppTPJ1-1y_TCs,94601
-bittensor_cli-9.8.7.dist-info/METADATA,sha256=PPTxAAdYJbLNkgqEtJHrr6nhlGBP-fVlbXiG5IRTEvA,6601
-bittensor_cli-9.8.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bittensor_cli-9.8.7.dist-info/entry_points.txt,sha256=hBTLGLbVxmAKy69XSKaUZvjTCmyEzDGZKq4S8UOto8I,49
-bittensor_cli-9.8.7.dist-info/top_level.txt,sha256=DvgvXpmTtI_Q1BbDZMlK90LFcGFCreN1daViEPV2iFw,14
-bittensor_cli-9.8.7.dist-info/RECORD,,
+bittensor_cli-9.9.0.dist-info/METADATA,sha256=3KHTWo7iaqwIrHfos259k3CbxZI9MBy_OwGxAZSf2rI,6601
+bittensor_cli-9.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bittensor_cli-9.9.0.dist-info/entry_points.txt,sha256=hBTLGLbVxmAKy69XSKaUZvjTCmyEzDGZKq4S8UOto8I,49
+bittensor_cli-9.9.0.dist-info/top_level.txt,sha256=DvgvXpmTtI_Q1BbDZMlK90LFcGFCreN1daViEPV2iFw,14
+bittensor_cli-9.9.0.dist-info/RECORD,,