bittensor-cli 9.20.0__tar.gz → 9.20.1__tar.gz

{bittensor_cli-9.20.0 → bittensor_cli-9.20.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bittensor-cli
-Version: 9.20.0
+Version: 9.20.1
 Summary: Bittensor CLI
 Author: bittensor.com
 Requires-Python: >=3.10
@@ -19,7 +19,7 @@ Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Utilities
 Requires-Dist: wheel
-Requires-Dist: async-substrate-interface>=1.6.2
+Requires-Dist: async-substrate-interface>=1.6.2,<2.0.0
 Requires-Dist: aiohttp~=3.13
 Requires-Dist: backoff~=2.2.1
 Requires-Dist: bittensor-drand>=1.3.0

{bittensor_cli-9.20.0 → bittensor_cli-9.20.1}/bittensor_cli/cli.py

@@ -2913,7 +2913,17 @@ class CLIManager:
         ),
         wallet_name: str = Options.wallet_name,
         wallet_path: str = Options.wallet_path,
-        wallet_hotkey: str = Options.wallet_hotkey,
+        wallet_hotkey: str = Options.edit_help(
+            "wallet_hotkey",
+            help_text="Deprecated option, "
+            "preserved for backwards compatibility to not break workflows which utilise it.",
+        ),
+        ss58_address: Optional[str] = typer.Option(
+            None,
+            "--ss58-address",
+            "--ss58",
+            help="SS58 address of the coldkey to inspect. Allows inspecting any coldkey without a local wallet file.",
+        ),
         network: Optional[list[str]] = Options.network,
         netuids: str = Options.netuids,
         quiet: bool = Options.quiet,
@@ -2921,9 +2931,11 @@ class CLIManager:
         json_output: bool = Options.json_output,
     ):
         """
-        Displays the details of the user's wallet pairs (coldkey, hotkey) on the Bittensor network.
+        Displays the details of the user's wallet (coldkey) on the Bittensor network.
 
-        The output is presented as a table with the below columns:
+        The output is presented as two separate tables:
+
+        [bold]Coldkey Overview[/bold]:
 
         - [blue bold]Coldkey[/blue bold]: The coldkey associated with the user's wallet.
 
@@ -2931,14 +2943,22 @@ class CLIManager:
 
         - [blue bold]Delegate[/blue bold]: The name of the delegate to which the coldkey has staked TAO.
 
-        - [blue bold]Stake[/blue bold]: The amount of stake held by both the coldkey and hotkey.
+        - [blue bold]Stake[/blue bold]: The amount of stake delegated.
 
-        - [blue bold]Emission[/blue bold]: The emission or rewards earned from staking.
+        - [blue bold]Emission[/blue bold]: The daily emission earned from delegation.
+
+        [bold]Hotkey Details[/bold]:
 
-        - [blue bold]Netuid[/blue bold]: The network unique identifier of the subnet where the hotkey is active (i.e., validating).
+        - [blue bold]Coldkey[/blue bold]: The parent coldkey of the hotkey.
+
+        - [blue bold]Netuid[/blue bold]: The network unique identifier of the subnet where the hotkey is active.
 
         - [blue bold]Hotkey[/blue bold]: The hotkey associated with the neuron on the network.
 
+        - [blue bold]Stake[/blue bold]: The amount of stake held by the hotkey.
+
+        - [blue bold]Emission[/blue bold]: The emission or rewards earned from staking.
+
         USAGE
 
         This command can be used to inspect a single wallet or all the wallets located at a specified path. It is useful for a comprehensive overview of a user's participation and performance in the Bittensor network.
@@ -2949,10 +2969,10 @@ class CLIManager:
 
         [green]$[/green] btcli wallet inspect --all -n 1 -n 2 -n 3
 
+        [green]$[/green] btcli wallet inspect --ss58-address 5FHneW46...
+
         [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, json_output, False)
 
         if netuids:
@@ -2962,18 +2982,28 @@ class CLIManager:
                 "Netuids must be a comma-separated list of ints, e.g., `--netuids 1,2,3,4`.",
             )
 
+        if ss58_address:
+            return self._run_command(
+                wallets.inspect(
+                    None,
+                    self.initialize_chain(network),
+                    netuids_filter=netuids,
+                    all_wallets=False,
+                    ss58_address=ss58_address,
+                )
+            )
+
         # if all-wallets is entered, ask for path
         ask_for = [WO.NAME, WO.PATH] if not all_wallets else [WO.PATH]
         validate = WV.WALLET if not all_wallets else WV.NONE
         wallet = self.wallet_ask(
-            wallet_name, wallet_path, wallet_hotkey, ask_for=ask_for, validate=validate
+            wallet_name, wallet_path, None, ask_for=ask_for, validate=validate
         )
 
-        self.initialize_chain(network)
         return self._run_command(
             wallets.inspect(
                 wallet,
-                self.subtensor,
+                self.initialize_chain(network),
                 netuids_filter=netuids,
                 all_wallets=all_wallets,
             )
@@ -5482,33 +5512,20 @@ class CLIManager:
             console.print(
                 "[dim]This command moves stake from one hotkey to another hotkey while keeping the same coldkey.[/dim]"
             )
+        interactive_selection = False
         if not destination_hotkey:
             dest_wallet_or_ss58 = Prompt.ask(
-                "Enter the [blue]destination wallet[/blue] where destination hotkey is located or "
-                "[blue]ss58 address[/blue]"
+                "Enter the [blue]ss58 address[/blue] of the hotkey to move the stake to, leave blank for other options"
             )
             if is_valid_ss58_address(dest_wallet_or_ss58):
                 destination_hotkey = dest_wallet_or_ss58
+            elif dest_wallet_or_ss58.strip() == "":
+                interactive_selection = True
             else:
-                dest_wallet = self.wallet_ask(
-                    dest_wallet_or_ss58,
-                    wallet_path,
-                    None,
-                    ask_for=[WO.NAME, WO.PATH],
-                    validate=WV.WALLET,
-                )
-                destination_hotkey = Prompt.ask(
-                    "Enter the [blue]destination hotkey[/blue] name",
-                    default=dest_wallet.hotkey_str,
-                )
-                destination_wallet = self.wallet_ask(
-                    dest_wallet_or_ss58,
-                    wallet_path,
-                    destination_hotkey,
-                    ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
-                    validate=WV.WALLET_AND_HOTKEY,
+                print_error(
+                    "Invalid destination hotkey ss58 address. Please enter a valid ss58 address."
                 )
-                destination_hotkey = get_hotkey_pub_ss58(destination_wallet)
+                raise typer.Exit()
         else:
             if is_valid_ss58_address(destination_hotkey):
                 destination_hotkey = destination_hotkey
@@ -5527,7 +5544,6 @@ class CLIManager:
             wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
         )
 
-        interactive_selection = False
         if not wallet_hotkey:
             origin_hotkey = Prompt.ask(
                 "Enter the [blue]origin hotkey[/blue] name or "

{bittensor_cli-9.20.0 → bittensor_cli-9.20.1}/bittensor_cli/src/__init__.py

@@ -1,6 +1,4 @@
 from enum import Enum
-from dataclasses import dataclass
-from typing import Any, Optional
 
 
 class Constants:
@@ -37,47 +35,6 @@ class Constants:
     delegates_detail_url = "https://raw.githubusercontent.com/opentensor/bittensor-delegates/main/public/delegates.json"
 
 
-@dataclass
-class DelegatesDetails:
-    display: str
-    additional: list[tuple[str, str]]
-    web: str
-    legal: Optional[str] = None
-    riot: Optional[str] = None
-    email: Optional[str] = None
-    pgp_fingerprint: Optional[str] = None
-    image: Optional[str] = None
-    twitter: Optional[str] = None
-
-    @classmethod
-    def from_chain_data(cls, data: dict[str, Any]) -> "DelegatesDetails":
-        def decode(key: str, default=""):
-            try:
-                if isinstance(data.get(key), dict):
-                    value = next(data.get(key).values())
-                    return bytes(value[0]).decode("utf-8")
-                elif isinstance(data.get(key), int):
-                    return data.get(key)
-                elif isinstance(data.get(key), tuple):
-                    return bytes(data.get(key)[0]).decode("utf-8")
-                else:
-                    return default
-            except (UnicodeDecodeError, TypeError):
-                return default
-
-        return cls(
-            display=decode("display"),
-            additional=decode("additional", []),
-            web=decode("web"),
-            legal=decode("legal"),
-            riot=decode("riot"),
-            email=decode("email"),
-            pgp_fingerprint=decode("pgp_fingerprint", None),
-            image=decode("image"),
-            twitter=decode("twitter"),
-        )
-
-
 class Defaults:
     netuid = 1
     rate_tolerance = 0.005

{bittensor_cli-9.20.0 → bittensor_cli-9.20.1}/bittensor_cli/src/bittensor/extrinsics/registration.py

@@ -708,11 +708,13 @@ async def burned_register_extrinsic(
         f":satellite: Checking Account on [bold]subnet:{netuid}[/bold]...",
         spinner="aesthetic",
     ) as status:
+        block_hash = await subtensor.substrate.get_chain_head()
         my_uid = await subtensor.query(
-            "SubtensorModule", "Uids", [netuid, get_hotkey_pub_ss58(wallet)]
+            module="SubtensorModule",
+            storage_function="Uids",
+            params=[netuid, get_hotkey_pub_ss58(wallet)],
+            block_hash=block_hash,
         )
-        block_hash = await subtensor.substrate.get_chain_head()
-
         print_verbose("Checking if already registered", status)
         neuron = await subtensor.neuron_for_uid(
             uid=my_uid, netuid=netuid, block_hash=block_hash

{bittensor_cli-9.20.0 → bittensor_cli-9.20.1}/bittensor_cli/src/bittensor/extrinsics/transfer.py

@@ -156,10 +156,10 @@ async def transfer_extrinsic(
                 f"   would bring you under the existential deposit: [bright_cyan]{existential_deposit}[/bright_cyan].\n"
             )
             return False, None
-        if account_balance < amount and allow_death:
+        if proxy_balance < amount and allow_death:
             print_error(
                 "[bold red]Not enough balance[/bold red]:\n\n"
-                f"  balance: [bright_red]{account_balance}[/bright_red]\n"
+                f"  balance: [bright_red]{proxy_balance}[/bright_red]\n"
                 f"  amount: [bright_red]{amount}[/bright_red]\n"
             )
             return False, None

{bittensor_cli-9.20.0 → bittensor_cli-9.20.1}/bittensor_cli/src/bittensor/subtensor_interface.py

@@ -32,7 +32,6 @@ from bittensor_cli.src.bittensor.chain_data import (
     CrowdloanData,
     ColdkeySwapAnnouncementInfo,
 )
-from bittensor_cli.src import DelegatesDetails
 from bittensor_cli.src.bittensor.balances import Balance, fixed_to_float
 from bittensor_cli.src import Constants, defaults, TYPE_REGISTRY
 from bittensor_cli.src.bittensor.extrinsics.mev_shield import encrypt_extrinsic
@@ -40,7 +39,6 @@ from bittensor_cli.src.bittensor.utils import (
     format_error_message,
     console,
     print_error,
-    decode_hex_identity_dict,
     validate_chain_endpoint,
     u16_normalized_float,
     MEV_SHIELD_PUBLIC_KEY_SIZE,
@@ -229,9 +227,11 @@ class SubtensorInterface:
             storage_function="NetworksAdded",
             block_hash=block_hash,
             reuse_block_hash=True,
+            fully_exhaust=True,
+            page_size=200,
         )
         res = []
-        async for netuid, exists in result:
+        for netuid, exists in result.records:
             if exists.value:
                 res.append(netuid)
         return res
@@ -283,14 +283,14 @@ class SubtensorInterface:
             params=[coldkey_ss58],
             block_hash=block_hash,
             reuse_block_hash=reuse_block,
+            fully_exhaust=True,
+            page_size=200,
         )
-
         destinations: dict[int, str] = {}
-        async for netuid, destination in query:
+        for netuid, destination in query.records:
             hotkey_ss58 = decode_account_id(destination.value[0])
             if hotkey_ss58:
                 destinations[int(netuid)] = hotkey_ss58
-
         return destinations
 
     async def get_stake_for_coldkey_and_hotkey(
@@ -573,9 +573,11 @@ class SubtensorInterface:
             params=[hotkey_ss58],
             block_hash=block_hash,
             reuse_block_hash=reuse_block,
+            fully_exhaust=True,
+            page_size=200,
         )
         res = []
-        async for record in result:
+        for record in result.records:
             if record[1].value:
                 res.append(record[0])
         return res
@@ -1449,9 +1451,11 @@ class SubtensorInterface:
             storage_function="MechanismCountCurrent",
             params=[],
             block_hash=block_hash,
+            fully_exhaust=True,
+            page_size=200,
         )
         res = {}
-        async for netuid, count in results:
+        for netuid, count in results.records:
             res[int(netuid)] = int(count.value)
         return res
 
@@ -1512,39 +1516,6 @@ class SubtensorInterface:
         else:
             return ProposalVoteData(vote_data)
 
-    async def get_delegate_identities(
-        self, block_hash: Optional[str] = None
-    ) -> dict[str, DelegatesDetails]:
-        """
-        Fetches delegates identities from the chain and GitHub. Preference is given to chain data, and missing info
-        is filled-in by the info from GitHub. At some point, we want to totally move away from fetching this info
-        from GitHub, but chain data is still limited in that regard.
-
-        :param block_hash: the hash of the blockchain block for the query
-
-        :return: {ss58: DelegatesDetails, ...}
-
-        """
-        identities_info = await self.substrate.query_map(
-            module="Registry",
-            storage_function="IdentityOf",
-            block_hash=block_hash,
-        )
-
-        all_delegates_details = {}
-        async for ss58_address, identity in identities_info:
-            all_delegates_details.update(
-                {
-                    decode_account_id(
-                        ss58_address[0]
-                    ): DelegatesDetails.from_chain_data(
-                        decode_hex_identity_dict(identity.value["info"])
-                    )
-                }
-            )
-
-        return all_delegates_details
-
     async def get_mechagraph_info(
         self, netuid: int, mech_id: int, block_hash: Optional[str] = None
     ) -> Optional[MetagraphInfo]:
@@ -1868,10 +1839,12 @@ class SubtensorInterface:
             storage_function="ColdkeySwapAnnouncements",
             block_hash=block_hash,
             reuse_block_hash=reuse_block,
+            fully_exhaust=True,
+            page_size=200,
         )
 
         announcements = []
-        async for ss58, data in result:
+        for ss58, data in result.records:
             coldkey = decode_account_id(ss58)
             announcements.append(
                 ColdkeySwapAnnouncementInfo._fix_decoded(coldkey, data)
@@ -1926,10 +1899,12 @@ class SubtensorInterface:
             storage_function="ColdkeySwapDisputes",
             block_hash=block_hash,
             reuse_block_hash=reuse_block,
+            fully_exhaust=True,
+            page_size=200,
         )
 
         disputes: list[tuple[str, int]] = []
-        async for ss58, data in result:
+        for ss58, data in result.records:
             coldkey = decode_account_id(ss58)
             disputes.append((coldkey, data.value))
         return disputes
@@ -1984,7 +1959,7 @@ class SubtensorInterface:
             fully_exhaust=True,
         )
         crowdloans = {}
-        async for fund_id, fund_info in crowdloans_data:
+        for fund_id, fund_info in crowdloans_data.records:
             decoded_call = await self._decode_inline_call(
                 fund_info["call"],
                 block_hash=block_hash,
@@ -2085,7 +2060,7 @@ class SubtensorInterface:
         )
 
         contributor_contributions = {}
-        async for contributor_key, contribution_amount in contributors_data:
+        for contributor_key, contribution_amount in contributors_data.records:
             try:
                 contributor_address = decode_account_id(contributor_key[0])
                 contribution_balance = Balance.from_rao(contribution_amount.value)
@@ -2239,10 +2214,12 @@ class SubtensorInterface:
             params=[],
             block_hash=block_hash,
             reuse_block_hash=reuse_block,
+            fully_exhaust=True,
+            page_size=1_000,
         )
 
         root_claim_types = {}
-        async for coldkey, claim_type_data in result:
+        for coldkey, claim_type_data in result.records:
             coldkey_ss58 = decode_account_id(coldkey[0])
 
             claim_type_key = next(iter(claim_type_data.value.keys()))
@@ -2338,9 +2315,11 @@ class SubtensorInterface:
             params=[hotkey_ss58, coldkey_ss58],
             block_hash=block_hash,
             reuse_block_hash=reuse_block,
+            fully_exhaust=True,
+            page_size=200,
         )
         total_claimed = {}
-        async for netuid, claimed in query:
+        for netuid, claimed in query.records:
             total_claimed[netuid] = Balance.from_rao(claimed.value).set_unit(
                 netuid=netuid
             )
@@ -2579,7 +2558,7 @@ class SubtensorInterface:
         return Balance.from_rao(int(current_price * 1e9))
 
     async def get_subnet_prices(
-        self, block_hash: Optional[str] = None, page_size: int = 100
+        self, block_hash: Optional[str] = None, page_size: int = 200
     ) -> dict[int, Balance]:
         """
         Gets the current Alpha prices in TAO for all subnets.
@@ -2594,10 +2573,11 @@ class SubtensorInterface:
             storage_function="AlphaSqrtPrice",
             page_size=page_size,
             block_hash=block_hash,
+            fully_exhaust=True,
         )
 
         map_ = {}
-        async for netuid_, current_sqrt_price in query:
+        for netuid_, current_sqrt_price in query.records:
             current_sqrt_price_ = fixed_to_float(current_sqrt_price.value)
             current_price = current_sqrt_price_**2
             map_[netuid_] = Balance.from_rao(int(current_price * 1e9))
@@ -2607,7 +2587,7 @@ class SubtensorInterface:
     async def get_all_subnet_ema_tao_inflow(
         self,
         block_hash: Optional[str] = None,
-        page_size: int = 100,
+        page_size: int = 200,
     ) -> dict[int, Balance]:
         """
         Query EMA TAO inflow for all subnets.
@@ -2627,9 +2607,10 @@ class SubtensorInterface:
             storage_function="SubnetEmaTaoFlow",
             page_size=page_size,
             block_hash=block_hash,
+            fully_exhaust=True,
         )
         ema_map = {}
-        async for netuid, value in query:
+        for netuid, value in query.records:
             if not value:
                 ema_map[netuid] = Balance.from_rao(0)
             else:

{bittensor_cli-9.20.0 → bittensor_cli-9.20.1}/bittensor_cli/src/bittensor/utils.py

@@ -147,6 +147,24 @@ def create_table(*columns, title: str = "", **overrides) -> Table:
     return Table(*columns, **config)
 
 
+def get_hotkey_identity_name(
+    identities: dict[str, Any], hotkey_ss58: str
+) -> Optional[str]:
+    """Return a hotkey display name from the V2 identity map, if present."""
+    hotkey_identity = identities.get("hotkeys", {}).get(hotkey_ss58, {})
+    identity_data = hotkey_identity.get("identity", {})
+    return identity_data.get("name") or identity_data.get("display") or None
+
+
+def get_coldkey_identity_name(
+    identities: dict[str, Any], coldkey_ss58: str
+) -> Optional[str]:
+    """Return a coldkey display name from the V2 identity map, if present."""
+    coldkey_identity = identities.get("coldkeys", {}).get(coldkey_ss58, {})
+    identity_data = coldkey_identity.get("identity", {})
+    return identity_data.get("name") or identity_data.get("display") or None
+
+
 jinja_env = Environment(
     loader=PackageLoader("bittensor_cli", "src/bittensor/templates"),
     autoescape=select_autoescape(),

{bittensor_cli-9.20.0 → bittensor_cli-9.20.1}/bittensor_cli/src/commands/stake/add.py

@@ -391,14 +391,14 @@ async def stake_add(
 
             # Temporary workaround - calculations without slippage
             current_price_float = float(subnet_info.price.tao)
-            rate = 1.0 / current_price_float
+            rate = _safe_inverse_rate(current_price_float)
 
             # If we are staking safe, add price tolerance
             if safe_staking:
                 if subnet_info.is_dynamic:
                     price_with_tolerance = current_price_float * (1 + rate_tolerance)
-                    _rate_with_tolerance = (
-                        1.0 / price_with_tolerance
+                    _rate_with_tolerance = _safe_inverse_rate(
+                        price_with_tolerance
                     )  # Rate only for display
                     rate_with_tolerance = f"{_rate_with_tolerance:.4f}"
                     price_with_tolerance = Balance.from_tao(
@@ -849,6 +849,11 @@ The columns are as follows:
     console.print(base_description + (safe_staking_description if safe_staking else ""))
 
 
+def _safe_inverse_rate(value: float) -> float:
+    """Returns the inverse of a positive rate, otherwise zero."""
+    return 1.0 / value if value > 0 else 0.0
+
+
 def _calculate_slippage(
     subnet_info, amount: Balance, stake_fee: Balance
 ) -> tuple[Balance, str, float, str]:
@@ -882,7 +887,7 @@ def _calculate_slippage(
         total_slippage = ideal_amount - received_amount
         slippage_pct_float = 100 * (total_slippage.tao / ideal_amount.tao)
         slippage_str = f"{slippage_pct_float:.4f} %"
-        rate = f"{(1 / subnet_info.price.tao or 1):.4f}"
+        rate = f"{_safe_inverse_rate(float(subnet_info.price.tao)):.4f}"
     else:
         # TODO: Fix this. Slippage is always zero for static networks.
         slippage_pct_float = (

{bittensor_cli-9.20.0 → bittensor_cli-9.20.1}/bittensor_cli/src/commands/stake/auto_staking.py

@@ -17,6 +17,8 @@ from bittensor_cli.src.bittensor.utils import (
     print_error,
     unlock_key,
     print_extrinsic_id,
+    get_hotkey_identity_name,
+    get_coldkey_identity_name,
 )
 
 if TYPE_CHECKING:
@@ -45,7 +47,6 @@ async def show_auto_stake_destinations(
             subnet_info,
             auto_destinations,
             identities,
-            delegate_identities,
         ) = await asyncio.gather(
             subtensor.all_subnets(block_hash=chain_head),
             subtensor.get_auto_stake_destinations(
@@ -54,36 +55,21 @@ async def show_auto_stake_destinations(
                 reuse_block=True,
             ),
             subtensor.fetch_coldkey_hotkey_identities(block_hash=chain_head),
-            subtensor.get_delegate_identities(block_hash=chain_head),
         )
 
     subnet_map = {info.netuid: info for info in subnet_info}
     auto_destinations = auto_destinations or {}
     identities = identities or {}
-    delegate_identities = delegate_identities or {}
-    hotkey_identities = identities.get("hotkeys", {})
 
     def resolve_identity(hotkey: str) -> Optional[str]:
         if not hotkey:
             return None
 
-        identity_entry = hotkey_identities.get(hotkey, {}).get("identity")
-        if identity_entry:
-            display_name = identity_entry.get("name") or identity_entry.get("display")
-            if display_name:
-                return display_name
-
-        delegate_info = delegate_identities.get(hotkey)
-        if delegate_info and getattr(delegate_info, "display", ""):
-            return delegate_info.display
-
-        return None
+        return get_hotkey_identity_name(identities, hotkey)
 
     coldkey_display = wallet_name
     if not coldkey_display:
-        coldkey_identity = identities.get("coldkeys", {}).get(coldkey_ss58, {})
-        if identity_data := coldkey_identity.get("identity"):
-            coldkey_display = identity_data.get("name") or identity_data.get("display")
+        coldkey_display = get_coldkey_identity_name(identities, coldkey_ss58)
         if not coldkey_display:
             coldkey_display = f"{coldkey_ss58[:6]}...{coldkey_ss58[-6:]}"
 
@@ -183,10 +169,9 @@ async def set_auto_stake_destination(
 
     try:
         chain_head = await subtensor.substrate.get_chain_head()
-        subnet_info, identities, delegate_identities = await asyncio.gather(
+        subnet_info, identities = await asyncio.gather(
             subtensor.subnet(netuid, block_hash=chain_head),
             subtensor.fetch_coldkey_hotkey_identities(block_hash=chain_head),
-            subtensor.get_delegate_identities(block_hash=chain_head),
         )
     except ValueError:
         print_error(f"Subnet with netuid {netuid} does not exist")
@@ -194,17 +179,8 @@ async def set_auto_stake_destination(
 
     hotkey_identity = ""
     identities = identities or {}
-    delegate_identities = delegate_identities or {}
 
-    hotkey_identity_entry = identities.get("hotkeys", {}).get(hotkey_ss58, {})
-    if identity_data := hotkey_identity_entry.get("identity"):
-        hotkey_identity = (
-            identity_data.get("name") or identity_data.get("display") or ""
-        )
-    if not hotkey_identity:
-        delegate_info = delegate_identities.get(hotkey_ss58)
-        if delegate_info and getattr(delegate_info, "display", ""):
-            hotkey_identity = delegate_info.display
+    hotkey_identity = get_hotkey_identity_name(identities, hotkey_ss58) or ""
 
     if prompt_user and not json_output:
         table = create_table(