bittensor-cli 9.10.2__py3-none-any.whl → 9.11.1__py3-none-any.whl

bittensor_cli/src/__init__.py

@@ -23,6 +23,7 @@ class Constants:
     dev_entrypoint = "wss://dev.chain.opentensor.ai:443"
     local_entrypoint = "ws://127.0.0.1:9944"
     latent_lite_entrypoint = "wss://lite.sub.latent.to:443"
+    lite_nodes = [finney_entrypoint, subvortex_entrypoint, latent_lite_entrypoint]
     network_map = {
         "finney": finney_entrypoint,
         "test": finney_test_entrypoint,
@@ -88,12 +89,14 @@ class Defaults:
     class config:
         base_path = "~/.bittensor"
         path = "~/.bittensor/config.yml"
+        debug_file_path = "~/.bittensor/debug.txt"
         dictionary = {
             "network": None,
             "wallet_path": None,
             "wallet_name": None,
             "wallet_hotkey": None,
             "use_cache": True,
+            "disk_cache": False,
             "metagraph_cols": {
                 "UID": True,
                 "GLOBAL_STAKE": True,
@@ -638,7 +641,7 @@ HYPERPARAMS = {
     "adjustment_interval": ("sudo_set_adjustment_interval", True),
     "activity_cutoff": ("sudo_set_activity_cutoff", False),
     "target_regs_per_interval": ("sudo_set_target_registrations_per_interval", True),
-    "min_burn": ("sudo_set_min_burn", True),
+    "min_burn": ("sudo_set_min_burn", False),
     "max_burn": ("sudo_set_max_burn", True),
     "bonds_moving_avg": ("sudo_set_bonds_moving_average", False),
     "max_regs_per_block": ("sudo_set_max_registrations_per_block", True),

bittensor_cli/src/bittensor/chain_data.py

@@ -1193,3 +1193,20 @@ class MetagraphInfo(InfoBase):
                 for adphk in decoded["alpha_dividends_per_hotkey"]
             ],
         )
+
+
+@dataclass
+class SimSwapResult:
+    tao_amount: Balance
+    alpha_amount: Balance
+    tao_fee: Balance
+    alpha_fee: Balance
+
+    @classmethod
+    def from_dict(cls, d: dict, netuid: int) -> "SimSwapResult":
+        return cls(
+            tao_amount=Balance.from_rao(d["tao_amount"]).set_unit(0),
+            alpha_amount=Balance.from_rao(d["alpha_amount"]).set_unit(netuid),
+            tao_fee=Balance.from_rao(d["tao_fee"]).set_unit(0),
+            alpha_fee=Balance.from_rao(d["alpha_fee"]).set_unit(netuid),
+        )

bittensor_cli/src/bittensor/extrinsics/transfer.py

@@ -175,7 +175,9 @@ async def transfer_extrinsic(
             f"  amount: [bright_cyan]{amount if not transfer_all else account_balance}[/bright_cyan]\n"
             f"  from: [light_goldenrod2]{wallet.name}[/light_goldenrod2] : "
             f"[bright_magenta]{wallet.coldkey.ss58_address}\n[/bright_magenta]"
-            f"  to: [bright_magenta]{destination}[/bright_magenta]\n  for fee: [bright_cyan]{fee}[/bright_cyan]"
+            f"  to: [bright_magenta]{destination}[/bright_magenta]\n  for fee: [bright_cyan]{fee}[/bright_cyan]\n"
+            f":warning:[bright_yellow]Transferring is not the same as staking. To instead stake, use "
+            f"[dark_orange]btcli stake add[/dark_orange] instead[/bright_yellow]:warning:"
         ):
             return False
 

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -1,21 +1,22 @@
 import asyncio
 import os
+import time
 from typing import Optional, Any, Union, TypedDict, Iterable
 
 import aiohttp
+from async_substrate_interface.async_substrate import (
+    DiskCachedAsyncSubstrateInterface,
+    AsyncSubstrateInterface,
+)
+from async_substrate_interface.errors import SubstrateRequestException
 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
 import typer
+import websockets
 
-
-from async_substrate_interface.async_substrate import (
-    DiskCachedAsyncSubstrateInterface,
-    AsyncSubstrateInterface,
-)
 from bittensor_cli.src.bittensor.chain_data import (
     DelegateInfo,
     StakeInfo,
@@ -27,6 +28,7 @@ from bittensor_cli.src.bittensor.chain_data import (
     DynamicInfo,
     SubnetState,
     MetagraphInfo,
+    SimSwapResult,
 )
 from bittensor_cli.src import DelegatesDetails
 from bittensor_cli.src.bittensor.balances import Balance, fixed_to_float
@@ -42,12 +44,6 @@ from bittensor_cli.src.bittensor.utils import (
     get_hotkey_pub_ss58,
 )
 
-SubstrateClass = (
-    DiskCachedAsyncSubstrateInterface
-    if os.getenv("DISK_CACHE", "0") == "1"
-    else AsyncSubstrateInterface
-)
-
 
 class ParamWithTypes(TypedDict):
     name: str  # Name of the parameter.
@@ -81,7 +77,7 @@ class SubtensorInterface:
     Thin layer for interacting with Substrate Interface. Mostly a collection of frequently-used calls.
     """
 
-    def __init__(self, network):
+    def __init__(self, network, use_disk_cache: bool = False):
         if network in Constants.network_map:
             self.chain_endpoint = Constants.network_map[network]
             self.network = network
@@ -111,8 +107,12 @@ class SubtensorInterface:
                 )
                 self.chain_endpoint = Constants.network_map[defaults.subtensor.network]
                 self.network = defaults.subtensor.network
-
-        self.substrate = SubstrateClass(
+        substrate_class = (
+            DiskCachedAsyncSubstrateInterface
+            if (use_disk_cache or os.getenv("DISK_CACHE", "0") == "1")
+            else AsyncSubstrateInterface
+        )
+        self.substrate = substrate_class(
             url=self.chain_endpoint,
             ss58_format=SS58_FORMAT,
             type_registry=TYPE_REGISTRY,
@@ -1503,59 +1503,79 @@ class SubtensorInterface:
         fee_dict = await self.substrate.get_payment_info(call, keypair)
         return Balance.from_rao(fee_dict["partial_fee"])
 
-    async def get_stake_fee(
+    async def sim_swap(
         self,
-        origin_hotkey_ss58: Optional[str],
-        origin_netuid: Optional[int],
-        origin_coldkey_ss58: str,
-        destination_hotkey_ss58: Optional[str],
-        destination_netuid: Optional[int],
-        destination_coldkey_ss58: str,
+        origin_netuid: int,
+        destination_netuid: int,
         amount: int,
         block_hash: Optional[str] = None,
-    ) -> Balance:
+    ) -> SimSwapResult:
         """
-        Calculates the fee for a staking operation.
-
-        :param origin_hotkey_ss58: SS58 address of source hotkey (None for new stake)
-        :param origin_netuid: Netuid of source subnet (None for new stake)
-        :param origin_coldkey_ss58: SS58 address of source coldkey
-        :param destination_hotkey_ss58: SS58 address of destination hotkey (None for removing stake)
-        :param destination_netuid: Netuid of destination subnet (None for removing stake)
-        :param destination_coldkey_ss58: SS58 address of destination coldkey
-        :param amount: Amount of stake to transfer in RAO
-        :param block_hash: Optional block hash at which to perform the calculation
-
-        :return: The calculated stake fee as a Balance object
-
-        When to use None:
-
-        1. Adding new stake (default fee):
-        - origin_hotkey_ss58 = None
-        - origin_netuid = None
-        - All other fields required
+        Hits the SimSwap Runtime API to calculate the fee and result for a given transaction. This should be used
+        instead of get_stake_fee for staking fee calculations. The SimSwapResult contains the staking fees and expected
+        returned amounts of a given transaction. This does not include the transaction (extrinsic) fee.
 
-        2. Removing stake (default fee):
-        - destination_hotkey_ss58 = None
-        - destination_netuid = None
-        - All other fields required
+        Args:
+            origin_netuid: Netuid of the source subnet (0 if new stake)
+            destination_netuid: Netuid of the destination subnet
+            amount: Amount to transfer in Rao
+            block_hash: The hash of the blockchain block number for the query.
 
-        For all other operations, no None values - provide all parameters:
-        3. Moving between subnets
-        4. Moving between hotkeys
-        5. Moving between coldkeys
+        Returns:
+            SimSwapResult object representing the result
         """
-
-        if origin_netuid is None:
-            origin_netuid = 0
-
-        fee_rate = await self.query("Swap", "FeeRate", [origin_netuid])
-        fee = amount * (fee_rate / U16_MAX)
-
-        result = Balance.from_rao(fee)
-        result.set_unit(origin_netuid)
-
-        return result
+        block_hash = block_hash or await self.substrate.get_chain_head()
+        if origin_netuid > 0 and destination_netuid > 0:
+            # for cross-subnet moves where neither origin nor destination is root
+            intermediate_result_, sn_price = await asyncio.gather(
+                self.query_runtime_api(
+                    "SwapRuntimeApi",
+                    "sim_swap_alpha_for_tao",
+                    params={"netuid": origin_netuid, "alpha": amount},
+                    block_hash=block_hash,
+                ),
+                self.get_subnet_price(origin_netuid, block_hash=block_hash),
+            )
+            intermediate_result = SimSwapResult.from_dict(
+                intermediate_result_, origin_netuid
+            )
+            result = SimSwapResult.from_dict(
+                await self.query_runtime_api(
+                    "SwapRuntimeApi",
+                    "sim_swap_tao_for_alpha",
+                    params={
+                        "netuid": destination_netuid,
+                        "tao": intermediate_result.tao_amount,
+                    },
+                    block_hash=block_hash,
+                ),
+                destination_netuid,
+            )
+            secondary_fee = (result.tao_fee * sn_price).set_unit(origin_netuid)
+            result.alpha_fee = result.alpha_fee + secondary_fee
+            return result
+        elif origin_netuid > 0:
+            # dynamic to tao
+            return SimSwapResult.from_dict(
+                await self.query_runtime_api(
+                    "SwapRuntimeApi",
+                    "sim_swap_alpha_for_tao",
+                    params={"netuid": origin_netuid, "alpha": amount},
+                    block_hash=block_hash,
+                ),
+                origin_netuid,
+            )
+        else:
+            # tao to dynamic or unstaked to staked tao (SN0)
+            return SimSwapResult.from_dict(
+                await self.query_runtime_api(
+                    "SwapRuntimeApi",
+                    "sim_swap_tao_for_alpha",
+                    params={"netuid": destination_netuid, "tao": amount},
+                    block_hash=block_hash,
+                ),
+                destination_netuid,
+            )
 
     async def get_scheduled_coldkey_swap(
         self,
@@ -1656,3 +1676,32 @@ class SubtensorInterface:
             map_[netuid_] = Balance.from_rao(int(current_price * 1e9))
 
         return map_
+
+
+async def best_connection(networks: list[str]):
+    """
+    Basic function to compare the latency of a given list of websocket endpoints
+    Args:
+        networks: list of network URIs
+
+    Returns:
+        {network_name: [end_to_end_latency, single_request_latency, chain_head_request_latency]}
+
+    """
+    results = {}
+    for network in networks:
+        try:
+            t1 = time.monotonic()
+            async with websockets.connect(network) as websocket:
+                pong = await websocket.ping()
+                latency = await pong
+                pt1 = time.monotonic()
+                await websocket.send(
+                    "{'jsonrpc': '2.0', 'method': 'chain_getHead', 'params': [], 'id': '82'}"
+                )
+                await websocket.recv()
+                t2 = time.monotonic()
+            results[network] = [t2 - t1, latency, t2 - pt1]
+        except Exception as e:
+            err_console.print(f"Error attempting network {network}: {e}")
+    return results

bittensor_cli/src/bittensor/utils.py

@@ -266,13 +266,29 @@ def get_hotkey_wallets_for_wallet(
     hotkeys_path = wallet_path / wallet.name / "hotkeys"
     try:
         hotkeys = [entry.name for entry in hotkeys_path.iterdir()]
-    except FileNotFoundError:
+    except (FileNotFoundError, NotADirectoryError):
         hotkeys = []
     for h_name in hotkeys:
-        hotkey_for_name = Wallet(path=str(wallet_path), name=wallet.name, hotkey=h_name)
+        if h_name.endswith("pub.txt"):
+            if h_name.split("pub.txt")[0] in hotkeys:
+                continue
+            else:
+                hotkey_for_name = Wallet(
+                    path=str(wallet_path),
+                    name=wallet.name,
+                    hotkey=h_name.split("pub.txt")[0],
+                )
+        else:
+            hotkey_for_name = Wallet(
+                path=str(wallet_path), name=wallet.name, hotkey=h_name
+            )
         try:
+            exists = (
+                hotkey_for_name.hotkey_file.exists_on_device()
+                or hotkey_for_name.hotkeypub_file.exists_on_device()
+            )
             if (
-                (exists := hotkey_for_name.hotkey_file.exists_on_device())
+                exists
                 and not hotkey_for_name.hotkey_file.is_encrypted()
                 # and hotkey_for_name.coldkeypub.ss58_address
                 and get_hotkey_pub_ss58(hotkey_for_name)
@@ -291,6 +307,7 @@ def get_hotkey_wallets_for_wallet(
             AttributeError,
             TypeError,
             KeyFileError,
+            ValueError,
         ):  # usually an unrelated file like .DS_Store
             continue
 

bittensor_cli/src/commands/stake/add.py

@@ -347,17 +347,6 @@ async def stake_add(
                 return False
             remaining_wallet_balance -= amount_to_stake
 
-            # TODO this should be asyncio gathered before the for loop
-            stake_fee = await subtensor.get_stake_fee(
-                origin_hotkey_ss58=None,
-                origin_netuid=None,
-                origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
-                destination_hotkey_ss58=hotkey[1],
-                destination_netuid=netuid,
-                destination_coldkey_ss58=wallet.coldkeypub.ss58_address,
-                amount=amount_to_stake.rao,
-            )
-
             # Calculate slippage
             # TODO: Update for V3, slippage calculation is significantly different in v3
             # try:
@@ -409,7 +398,13 @@ async def stake_add(
                     safe_staking_=safe_staking,
                 )
                 row_extension = []
-            received_amount = rate * (amount_to_stake - stake_fee - extrinsic_fee)
+            # TODO this should be asyncio gathered before the for loop
+            sim_swap = await subtensor.sim_swap(
+                origin_netuid=0,
+                destination_netuid=netuid,
+                amount=(amount_to_stake - extrinsic_fee).rao,
+            )
+            received_amount = sim_swap.alpha_amount
             # Add rows for the table
             base_row = [
                 str(netuid),  # netuid
@@ -418,7 +413,7 @@ async def stake_add(
                 str(rate)
                 + f" {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",  # rate
                 str(received_amount.set_unit(netuid)),  # received
-                str(stake_fee),  # fee
+                str(sim_swap.tao_fee),  # fee
                 str(extrinsic_fee),
                 # str(slippage_pct),  # slippage
             ] + row_extension

bittensor_cli/src/commands/stake/move.py

@@ -520,14 +520,10 @@ async def move_stake(
             "alpha_amount": amount_to_move_as_balance.rao,
         },
     )
-    stake_fee, extrinsic_fee = await asyncio.gather(
-        subtensor.get_stake_fee(
-            origin_hotkey_ss58=origin_hotkey,
+    sim_swap, extrinsic_fee = await asyncio.gather(
+        subtensor.sim_swap(
             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),
@@ -543,7 +539,9 @@ async def move_stake(
                 origin_hotkey=origin_hotkey,
                 destination_hotkey=destination_hotkey,
                 amount_to_move=amount_to_move_as_balance,
-                stake_fee=stake_fee,
+                stake_fee=sim_swap.alpha_fee
+                if origin_netuid != 0
+                else sim_swap.tao_fee,
                 extrinsic_fee=extrinsic_fee,
             )
         except ValueError:
@@ -709,14 +707,10 @@ async def transfer_stake(
             "alpha_amount": amount_to_transfer.rao,
         },
     )
-    stake_fee, extrinsic_fee = await asyncio.gather(
-        subtensor.get_stake_fee(
-            origin_hotkey_ss58=origin_hotkey,
+    sim_swap, extrinsic_fee = await asyncio.gather(
+        subtensor.sim_swap(
             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),
@@ -732,7 +726,9 @@ async def transfer_stake(
                 origin_hotkey=origin_hotkey,
                 destination_hotkey=origin_hotkey,
                 amount_to_move=amount_to_transfer,
-                stake_fee=stake_fee,
+                stake_fee=sim_swap.alpha_fee
+                if origin_netuid != 0
+                else sim_swap.tao_fee,
                 extrinsic_fee=extrinsic_fee,
             )
         except ValueError:
@@ -880,14 +876,10 @@ async def swap_stake(
             "alpha_amount": amount_to_swap.rao,
         },
     )
-    stake_fee, extrinsic_fee = await asyncio.gather(
-        subtensor.get_stake_fee(
-            origin_hotkey_ss58=hotkey_ss58,
+    sim_swap, extrinsic_fee = await asyncio.gather(
+        subtensor.sim_swap(
             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),
@@ -903,7 +895,9 @@ async def swap_stake(
                 origin_hotkey=hotkey_ss58,
                 destination_hotkey=hotkey_ss58,
                 amount_to_move=amount_to_swap,
-                stake_fee=stake_fee,
+                stake_fee=sim_swap.alpha_fee
+                if origin_netuid != 0
+                else sim_swap.tao_fee,
                 extrinsic_fee=extrinsic_fee,
             )
         except ValueError:

bittensor_cli/src/commands/stake/remove.py

@@ -200,16 +200,6 @@ async def unstake(
                 )
                 continue  # Skip to the next subnet - useful when single amount is specified for all subnets
 
-            stake_fee = await subtensor.get_stake_fee(
-                origin_hotkey_ss58=staking_address_ss58,
-                origin_netuid=netuid,
-                origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
-                destination_hotkey_ss58=None,
-                destination_netuid=None,
-                destination_coldkey_ss58=wallet.coldkeypub.ss58_address,
-                amount=amount_to_unstake_as_balance.rao,
-            )
-
             try:
                 current_price = subnet_info.price.tao
                 if safe_staking:
@@ -240,10 +230,10 @@ async def unstake(
                         netuid=netuid,
                         amount=amount_to_unstake_as_balance,
                     )
-                rate = current_price
-                received_amount = (
-                    (amount_to_unstake_as_balance - stake_fee) * rate
-                ) - extrinsic_fee
+                sim_swap = await subtensor.sim_swap(
+                    netuid, 0, amount_to_unstake_as_balance.rao
+                )
+                received_amount = sim_swap.tao_amount - extrinsic_fee
             except ValueError:
                 continue
             total_received_amount += received_amount
@@ -266,7 +256,7 @@ async def unstake(
                 str(amount_to_unstake_as_balance),  # Amount to Unstake
                 f"{subnet_info.price.tao:.6f}"
                 + f"(τ/{Balance.get_unit(netuid)})",  # Rate
-                str(stake_fee.set_unit(netuid)),  # Fee
+                str(sim_swap.alpha_fee),  # Fee
                 str(extrinsic_fee),  # Extrinsic fee
                 str(received_amount),  # Received Amount
                 # slippage_pct,  # Slippage Percent
@@ -361,6 +351,7 @@ async def unstake(
     )
     if json_output:
         json_console.print(json.dumps(successes))
+    return True
 
 
 async def unstake_all(
@@ -493,15 +484,6 @@ async def unstake_all(
             hotkey_display = hotkey_names.get(stake.hotkey_ss58, stake.hotkey_ss58)
             subnet_info = all_sn_dynamic_info.get(stake.netuid)
             stake_amount = stake.stake
-            stake_fee = await subtensor.get_stake_fee(
-                origin_hotkey_ss58=stake.hotkey_ss58,
-                origin_netuid=stake.netuid,
-                origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
-                destination_hotkey_ss58=None,
-                destination_netuid=None,
-                destination_coldkey_ss58=wallet.coldkeypub.ss58_address,
-                amount=stake_amount.rao,
-            )
 
             try:
                 current_price = subnet_info.price.tao
@@ -514,8 +496,8 @@ async def unstake_all(
                     subtensor,
                     hotkey_ss58=stake.hotkey_ss58,
                 )
-                rate = current_price
-                received_amount = ((stake_amount - stake_fee) * rate) - extrinsic_fee
+                sim_swap = await subtensor.sim_swap(stake.netuid, 0, stake_amount.rao)
+                received_amount = sim_swap.tao_amount - extrinsic_fee
 
                 if received_amount < Balance.from_tao(0):
                     print_error("Not enough Alpha to pay the transaction fee.")
@@ -531,7 +513,7 @@ async def unstake_all(
                 str(stake_amount),
                 f"{float(subnet_info.price):.6f}"
                 + f"({Balance.get_unit(0)}/{Balance.get_unit(stake.netuid)})",
-                str(stake_fee),
+                str(sim_swap.alpha_fee),
                 str(extrinsic_fee),
                 str(received_amount),
             )

bittensor_cli/src/commands/subnets/price.py

@@ -52,7 +52,17 @@ async def price(
 
             step = 300
             start_block = max(0, current_block - total_blocks)
-            block_numbers = list(range(start_block, current_block + 1, step))
+
+            # snap start block down to nearest multiple of 10
+            start_block -= start_block % 10
+
+            block_numbers = []
+            for b in range(start_block, current_block + 1, step):
+                if b == current_block:
+                    block_numbers.append(b)  # exact current block
+                else:
+                    block_numbers.append(b - (b % 5))  # snap down to multiple of 10
+            block_numbers = sorted(set(block_numbers))
 
             # Block hashes
             block_hash_cors = [

bittensor_cli/src/commands/subnets/subnets.py

@@ -2448,3 +2448,71 @@ async def start_subnet(
             await get_start_schedule(subtensor, netuid)
             print_error(f":cross_mark: Failed to start subnet: {error_msg}")
             return False
+
+
+async def set_symbol(
+    wallet: "Wallet",
+    subtensor: "SubtensorInterface",
+    netuid: int,
+    symbol: str,
+    prompt: bool = False,
+    json_output: bool = False,
+) -> bool:
+    """
+    Set a subtensor's symbol, given the netuid and symbol.
+
+    The symbol must be a symbol that subtensor recognizes as available
+    (defined in https://github.com/opentensor/subtensor/blob/main/pallets/subtensor/src/subnets/symbols.rs#L8)
+    """
+    if not await subtensor.subnet_exists(netuid):
+        err = f"Subnet {netuid} does not exist."
+        if json_output:
+            json_console.print_json(data={"success": False, "message": err})
+        else:
+            err_console.print(err)
+        return False
+
+    if prompt and not json_output:
+        sn_info = await subtensor.subnet(netuid=netuid)
+        if not Confirm.ask(
+            f"Your current subnet symbol for SN{netuid} is {sn_info.symbol}. Do you want to update it to {symbol}?"
+        ):
+            return False
+
+    if not (unlock_status := unlock_key(wallet, print_out=False)).success:
+        err = unlock_status.message
+        if json_output:
+            json_console.print_json(data={"success": False, "message": err})
+        else:
+            console.print(err)
+        return False
+
+    start_call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="update_symbol",
+        call_params={"netuid": netuid, "symbol": symbol.encode("utf-8")},
+    )
+
+    signed_ext = await subtensor.substrate.create_signed_extrinsic(
+        call=start_call,
+        keypair=wallet.coldkey,
+    )
+
+    response = await subtensor.substrate.submit_extrinsic(
+        extrinsic=signed_ext,
+        wait_for_inclusion=True,
+    )
+    if await response.is_success:
+        message = f"Successfully updated SN{netuid}'s symbol to {symbol}."
+        if json_output:
+            json_console.print_json(data={"success": True, "message": message})
+        else:
+            console.print(f":white_heavy_check_mark:[dark_sea_green3] {message}\n")
+        return True
+    else:
+        err = format_error_message(await response.error_message)
+        if json_output:
+            json_console.print_json(data={"success": False, "message": err})
+        else:
+            err_console.print(f":cross_mark: [red]Failed[/red]: {err}")
+        return False

bittensor_cli/src/commands/sudo.py

@@ -34,6 +34,7 @@ if TYPE_CHECKING:
         SubtensorInterface,
         ProposalVoteData,
     )
+    from scalecodec.types import GenericMetadataVersioned
 
 
 # helpers and extrinsics
@@ -91,8 +92,8 @@ def search_metadata(
     param_name: str,
     value: Union[str, bool, float, list[float]],
     netuid: int,
-    metadata,
-    pallet: str = DEFAULT_PALLET,
+    metadata: "GenericMetadataVersioned",
+    pallet_name: str = DEFAULT_PALLET,
 ) -> tuple[bool, Optional[dict]]:
     """
     Searches the substrate metadata AdminUtils pallet for a given parameter name. Crafts a response dict to be used
@@ -103,7 +104,7 @@ def search_metadata(
         value: the value to set the hyperparameter
         netuid: the specified netuid
         metadata: the subtensor.substrate.metadata
-        pallet: the name of the module to use for the query. If not set, the default value is DEFAULT_PALLET
+        pallet_name: the name of the module to use for the query. If not set, the default value is DEFAULT_PALLET
 
     Returns:
         (success, dict of call params)
@@ -125,7 +126,7 @@ def search_metadata(
 
     call_crafter = {"netuid": netuid}
 
-    pallet = metadata.get_metadata_pallet(pallet)
+    pallet = metadata.get_metadata_pallet(pallet_name)
     for call in pallet.calls:
         if call.name == param_name:
             if "netuid" not in [x.name for x in call.args]: