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

bittensor_cli/src/commands/stake/remove.py

@@ -49,26 +49,36 @@ async def unstake(
         f"Retrieving subnet data & identities from {subtensor.network}...",
         spinner="earth",
     ):
-        all_sn_dynamic_info_, ck_hk_identities, old_identities = await asyncio.gather(
-            subtensor.all_subnets(),
-            subtensor.fetch_coldkey_hotkey_identities(),
-            subtensor.get_delegate_identities(),
+        chain_head = await subtensor.substrate.get_chain_head()
+        (
+            all_sn_dynamic_info_,
+            ck_hk_identities,
+            old_identities,
+            stake_infos,
+        ) = await asyncio.gather(
+            subtensor.all_subnets(block_hash=chain_head),
+            subtensor.fetch_coldkey_hotkey_identities(block_hash=chain_head),
+            subtensor.get_delegate_identities(block_hash=chain_head),
+            subtensor.get_stake_for_coldkey(
+                wallet.coldkeypub.ss58_address, block_hash=chain_head
+            ),
         )
         all_sn_dynamic_info = {info.netuid: info for info in all_sn_dynamic_info_}
 
     if interactive:
         hotkeys_to_unstake_from, unstake_all_from_hk = await _unstake_selection(
-            subtensor,
-            wallet,
             all_sn_dynamic_info,
             ck_hk_identities,
             old_identities,
+            stake_infos,
             netuid=netuid,
         )
         if unstake_all_from_hk:
             hotkey_to_unstake_all = hotkeys_to_unstake_from[0]
             unstake_all_alpha = Confirm.ask(
-                "\nUnstake [blue]all alpha stakes[/blue] and stake back to [blue]root[/blue]? (No will unstake everything)",
+                "\nDo you want to:\n"
+                "[blue]Yes[/blue]: Unstake from all subnets and automatically restake to subnet 0 (root)\n"
+                "[blue]No[/blue]: Unstake everything (including subnet 0)",
                 default=True,
             )
             return await unstake_all(
@@ -96,20 +106,17 @@ async def unstake(
             all_hotkeys=all_hotkeys,
             include_hotkeys=include_hotkeys,
             exclude_hotkeys=exclude_hotkeys,
+            stake_infos=stake_infos,
+            identities=ck_hk_identities,
+            old_identities=old_identities,
         )
 
     with console.status(
         f"Retrieving stake data from {subtensor.network}...",
         spinner="earth",
     ):
-        # Fetch stake balances
-        chain_head = await subtensor.substrate.get_chain_head()
-        stake_info_list = await subtensor.get_stake_for_coldkey(
-            coldkey_ss58=wallet.coldkeypub.ss58_address,
-            block_hash=chain_head,
-        )
         stake_in_netuids = {}
-        for stake_info in stake_info_list:
+        for stake_info in stake_infos:
             if stake_info.hotkey_ss58 not in stake_in_netuids:
                 stake_in_netuids[stake_info.hotkey_ss58] = {}
             stake_in_netuids[stake_info.hotkey_ss58][stake_info.netuid] = (
@@ -313,6 +320,9 @@ async def unstake_all(
     subtensor: "SubtensorInterface",
     hotkey_ss58_address: str,
     unstake_all_alpha: bool = False,
+    all_hotkeys: bool = False,
+    include_hotkeys: list[str] = [],
+    exclude_hotkeys: list[str] = [],
     prompt: bool = True,
 ) -> bool:
     """Unstakes all stakes from all hotkeys in all subnets."""
@@ -334,10 +344,27 @@ async def unstake_all(
             subtensor.all_subnets(),
             subtensor.get_balance(wallet.coldkeypub.ss58_address),
         )
-        if not hotkey_ss58_address:
-            hotkey_ss58_address = wallet.hotkey.ss58_address
+
+        if all_hotkeys:
+            hotkeys = _get_hotkeys_to_unstake(
+                wallet,
+                hotkey_ss58_address=hotkey_ss58_address,
+                all_hotkeys=all_hotkeys,
+                include_hotkeys=include_hotkeys,
+                exclude_hotkeys=exclude_hotkeys,
+                stake_infos=stake_info,
+                identities=ck_hk_identities,
+                old_identities=old_identities,
+            )
+        elif not hotkey_ss58_address:
+            hotkeys = [(wallet.hotkey_str, wallet.hotkey.ss58_address)]
+        else:
+            hotkeys = [(None, hotkey_ss58_address)]
+
+        hotkey_names = {ss58: name for name, ss58 in hotkeys if name is not None}
+        hotkey_ss58s = [ss58 for _, ss58 in hotkeys]
         stake_info = [
-            stake for stake in stake_info if stake.hotkey_ss58 == hotkey_ss58_address
+            stake for stake in stake_info if stake.hotkey_ss58 in hotkey_ss58s
         ]
 
         if unstake_all_alpha:
@@ -403,18 +430,7 @@ async def unstake_all(
             if stake.stake.rao == 0:
                 continue
 
-            # Get hotkey identity
-            if hk_identity := ck_hk_identities["hotkeys"].get(stake.hotkey_ss58):
-                hotkey_name = hk_identity.get("identity", {}).get(
-                    "name", ""
-                ) or hk_identity.get("display", "~")
-                hotkey_display = f"{hotkey_name}"
-            elif old_identity := old_identities.get(stake.hotkey_ss58):
-                hotkey_name = old_identity.display
-                hotkey_display = f"{hotkey_name}"
-            else:
-                hotkey_display = stake.hotkey_ss58
-
+            hotkey_display = hotkey_names.get(stake.hotkey_ss58, stake.hotkey_ss58)
             subnet_info = all_sn_dynamic_info.get(stake.netuid)
             stake_amount = stake.stake
             received_amount, slippage_pct, slippage_pct_float = _calculate_slippage(
@@ -455,56 +471,16 @@ async def unstake_all(
         err_console.print("Error decrypting coldkey (possibly incorrect password)")
         return False
 
-    console_status = (
-        ":satellite: Unstaking all Alpha stakes..."
-        if unstake_all_alpha
-        else ":satellite: Unstaking all stakes..."
-    )
-    previous_root_stake = await subtensor.get_stake(
-        hotkey_ss58=hotkey_ss58_address,
-        coldkey_ss58=wallet.coldkeypub.ss58_address,
-        netuid=0,
-    )
-    with console.status(console_status):
-        call_function = "unstake_all_alpha" if unstake_all_alpha else "unstake_all"
-        call = await subtensor.substrate.compose_call(
-            call_module="SubtensorModule",
-            call_function=call_function,
-            call_params={"hotkey": hotkey_ss58_address},
-        )
-        success, error_message = await subtensor.sign_and_send_extrinsic(
-            call=call,
-            wallet=wallet,
-            wait_for_inclusion=True,
-            wait_for_finalization=False,
-        )
-
-        if success:
-            success_message = (
-                ":white_heavy_check_mark: [green]Successfully unstaked all stakes[/green]"
-                if not unstake_all_alpha
-                else ":white_heavy_check_mark: [green]Successfully unstaked all Alpha stakes[/green]"
-            )
-            console.print(success_message)
-            new_balance = await subtensor.get_balance(wallet.coldkeypub.ss58_address)
-            console.print(
-                f"Balance:\n [blue]{current_wallet_balance}[/blue] :arrow_right: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_balance}"
-            )
-            if unstake_all_alpha:
-                root_stake = await subtensor.get_stake(
-                    hotkey_ss58=hotkey_ss58_address,
-                    coldkey_ss58=wallet.coldkeypub.ss58_address,
-                    netuid=0,
-                )
-                console.print(
-                    f"Root Stake:\n [blue]{previous_root_stake}[/blue] :arrow_right: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{root_stake}"
-                )
-            return True
-        else:
-            err_console.print(
-                f":cross_mark: [red]Failed to unstake[/red]: {error_message}"
+    with console.status("Unstaking all stakes...") as status:
+        for hotkey_ss58 in hotkey_ss58s:
+            await _unstake_all_extrinsic(
+                wallet=wallet,
+                subtensor=subtensor,
+                hotkey_ss58=hotkey_ss58,
+                hotkey_name=hotkey_names.get(hotkey_ss58, hotkey_ss58),
+                unstake_all_alpha=unstake_all_alpha,
+                status=status,
             )
-            return False
 
 
 # Extrinsics
@@ -666,9 +642,7 @@ async def _safe_unstake_extrinsic(
             )
             return
         else:
-            err_out(
-                f"\n{failure_prelude} with error: {format_error_message(e)}"
-            )
+            err_out(f"\n{failure_prelude} with error: {format_error_message(e)}")
         return
 
     await response.process_events()
@@ -709,6 +683,115 @@ async def _safe_unstake_extrinsic(
     )
 
 
+async def _unstake_all_extrinsic(
+    wallet: Wallet,
+    subtensor: "SubtensorInterface",
+    hotkey_ss58: str,
+    hotkey_name: str,
+    unstake_all_alpha: bool,
+    status=None,
+) -> None:
+    """Execute an unstake all extrinsic.
+
+    Args:
+        wallet: Wallet instance
+        subtensor: Subtensor interface
+        hotkey_ss58: Hotkey SS58 address
+        hotkey_name: Display name of the hotkey
+        unstake_all_alpha: Whether to unstake only alpha stakes
+        status: Optional status for console updates
+    """
+    err_out = partial(print_error, status=status)
+    failure_prelude = (
+        f":cross_mark: [red]Failed[/red] to unstake all from {hotkey_name}"
+    )
+
+    if status:
+        status.update(
+            f"\n:satellite: {'Unstaking all Alpha stakes' if unstake_all_alpha else 'Unstaking all stakes'} from {hotkey_name} ..."
+        )
+
+    block_hash = await subtensor.substrate.get_chain_head()
+    if unstake_all_alpha:
+        previous_root_stake, current_balance = await asyncio.gather(
+            subtensor.get_stake(
+                hotkey_ss58=hotkey_ss58,
+                coldkey_ss58=wallet.coldkeypub.ss58_address,
+                netuid=0,
+                block_hash=block_hash,
+            ),
+            subtensor.get_balance(
+                wallet.coldkeypub.ss58_address, block_hash=block_hash
+            ),
+        )
+    else:
+        current_balance = await subtensor.get_balance(
+            wallet.coldkeypub.ss58_address, block_hash=block_hash
+        )
+
+    call_function = "unstake_all_alpha" if unstake_all_alpha else "unstake_all"
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function=call_function,
+        call_params={"hotkey": hotkey_ss58},
+    )
+
+    try:
+        response = await subtensor.substrate.submit_extrinsic(
+            extrinsic=await subtensor.substrate.create_signed_extrinsic(
+                call=call,
+                keypair=wallet.coldkey,
+            ),
+            wait_for_inclusion=True,
+            wait_for_finalization=False,
+        )
+        await response.process_events()
+
+        if not await response.is_success:
+            err_out(
+                f"{failure_prelude} with error: "
+                f"{format_error_message(await response.error_message)}"
+            )
+            return
+
+        # Fetch latest balance and stake
+        block_hash = await subtensor.substrate.get_chain_head()
+        if unstake_all_alpha:
+            new_root_stake, new_balance = await asyncio.gather(
+                subtensor.get_stake(
+                    hotkey_ss58=hotkey_ss58,
+                    coldkey_ss58=wallet.coldkeypub.ss58_address,
+                    netuid=0,
+                    block_hash=block_hash,
+                ),
+                subtensor.get_balance(
+                    wallet.coldkeypub.ss58_address, block_hash=block_hash
+                ),
+            )
+        else:
+            new_balance = await subtensor.get_balance(
+                wallet.coldkeypub.ss58_address, block_hash=block_hash
+            )
+
+        success_message = (
+            ":white_heavy_check_mark: [green]Finalized: Successfully unstaked all stakes[/green]"
+            if not unstake_all_alpha
+            else ":white_heavy_check_mark: [green]Finalized: Successfully unstaked all Alpha stakes[/green]"
+        )
+        console.print(f"{success_message} from {hotkey_name}")
+        console.print(
+            f"Balance:\n [blue]{current_balance}[/blue] :arrow_right: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_balance}"
+        )
+
+        if unstake_all_alpha:
+            console.print(
+                f"Root Stake for {hotkey_name}:\n [blue]{previous_root_stake}[/blue] :arrow_right: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_root_stake}"
+            )
+
+    except Exception as e:
+        err_out(f"{failure_prelude} with error: {str(e)}")
+
+
 # Helpers
 def _calculate_slippage(subnet_info, amount: Balance) -> tuple[Balance, str, float]:
     """Calculate slippage and received amount for unstaking operation.
@@ -737,17 +820,12 @@ def _calculate_slippage(subnet_info, amount: Balance) -> tuple[Balance, str, flo
 
 
 async def _unstake_selection(
-    subtensor: "SubtensorInterface",
-    wallet: Wallet,
     dynamic_info,
     identities,
     old_identities,
+    stake_infos,
     netuid: Optional[int] = None,
 ):
-    stake_infos = await subtensor.get_stake_for_coldkey(
-        coldkey_ss58=wallet.coldkeypub.ss58_address
-    )
-
     if not stake_infos:
         print_error("You have no stakes to unstake.")
         raise typer.Exit()
@@ -771,16 +849,11 @@ async def _unstake_selection(
 
     hotkeys_info = []
     for idx, (hotkey_ss58, netuid_stakes) in enumerate(hotkey_stakes.items()):
-        if hk_identity := identities["hotkeys"].get(hotkey_ss58):
-            hotkey_name = hk_identity.get("identity", {}).get(
-                "name", ""
-            ) or hk_identity.get("display", "~")
-        elif old_identity := old_identities.get(hotkey_ss58):
-            hotkey_name = old_identity.display
-        else:
-            hotkey_name = "~"
-        # TODO: Add wallet ids here.
-
+        hotkey_name = get_hotkey_identity(
+            hotkey_ss58=hotkey_ss58,
+            identities=identities,
+            old_identities=old_identities,
+        )
         hotkeys_info.append(
             {
                 "index": idx,
@@ -983,6 +1056,9 @@ def _get_hotkeys_to_unstake(
     all_hotkeys: bool,
     include_hotkeys: list[str],
     exclude_hotkeys: list[str],
+    stake_infos: list,
+    identities: dict,
+    old_identities: dict,
 ) -> list[tuple[Optional[str], str]]:
     """Get list of hotkeys to unstake from based on input parameters.
 
@@ -1002,13 +1078,27 @@ def _get_hotkeys_to_unstake(
 
     if all_hotkeys:
         print_verbose("Unstaking from all hotkeys")
-        all_hotkeys_: list[Wallet] = get_hotkey_wallets_for_wallet(wallet=wallet)
-        return [
+        all_hotkeys_ = get_hotkey_wallets_for_wallet(wallet=wallet)
+        wallet_hotkeys = [
             (wallet.hotkey_str, wallet.hotkey.ss58_address)
             for wallet in all_hotkeys_
             if wallet.hotkey_str not in exclude_hotkeys
         ]
 
+        wallet_hotkey_addresses = {addr for _, addr in wallet_hotkeys}
+        chain_hotkeys = [
+            (
+                get_hotkey_identity(stake_info.hotkey_ss58, identities, old_identities),
+                stake_info.hotkey_ss58,
+            )
+            for stake_info in stake_infos
+            if (
+                stake_info.hotkey_ss58 not in wallet_hotkey_addresses
+                and stake_info.hotkey_ss58 not in exclude_hotkeys
+            )
+        ]
+        return wallet_hotkeys + chain_hotkeys
+
     if include_hotkeys:
         print_verbose("Unstaking from included hotkeys")
         result = []
@@ -1144,3 +1234,28 @@ The columns are as follows:
     - [bold white]Partial unstaking[/bold white]: If True, allows unstaking up to the rate tolerance limit. If False, the entire transaction will fail if rate tolerance is exceeded.\n"""
 
     console.print(base_description + (safe_staking_description if safe_staking else ""))
+
+
+def get_hotkey_identity(
+    hotkey_ss58: str,
+    identities: dict,
+    old_identities: dict,
+) -> str:
+    """Get identity name for a hotkey from identities or old_identities.
+
+    Args:
+        hotkey_ss58 (str): The hotkey SS58 address
+        identities (dict): Current identities from fetch_coldkey_hotkey_identities
+        old_identities (dict): Old identities from get_delegate_identities
+
+    Returns:
+        str: Identity name or truncated address
+    """
+    if hk_identity := identities["hotkeys"].get(hotkey_ss58):
+        return hk_identity.get("identity", {}).get("name", "") or hk_identity.get(
+            "display", "~"
+        )
+    elif old_identity := old_identities.get(hotkey_ss58):
+        return old_identity.display
+    else:
+        return f"{hotkey_ss58[:4]}...{hotkey_ss58[-4:]}"

bittensor_cli/src/commands/subnets/subnets.py

@@ -889,8 +889,8 @@ async def show(
             total_emission_per_block = 0
             for netuid_ in range(len(all_subnets)):
                 subnet = all_subnets[netuid_]
-                emission_on_subnet = (
-                    root_state.emission_history[netuid_][idx] / (subnet.tempo or 1)
+                emission_on_subnet = root_state.emission_history[netuid_][idx] / (
+                    subnet.tempo or 1
                 )
                 total_emission_per_block += subnet.alpha_to_tao(
                     Balance.from_rao(emission_on_subnet)
@@ -2135,9 +2135,7 @@ async def get_identity(subtensor: "SubtensorInterface", netuid: int, title: str
         title = "Subnet Identity"
 
     if not await subtensor.subnet_exists(netuid):
-        print_error(
-            f"Subnet {netuid} does not exist."
-        )
+        print_error(f"Subnet {netuid} does not exist.")
         raise typer.Exit()
 
     with console.status(

bittensor_cli/src/commands/sudo.py

@@ -18,6 +18,8 @@ from bittensor_cli.src.bittensor.utils import (
     normalize_hyperparameters,
     unlock_key,
     blocks_to_duration,
+    float_to_u64,
+    float_to_u16,
 )
 
 if TYPE_CHECKING:
@@ -70,12 +72,76 @@ def allowed_value(
     return True, value
 
 
+def search_metadata(
+    param_name: str, value: Union[str, bool, float, list[float]], netuid: int, metadata
+) -> tuple[bool, Optional[dict]]:
+    """
+    Searches the substrate metadata AdminUtils pallet for a given parameter name. Crafts a response dict to be used
+        as call parameters for setting this hyperparameter.
+
+    Args:
+        param_name: the name of the hyperparameter
+        value: the value to set the hyperparameter
+        netuid: the specified netuid
+        metadata: the subtensor.substrate.metadata
+
+    Returns:
+        (success, dict of call params)
+
+    """
+
+    def string_to_bool(val) -> bool:
+        try:
+            return {"true": True, "1": True, "0": False, "false": False}[val.lower()]
+        except KeyError:
+            return ValueError
+
+    def type_converter_with_retry(type_, val, arg_name):
+        try:
+            if val is None:
+                val = input(
+                    f"Enter a value for field '{arg_name}' with type '{arg_type_output[type_]}': "
+                )
+            return arg_types[type_](val)
+        except ValueError:
+            return type_converter_with_retry(type_, None, arg_name)
+
+    arg_types = {"bool": string_to_bool, "u16": float_to_u16, "u64": float_to_u64}
+    arg_type_output = {"bool": "bool", "u16": "float", "u64": "float"}
+
+    call_crafter = {"netuid": netuid}
+
+    for pallet in metadata.pallets:
+        if pallet.name == "AdminUtils":
+            for call in pallet.calls:
+                if call.name == param_name:
+                    if "netuid" not in [x.name for x in call.args]:
+                        return False, None
+                    call_args = [
+                        arg for arg in call.args if arg.value["name"] != "netuid"
+                    ]
+                    if len(call_args) == 1:
+                        arg = call_args[0].value
+                        call_crafter[arg["name"]] = type_converter_with_retry(
+                            arg["typeName"], value, arg["name"]
+                        )
+                    else:
+                        for arg_ in call_args:
+                            arg = arg_.value
+                            call_crafter[arg["name"]] = type_converter_with_retry(
+                                arg["typeName"], None, arg["name"]
+                            )
+                    return True, call_crafter
+    else:
+        return False, None
+
+
 async def set_hyperparameter_extrinsic(
     subtensor: "SubtensorInterface",
     wallet: "Wallet",
     netuid: int,
     parameter: str,
-    value: Union[str, bool, float, list[float]],
+    value: Optional[Union[str, bool, float, list[float]]],
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
 ) -> bool:
@@ -110,44 +176,58 @@ async def set_hyperparameter_extrinsic(
     if not unlock_key(wallet).success:
         return False
 
+    arbitrary_extrinsic = False
+
     extrinsic, sudo_ = HYPERPARAMS.get(parameter, ("", False))
-    if extrinsic is None:
-        err_console.print(":cross_mark: [red]Invalid hyperparameter specified.[/red]")
-        return False
+    if not extrinsic:
+        arbitrary_extrinsic, call_params = search_metadata(
+            parameter, value, netuid, subtensor.substrate.metadata
+        )
+        extrinsic = parameter
+        if not arbitrary_extrinsic:
+            err_console.print(
+                ":cross_mark: [red]Invalid hyperparameter specified.[/red]"
+            )
+            return False
 
+    substrate = subtensor.substrate
+    msg_value = value if not arbitrary_extrinsic else call_params
     with console.status(
-        f":satellite: Setting hyperparameter [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{parameter}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] to [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{value}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] on subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{netuid}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] ...",
+        f":satellite: Setting hyperparameter [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{parameter}"
+        f"[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] to [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{msg_value}"
+        f"[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] on subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]"
+        f"{netuid}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] ...",
         spinner="earth",
     ):
-        substrate = subtensor.substrate
-        extrinsic_params = await substrate.get_metadata_call_function(
-            "AdminUtils", extrinsic
-        )
-        call_params: dict[str, Union[str, bool, float]] = {"netuid": netuid}
-
-        # if input value is a list, iterate through the list and assign values
-        if isinstance(value, list):
-            # Ensure that there are enough values for all non-netuid parameters
-            non_netuid_fields = [
-                param["name"]
-                for param in extrinsic_params["fields"]
-                if "netuid" not in param["name"]
-            ]
-
-            if len(value) < len(non_netuid_fields):
-                raise ValueError(
-                    "Not enough values provided in the list for all parameters"
-                )
-
-            call_params.update(
-                {str(name): val for name, val in zip(non_netuid_fields, value)}
+        if not arbitrary_extrinsic:
+            extrinsic_params = await substrate.get_metadata_call_function(
+                "AdminUtils", extrinsic
             )
+            call_params = {"netuid": netuid}
+
+            # if input value is a list, iterate through the list and assign values
+            if isinstance(value, list):
+                # Ensure that there are enough values for all non-netuid parameters
+                non_netuid_fields = [
+                    param["name"]
+                    for param in extrinsic_params["fields"]
+                    if "netuid" not in param["name"]
+                ]
+
+                if len(value) < len(non_netuid_fields):
+                    raise ValueError(
+                        "Not enough values provided in the list for all parameters"
+                    )
 
-        else:
-            value_argument = extrinsic_params["fields"][
-                len(extrinsic_params["fields"]) - 1
-            ]
-            call_params[str(value_argument["name"])] = value
+                call_params.update(
+                    {str(name): val for name, val in zip(non_netuid_fields, value)}
+                )
+
+            else:
+                value_argument = extrinsic_params["fields"][
+                    len(extrinsic_params["fields"]) - 1
+                ]
+                call_params[str(value_argument["name"])] = value
 
         # create extrinsic call
         call_ = await substrate.compose_call(
@@ -167,11 +247,16 @@ async def set_hyperparameter_extrinsic(
         if not success:
             err_console.print(f":cross_mark: [red]Failed[/red]: {err_msg}")
             await asyncio.sleep(0.5)
-
+        elif arbitrary_extrinsic:
+            console.print(
+                f":white_heavy_check_mark: "
+                f"[dark_sea_green3]Hyperparameter {parameter} values changed to {call_params}[/dark_sea_green3]"
+            )
         # Successful registration, final check for membership
         else:
             console.print(
-                f":white_heavy_check_mark: [dark_sea_green3]Hyperparameter {parameter} changed to {value}[/dark_sea_green3]"
+                f":white_heavy_check_mark: "
+                f"[dark_sea_green3]Hyperparameter {parameter} changed to {value}[/dark_sea_green3]"
             )
             return True
 
@@ -470,7 +555,7 @@ async def sudo_set_hyperparameter(
     subtensor: "SubtensorInterface",
     netuid: int,
     param_name: str,
-    param_value: str,
+    param_value: Optional[str],
 ):
     """Set subnet hyperparameters."""
 
@@ -481,7 +566,12 @@ async def sudo_set_hyperparameter(
         "commit_reveal_weights_enabled",
         "liquid_alpha_enabled",
     ]:
-        normalized_value = param_value.lower() in ["true", "True", "1"]
+        normalized_value = param_value.lower() in ["true", "1"]
+    elif param_value in ("True", "False"):
+        normalized_value = {
+            "True": True,
+            "False": False,
+        }[param_value]
     else:
         normalized_value = param_value
 
@@ -492,7 +582,6 @@ async def sudo_set_hyperparameter(
             f"Value is {normalized_value} but must be {value}"
         )
         return
-
     success = await set_hyperparameter_extrinsic(
         subtensor, wallet, netuid, param_name, value
     )