bittensor-cli 8.4.4__py3-none-any.whl → 9.0.0__py3-none-any.whl

bittensor_cli/cli.py

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
 import asyncio
-import binascii
 import curses
-from functools import partial
+import importlib
 import os.path
 import re
 import ssl
@@ -19,21 +18,28 @@ from bittensor_wallet import Wallet
 from rich import box
 from rich.prompt import Confirm, FloatPrompt, Prompt, IntPrompt
 from rich.table import Column, Table
+from rich.tree import Tree
 from bittensor_cli.src import (
     defaults,
     HELP_PANELS,
     WalletOptions as WO,
     WalletValidationTypes as WV,
     Constants,
+    COLOR_PALETTE,
 )
 from bittensor_cli.src.bittensor import utils
 from bittensor_cli.src.bittensor.balances import Balance
-from bittensor_cli.src.bittensor.async_substrate_interface import (
-    SubstrateRequestException,
-)
-from bittensor_cli.src.commands import root, subnets, sudo, wallets
+from async_substrate_interface.errors import SubstrateRequestException
+from bittensor_cli.src.commands import sudo, wallets
 from bittensor_cli.src.commands import weights as weights_cmds
-from bittensor_cli.src.commands.stake import children_hotkeys, stake
+from bittensor_cli.src.commands.subnets import price, subnets
+from bittensor_cli.src.commands.stake import (
+    children_hotkeys,
+    list as list_stake,
+    move as move_stake,
+    add as add_stake,
+    remove as remove_stake,
+)
 from bittensor_cli.src.bittensor.subtensor_interface import SubtensorInterface
 from bittensor_cli.src.bittensor.chain_data import SubnetHyperparameters
 from bittensor_cli.src.bittensor.utils import (
@@ -43,22 +49,30 @@ from bittensor_cli.src.bittensor.utils import (
     is_valid_ss58_address,
     print_error,
     validate_chain_endpoint,
-    retry_prompt,
+    validate_netuid,
+    is_rao_network,
+    get_effective_network,
+    prompt_for_identity,
+    validate_uri,
+    prompt_for_subnet_identity,
+    print_linux_dependency_message,
+    is_linux,
+    validate_rate_tolerance,
 )
 from typing_extensions import Annotated
-from textwrap import dedent
-from websockets import ConnectionClosed
+from websockets import ConnectionClosed, InvalidHandshake
 from yaml import safe_dump, safe_load
 
 try:
     from git import Repo, GitError
 except ImportError:
+    Repo = None
 
     class GitError(Exception):
         pass
 
 
-__version__ = "8.4.4"
+__version__ = "9.0.0"
 
 
 _core_version = re.match(r"^\d+\.\d+\.\d+", __version__).group(0)
@@ -155,8 +169,19 @@ class Options:
     )
     netuid = typer.Option(
         None,
-        help="The netuid of the subnet in the root network, (e.g. 1).",
+        help="The netuid of the subnet in the network, (e.g. 1).",
         prompt=True,
+        callback=validate_netuid,
+    )
+    netuid_not_req = typer.Option(
+        None,
+        help="The netuid of the subnet in the network, (e.g. 1).",
+        prompt=False,
+    )
+    all_netuids = typer.Option(
+        False,
+        help="Use all netuids",
+        prompt=False,
     )
     weights = typer.Option(
         None,
@@ -202,6 +227,39 @@ class Options:
         "--quiet",
         help="Display only critical information on the console.",
     )
+    live = typer.Option(
+        False,
+        "--live",
+        help="Display live view of the table",
+    )
+    uri = typer.Option(
+        None,
+        "--uri",
+        help="Create wallet from uri (e.g. 'Alice', 'Bob', 'Charlie', 'Dave', 'Eve')",
+        callback=validate_uri,
+    )
+    rate_tolerance = typer.Option(
+        None,
+        "--slippage",
+        "--slippage-tolerance",
+        "--tolerance",
+        help="Set the rate tolerance percentage for transactions (default: 0.05%).",
+        callback=validate_rate_tolerance,
+    )
+    safe_staking = typer.Option(
+        None,
+        "--safe-staking/--no-safe-staking",
+        "--safe/--unsafe",
+        help="Enable or disable safe staking mode (default: enabled).",
+    )
+    allow_partial_stake = typer.Option(
+        None,
+        "--allow-partial-stake/--no-allow-partial-stake",
+        "--partial/--no-partial",
+        "--allow/--not-allow",
+        "--allow-partial/--not-partial",
+        help="Enable or disable partial stake mode (default: disabled).",
+    )
 
 
 def list_prompt(init_var: list, list_type: type, help_text: str) -> list:
@@ -244,7 +302,8 @@ def parse_to_list(
 def verbosity_console_handler(verbosity_level: int = 1) -> None:
     """
     Sets verbosity level of console output
-    :param verbosity_level: int corresponding to verbosity level of console output (0 is quiet, 1 is normal, 2 is verbose)
+    :param verbosity_level: int corresponding to verbosity level of console output (0 is quiet, 1 is normal, 2 is
+        verbose)
     """
     if verbosity_level not in range(3):
         raise ValueError(
@@ -264,6 +323,32 @@ def verbosity_console_handler(verbosity_level: int = 1) -> None:
         verbose_console.quiet = False
 
 
+def get_optional_netuid(netuid: Optional[int], all_netuids: bool) -> Optional[int]:
+    """
+    Parses options to determine if the user wants to use a specific netuid or all netuids (None)
+
+    Returns:
+        None if using all netuids, otherwise int for the netuid to use
+    """
+    if netuid is None and all_netuids is True:
+        return None
+    elif netuid is None and all_netuids is False:
+        answer = Prompt.ask(
+            f"Enter the [{COLOR_PALETTE['GENERAL']['SUBHEADING_MAIN']}]netuid"
+            f"[/{COLOR_PALETTE['GENERAL']['SUBHEADING_MAIN']}] to use. Leave blank for all netuids",
+            default=None,
+            show_default=False,
+        )
+        if answer is None:
+            return None
+        if answer.lower() == "all":
+            return None
+        else:
+            return int(answer)
+    else:
+        return netuid
+
+
 def get_n_words(n_words: Optional[int]) -> int:
     """
     Prompts the user to select the number of words used in the mnemonic if not supplied or not within the
@@ -413,12 +498,21 @@ def version_callback(value: bool):
         raise typer.Exit()
 
 
+def commands_callback(value: bool):
+    """
+    Prints a tree of commands for the app
+    """
+    if value:
+        cli = CLIManager()
+        console.print(cli.generate_command_tree())
+        raise typer.Exit()
+
+
 class CLIManager:
     """
     :var app: the main CLI Typer app
     :var config_app: the Typer app as it relates to config commands
     :var wallet_app: the Typer app as it relates to wallet commands
-    :var root_app: the Typer app as it relates to root commands
     :var stake_app: the Typer app as it relates to stake commands
     :var sudo_app: the Typer app as it relates to sudo commands
     :var subnets_app: the Typer app as it relates to subnets commands
@@ -429,10 +523,10 @@ class CLIManager:
     app: typer.Typer
     config_app: typer.Typer
     wallet_app: typer.Typer
-    root_app: typer.Typer
     subnets_app: typer.Typer
     weights_app: typer.Typer
     utils_app = typer.Typer(epilog=_epilog)
+    asyncio_runner = asyncio
 
     def __init__(self):
         self.config = {
@@ -441,23 +535,29 @@ class CLIManager:
             "wallet_hotkey": None,
             "network": None,
             "use_cache": True,
-            "metagraph_cols": {
-                "UID": True,
-                "STAKE": True,
-                "RANK": True,
-                "TRUST": True,
-                "CONSENSUS": True,
-                "INCENTIVE": True,
-                "DIVIDENDS": True,
-                "EMISSION": True,
-                "VTRUST": True,
-                "VAL": True,
-                "UPDATED": True,
-                "ACTIVE": True,
-                "AXON": True,
-                "HOTKEY": True,
-                "COLDKEY": True,
-            },
+            "rate_tolerance": None,
+            "safe_staking": True,
+            "allow_partial_stake": False,
+            # Commenting this out as this needs to get updated
+            # "metagraph_cols": {
+            #     "UID": True,
+            #     "GLOBAL_STAKE": True,
+            #     "LOCAL_STAKE": True,
+            #     "STAKE_WEIGHT": True,
+            #     "RANK": True,
+            #     "TRUST": True,
+            #     "CONSENSUS": True,
+            #     "INCENTIVE": True,
+            #     "DIVIDENDS": True,
+            #     "EMISSION": True,
+            #     "VTRUST": True,
+            #     "VAL": True,
+            #     "UPDATED": True,
+            #     "ACTIVE": True,
+            #     "AXON": True,
+            #     "HOTKEY": True,
+            #     "COLDKEY": True,
+            # },
         }
         self.subtensor = None
         self.config_base_path = os.path.expanduser(defaults.config.base_path)
@@ -471,7 +571,6 @@ class CLIManager:
         )
         self.config_app = typer.Typer(epilog=_epilog)
         self.wallet_app = typer.Typer(epilog=_epilog)
-        self.root_app = typer.Typer(epilog=_epilog)
         self.stake_app = typer.Typer(epilog=_epilog)
         self.sudo_app = typer.Typer(epilog=_epilog)
         self.subnets_app = typer.Typer(epilog=_epilog)
@@ -501,15 +600,6 @@ class CLIManager:
             self.wallet_app, name="wallets", hidden=True, no_args_is_help=True
         )
 
-        # root aliases
-        self.app.add_typer(
-            self.root_app,
-            name="root",
-            short_help="Root commands, alias: `r`",
-            no_args_is_help=True,
-        )
-        self.app.add_typer(self.root_app, name="r", hidden=True, no_args_is_help=True)
-
         # stake aliases
         self.app.add_typer(
             self.stake_app,
@@ -558,13 +648,15 @@ class CLIManager:
         )
 
         # utils app
-        self.app.add_typer(self.utils_app, name="utils", no_args_is_help=True)
+        self.app.add_typer(
+            self.utils_app, name="utils", no_args_is_help=True, hidden=True
+        )
 
         # config commands
         self.config_app.command("set")(self.set_config)
         self.config_app.command("get")(self.get_config)
         self.config_app.command("clear")(self.del_config)
-        self.config_app.command("metagraph")(self.metagraph_config)
+        self.config_app.command("metagraph", hidden=True)(self.metagraph_config)
 
         # wallet commands
         self.wallet_app.command(
@@ -595,16 +687,21 @@ class CLIManager:
             "balance", rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"]
         )(self.wallet_balance)
         self.wallet_app.command(
-            "history", rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"]
+            "history",
+            rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"],
+            hidden=True,
         )(self.wallet_history)
         self.wallet_app.command(
-            "overview", rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"]
+            "overview",
+            rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"],
         )(self.wallet_overview)
         self.wallet_app.command(
             "transfer", rich_help_panel=HELP_PANELS["WALLET"]["OPERATIONS"]
         )(self.wallet_transfer)
         self.wallet_app.command(
-            "inspect", rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"]
+            "inspect",
+            rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"],
+            hidden=True,
         )(self.wallet_inspect)
         self.wallet_app.command(
             "faucet", rich_help_panel=HELP_PANELS["WALLET"]["OPERATIONS"]
@@ -619,59 +716,25 @@ class CLIManager:
             "sign", rich_help_panel=HELP_PANELS["WALLET"]["OPERATIONS"]
         )(self.wallet_sign)
 
-        # root commands
-        self.root_app.command("list")(self.root_list)
-        self.root_app.command(
-            "set-weights", rich_help_panel=HELP_PANELS["ROOT"]["WEIGHT_MGMT"]
-        )(self.root_set_weights)
-        self.root_app.command(
-            "get-weights", rich_help_panel=HELP_PANELS["ROOT"]["WEIGHT_MGMT"]
-        )(self.root_get_weights)
-        self.root_app.command(
-            "boost", rich_help_panel=HELP_PANELS["ROOT"]["WEIGHT_MGMT"]
-        )(self.root_boost)
-        self.root_app.command(
-            "slash", rich_help_panel=HELP_PANELS["ROOT"]["WEIGHT_MGMT"]
-        )(self.root_slash)
-        self.root_app.command(
-            "senate", rich_help_panel=HELP_PANELS["ROOT"]["GOVERNANCE"]
-        )(self.root_senate)
-        self.root_app.command(
-            "senate-vote", rich_help_panel=HELP_PANELS["ROOT"]["GOVERNANCE"]
-        )(self.root_senate_vote)
-        self.root_app.command("register")(self.root_register)
-        self.root_app.command(
-            "proposals", rich_help_panel=HELP_PANELS["ROOT"]["GOVERNANCE"]
-        )(self.root_proposals)
-        self.root_app.command(
-            "set-take", rich_help_panel=HELP_PANELS["ROOT"]["DELEGATION"]
-        )(self.root_set_take)
-        self.root_app.command(
-            "delegate-stake", rich_help_panel=HELP_PANELS["ROOT"]["DELEGATION"]
-        )(self.root_delegate_stake)
-        self.root_app.command(
-            "undelegate-stake", rich_help_panel=HELP_PANELS["ROOT"]["DELEGATION"]
-        )(self.root_undelegate_stake)
-        self.root_app.command(
-            "my-delegates", rich_help_panel=HELP_PANELS["ROOT"]["DELEGATION"]
-        )(self.root_my_delegates)
-        self.root_app.command(
-            "list-delegates", rich_help_panel=HELP_PANELS["ROOT"]["DELEGATION"]
-        )(self.root_list_delegates)
-        self.root_app.command(
-            "nominate", rich_help_panel=HELP_PANELS["ROOT"]["GOVERNANCE"]
-        )(self.root_nominate)
-
         # stake commands
-        self.stake_app.command(
-            "show", rich_help_panel=HELP_PANELS["STAKE"]["STAKE_MGMT"]
-        )(self.stake_show)
         self.stake_app.command(
             "add", rich_help_panel=HELP_PANELS["STAKE"]["STAKE_MGMT"]
         )(self.stake_add)
         self.stake_app.command(
             "remove", rich_help_panel=HELP_PANELS["STAKE"]["STAKE_MGMT"]
         )(self.stake_remove)
+        self.stake_app.command(
+            "list", rich_help_panel=HELP_PANELS["STAKE"]["STAKE_MGMT"]
+        )(self.stake_list)
+        self.stake_app.command(
+            "move", rich_help_panel=HELP_PANELS["STAKE"]["MOVEMENT"]
+        )(self.stake_move)
+        self.stake_app.command(
+            "transfer", rich_help_panel=HELP_PANELS["STAKE"]["MOVEMENT"]
+        )(self.stake_transfer)
+        self.stake_app.command(
+            "swap", rich_help_panel=HELP_PANELS["STAKE"]["MOVEMENT"]
+        )(self.stake_swap)
 
         # stake-children commands
         children_app = typer.Typer()
@@ -697,6 +760,21 @@ class CLIManager:
         self.sudo_app.command("get", rich_help_panel=HELP_PANELS["SUDO"]["CONFIG"])(
             self.sudo_get
         )
+        self.sudo_app.command(
+            "senate", rich_help_panel=HELP_PANELS["SUDO"]["GOVERNANCE"]
+        )(self.sudo_senate)
+        self.sudo_app.command(
+            "proposals", rich_help_panel=HELP_PANELS["SUDO"]["GOVERNANCE"]
+        )(self.sudo_proposals)
+        self.sudo_app.command(
+            "senate-vote", rich_help_panel=HELP_PANELS["SUDO"]["GOVERNANCE"]
+        )(self.sudo_senate_vote)
+        self.sudo_app.command("set-take", rich_help_panel=HELP_PANELS["SUDO"]["TAKE"])(
+            self.sudo_set_take
+        )
+        self.sudo_app.command("get-take", rich_help_panel=HELP_PANELS["SUDO"]["TAKE"])(
+            self.sudo_get_take
+        )
 
         # subnets commands
         self.subnets_app.command(
@@ -706,8 +784,8 @@ class CLIManager:
             "list", rich_help_panel=HELP_PANELS["SUBNETS"]["INFO"]
         )(self.subnets_list)
         self.subnets_app.command(
-            "lock-cost", rich_help_panel=HELP_PANELS["SUBNETS"]["CREATION"]
-        )(self.subnets_lock_cost)
+            "burn-cost", rich_help_panel=HELP_PANELS["SUBNETS"]["CREATION"]
+        )(self.subnets_burn_cost)
         self.subnets_app.command(
             "create", rich_help_panel=HELP_PANELS["SUBNETS"]["CREATION"]
         )(self.subnets_create)
@@ -718,8 +796,14 @@ class CLIManager:
             "register", rich_help_panel=HELP_PANELS["SUBNETS"]["REGISTER"]
         )(self.subnets_register)
         self.subnets_app.command(
-            "metagraph", rich_help_panel=HELP_PANELS["SUBNETS"]["INFO"]
-        )(self.subnets_metagraph)
+            "metagraph", rich_help_panel=HELP_PANELS["SUBNETS"]["INFO"], hidden=True
+        )(self.subnets_show)  # Aliased to `s show` for now
+        self.subnets_app.command(
+            "show", rich_help_panel=HELP_PANELS["SUBNETS"]["INFO"]
+        )(self.subnets_show)
+        self.subnets_app.command(
+            "price", rich_help_panel=HELP_PANELS["SUBNETS"]["INFO"]
+        )(self.subnets_price)
 
         # weights commands
         self.weights_app.command(
@@ -764,22 +848,49 @@ class CLIManager:
             hidden=True,
         )(self.wallet_get_id)
 
-        # Root
-        self.root_app.command("set_weights", hidden=True)(self.root_set_weights)
-        self.root_app.command("get_weights", hidden=True)(self.root_get_weights)
-        self.root_app.command("senate_vote", hidden=True)(self.root_senate_vote)
-        self.root_app.command("set_take", hidden=True)(self.root_set_take)
-        self.root_app.command("delegate_stake", hidden=True)(self.root_delegate_stake)
-        self.root_app.command("undelegate_stake", hidden=True)(
-            self.root_undelegate_stake
-        )
-        self.root_app.command("my_delegates", hidden=True)(self.root_my_delegates)
-        self.root_app.command("list_delegates", hidden=True)(self.root_list_delegates)
-
         # Subnets
-        self.subnets_app.command("lock_cost", hidden=True)(self.subnets_lock_cost)
+        self.subnets_app.command("burn_cost", hidden=True)(self.subnets_burn_cost)
         self.subnets_app.command("pow_register", hidden=True)(self.subnets_pow_register)
 
+        # Sudo
+        self.sudo_app.command("senate_vote", hidden=True)(self.sudo_senate_vote)
+        self.sudo_app.command("get_take", hidden=True)(self.sudo_get_take)
+        self.sudo_app.command("set_take", hidden=True)(self.sudo_set_take)
+
+    def generate_command_tree(self) -> Tree:
+        """
+        Generates a rich.Tree of the commands, subcommands, and groups of this app
+        """
+
+        def build_rich_tree(data: dict, parent: Tree):
+            for group, content in data.get("groups", {}).items():
+                group_node = parent.add(
+                    f"[bold cyan]{group}[/]"
+                )  # Add group to the tree
+                for command in content.get("commands", []):
+                    group_node.add(f"[green]{command}[/]")  # Add commands to the group
+                build_rich_tree(content, group_node)  # Recurse for subgroups
+
+        def traverse_group(group: typer.Typer) -> dict:
+            tree = {}
+            if commands := [
+                cmd.name for cmd in group.registered_commands if not cmd.hidden
+            ]:
+                tree["commands"] = commands
+            for group in group.registered_groups:
+                if "groups" not in tree:
+                    tree["groups"] = {}
+                if not group.hidden:
+                    if group_transversal := traverse_group(group.typer_instance):
+                        tree["groups"][group.name] = group_transversal
+
+            return tree
+
+        groups_and_commands = traverse_group(self.app)
+        root = Tree("[bold magenta]BTCLI Commands[/]")  # Root node
+        build_rich_tree(groups_and_commands, root)
+        return root
+
     def initialize_chain(
         self,
         network: Optional[list[str]] = None,
@@ -810,13 +921,13 @@ class CLIManager:
             elif self.config["network"]:
                 self.subtensor = SubtensorInterface(self.config["network"])
                 console.print(
-                    f"Using the specified network [dark_orange]{self.config['network']}[/dark_orange] from config"
+                    f"Using the specified network [{COLOR_PALETTE['GENERAL']['LINKS']}]{self.config['network']}[/{COLOR_PALETTE['GENERAL']['LINKS']}] from config"
                 )
             else:
                 self.subtensor = SubtensorInterface(defaults.subtensor.network)
         return self.subtensor
 
-    def _run_command(self, cmd: Coroutine):
+    def _run_command(self, cmd: Coroutine, exit_early: bool = True):
         """
         Runs the supplied coroutine with `asyncio.run`
         """
@@ -832,16 +943,19 @@ class CLIManager:
                     initiated = True
                     result = await cmd
                 return result
-            except (ConnectionRefusedError, ssl.SSLError):
+            except (ConnectionRefusedError, ssl.SSLError, InvalidHandshake):
                 err_console.print(f"Unable to connect to the chain: {self.subtensor}")
                 verbose_console.print(traceback.format_exc())
             except (
                 ConnectionClosed,
                 SubstrateRequestException,
                 KeyboardInterrupt,
+                RuntimeError,
             ) as e:
                 if isinstance(e, SubstrateRequestException):
                     err_console.print(str(e))
+                elif isinstance(e, RuntimeError):
+                    pass  # Temporarily to handle loop bound issues
                 verbose_console.print(traceback.format_exc())
             except Exception as e:
                 err_console.print(f"An unknown error has occurred: {e}")
@@ -849,23 +963,35 @@ class CLIManager:
             finally:
                 if initiated is False:
                     asyncio.create_task(cmd).cancel()
-                    raise typer.Exit()
+                if (
+                    exit_early is True
+                ):  # temporarily to handle multiple run commands in one session
+                    try:
+                        raise typer.Exit()
+                    except Exception as e:  # ensures we always exit cleanly
+                        if not isinstance(e, (typer.Exit, RuntimeError)):
+                            err_console.print(f"An unknown error has occurred: {e}")
 
-        if sys.version_info < (3, 10):
-            # For Python 3.9 or lower
-            return asyncio.get_event_loop().run_until_complete(_run())
-        else:
-            # For Python 3.10 or higher
-            return asyncio.run(_run())
+        return self.asyncio_runner(_run())
 
     def main_callback(
         self,
         version: Annotated[
-            Optional[bool], typer.Option("--version", callback=version_callback)
+            Optional[bool],
+            typer.Option(
+                "--version", callback=version_callback, help="Show BTCLI version"
+            ),
+        ] = None,
+        commands: Annotated[
+            Optional[bool],
+            typer.Option(
+                "--commands", callback=commands_callback, help="Show BTCLI commands"
+            ),
         ] = None,
     ):
         """
-        Command line interface (CLI) for Bittensor. Uses the values in the configuration file. These values can be overriden by passing them explicitly in the command line.
+        Command line interface (CLI) for Bittensor. Uses the values in the configuration file. These values can be
+            overriden by passing them explicitly in the command line.
         """
         # Load or create the config file
         if os.path.exists(self.config_path):
@@ -897,6 +1023,20 @@ class CLIManager:
             if k in self.config.keys():
                 self.config[k] = v
 
+        if sys.version_info < (3, 10):
+            # For Python 3.9 or lower
+            self.asyncio_runner = asyncio.get_event_loop().run_until_complete
+        else:
+            try:
+                uvloop = importlib.import_module("uvloop")
+                if sys.version_info >= (3, 11):
+                    self.asyncio_runner = uvloop.run
+                else:
+                    uvloop.install()
+                    self.asyncio_runner = asyncio.run
+            except ModuleNotFoundError:
+                self.asyncio_runner = asyncio.run
+
     def verbosity_handler(self, quiet: bool, verbose: bool):
         if quiet and verbose:
             err_console.print("Cannot specify both `--quiet` and `--verbose`")
@@ -953,9 +1093,44 @@ class CLIManager:
             help="Disable caching of some commands. This will disable the `--reuse-last` and `--html` flags on "
             "commands such as `subnets metagraph`, `stake show` and `subnets list`.",
         ),
+        rate_tolerance: Optional[float] = typer.Option(
+            None,
+            "--slippage",
+            "--slippage-tolerance",
+            "--tolerance",
+            help="Set the rate tolerance percentage for transactions (e.g. 0.1 for 0.1%).",
+        ),
+        safe_staking: Optional[bool] = typer.Option(
+            None,
+            "--safe-staking/--no-safe-staking",
+            "--safe/--unsafe",
+            help="Enable or disable safe staking mode.",
+        ),
+        allow_partial_stake: Optional[bool] = typer.Option(
+            None,
+            "--allow-partial-stake/--no-allow-partial-stake",
+            "--partial/--no-partial",
+            "--allow/--not-allow",
+        ),
     ):
         """
-        Sets the values in the config file. To set the metagraph configuration, use the command `btcli config metagraph`
+        Sets or updates configuration values in the BTCLI config file.
+
+        This command allows you to set default values that will be used across all BTCLI commands.
+
+        USAGE
+        Interactive mode:
+            [green]$[/green] btcli config set
+
+        Set specific values:
+            [green]$[/green] btcli config set --wallet-name default --network finney
+            [green]$[/green] btcli config set --safe-staking --rate-tolerance 0.1
+
+        [bold]NOTE[/bold]:
+        - Network values can be network names (e.g., 'finney', 'test') or websocket URLs
+        - Rate tolerance is specified as a decimal (e.g., 0.05 for 0.05%)
+        - Changes are saved to ~/.bittensor/btcli.yaml
+        - Use '[green]$[/green] btcli config get' to view current settings
         """
         args = {
             "wallet_name": wallet_name,
@@ -963,8 +1138,11 @@ class CLIManager:
             "wallet_hotkey": wallet_hotkey,
             "network": network,
             "use_cache": use_cache,
+            "rate_tolerance": rate_tolerance,
+            "safe_staking": safe_staking,
+            "allow_partial_stake": allow_partial_stake,
         }
-        bools = ["use_cache"]
+        bools = ["use_cache", "safe_staking", "allow_partial_stake"]
         if all(v is None for v in args.values()):
             # Print existing configs
             self.get_config()
@@ -988,6 +1166,20 @@ class CLIManager:
                     default=True,
                 )
                 self.config[arg] = nc
+
+            elif arg == "rate_tolerance":
+                while True:
+                    val = FloatPrompt.ask(
+                        f"What percentage would you like to set for [red]{arg}[/red]?\nValues are percentages (e.g. 0.05 for 5%)",
+                        default=0.05,
+                    )
+                    try:
+                        validated_val = validate_rate_tolerance(val)
+                        self.config[arg] = validated_val
+                        break
+                    except typer.BadParameter as e:
+                        print_error(str(e))
+                        continue
             else:
                 val = Prompt.ask(
                     f"What value would you like to assign to [red]{arg}[/red]?"
@@ -1045,6 +1237,18 @@ class CLIManager:
         wallet_hotkey: bool = typer.Option(False, *Options.wallet_hotkey.param_decls),
         network: bool = typer.Option(False, *Options.network.param_decls),
         use_cache: bool = typer.Option(False, "--cache"),
+        rate_tolerance: bool = typer.Option(
+            False, "--slippage", "--slippage-tolerance", "--tolerance"
+        ),
+        safe_staking: bool = typer.Option(
+            False, "--safe-staking/--no-safe-staking", "--safe/--unsafe"
+        ),
+        allow_partial_stake: bool = typer.Option(
+            False,
+            "--allow-partial-stake/--no-allow-partial-stake",
+            "--partial/--no-partial",
+            "--allow/--not-allow",
+        ),
         all_items: bool = typer.Option(False, "--all"),
     ):
         """
@@ -1074,6 +1278,9 @@ class CLIManager:
             "wallet_hotkey": wallet_hotkey,
             "network": network,
             "use_cache": use_cache,
+            "rate_tolerance": rate_tolerance,
+            "safe_staking": safe_staking,
+            "allow_partial_stake": allow_partial_stake,
         }
 
         # If no specific argument is provided, iterate over all
@@ -1135,6 +1342,8 @@ class CLIManager:
                 else:
                     if value in Constants.networks:
                         value = value + f" ({Constants.network_map[value]})"
+            if key == "rate_tolerance":
+                value = f"{value} ({value*100}%)" if value is not None else "None"
 
             elif key in deprecated_configs:
                 continue
@@ -1147,13 +1356,112 @@ class CLIManager:
                 table.add_row(str(key), str(value), "")
 
         console.print(table)
-        console.print(
-            dedent(
-                """
-            [red]Deprecation notice[/red]: The chain endpoint config is now deprecated. You can use the network config to pass chain endpoints.
-            """
+
+    def ask_rate_tolerance(
+        self,
+        rate_tolerance: Optional[float],
+    ) -> float:
+        """
+        Gets rate tolerance from args, config, or default.
+
+        Args:
+            rate_tolerance (Optional[float]): Explicitly provided slippage value
+
+        Returns:
+            float: rate tolerance value
+        """
+        if rate_tolerance is not None:
+            console.print(
+                f"[dim][blue]Rate tolerance[/blue]: [bold cyan]{rate_tolerance} ({rate_tolerance*100}%)[/bold cyan]."
             )
-        )
+            return rate_tolerance
+        elif self.config.get("rate_tolerance") is not None:
+            config_slippage = self.config["rate_tolerance"]
+            console.print(
+                f"[dim][blue]Rate tolerance[/blue]: [bold cyan]{config_slippage} ({config_slippage*100}%)[/bold cyan] (from config)."
+            )
+            return config_slippage
+        else:
+            console.print(
+                "[dim][blue]Rate tolerance[/blue]: "
+                + f"[bold cyan]{defaults.rate_tolerance} ({defaults.rate_tolerance*100}%)[/bold cyan] "
+                + "by default. Set this using "
+                + "[dark_sea_green3 italic]`btcli config set`[/dark_sea_green3 italic] "
+                + "or "
+                + "[dark_sea_green3 italic]`--tolerance`[/dark_sea_green3 italic] flag[/dim]"
+            )
+            return defaults.rate_tolerance
+
+    def ask_safe_staking(
+        self,
+        safe_staking: Optional[bool],
+    ) -> bool:
+        """
+        Gets safe staking setting from args, config, or default.
+
+        Args:
+            safe_staking (Optional[bool]): Explicitly provided safe staking value
+
+        Returns:
+            bool: Safe staking setting
+        """
+        if safe_staking is not None:
+            console.print(
+                f"[dim][blue]Safe staking[/blue]: [bold cyan]{'enabled' if safe_staking else 'disabled'}[/bold cyan]."
+            )
+            return safe_staking
+        elif self.config.get("safe_staking") is not None:
+            safe_staking = self.config["safe_staking"]
+            console.print(
+                f"[dim][blue]Safe staking[/blue]: [bold cyan]{'enabled' if safe_staking else 'disabled'}[/bold cyan] (from config)."
+            )
+            return safe_staking
+        else:
+            safe_staking = True
+            console.print(
+                "[dim][blue]Safe staking[/blue]: "
+                + f"[bold cyan]{'enabled' if safe_staking else 'disabled'}[/bold cyan] "
+                + "by default. Set this using "
+                + "[dark_sea_green3 italic]`btcli config set`[/dark_sea_green3 italic] "
+                + "or "
+                + "[dark_sea_green3 italic]`--safe/--unsafe`[/dark_sea_green3 italic] flag[/dim]"
+            )
+            return safe_staking
+
+    def ask_partial_stake(
+        self,
+        allow_partial_stake: Optional[bool],
+    ) -> bool:
+        """
+        Gets partial stake setting from args, config, or default.
+
+        Args:
+            allow_partial_stake (Optional[bool]): Explicitly provided partial stake value
+
+        Returns:
+            bool: Partial stake setting
+        """
+        if allow_partial_stake is not None:
+            console.print(
+                f"[dim][blue]Partial staking[/blue]: [bold cyan]{'enabled' if allow_partial_stake else 'disabled'}[/bold cyan]."
+            )
+            return allow_partial_stake
+        elif self.config.get("allow_partial_stake") is not None:
+            config_partial = self.config["allow_partial_stake"]
+            console.print(
+                f"[dim][blue]Partial staking[/blue]: [bold cyan]{'enabled' if config_partial else 'disabled'}[/bold cyan] (from config)."
+            )
+            return config_partial
+        else:
+            console.print(
+                "[dim][blue]Partial staking[/blue]: "
+                + f"[bold cyan]{'enabled' if allow_partial_stake else 'disabled'}[/bold cyan] "
+                + "by default. Set this using "
+                + "[dark_sea_green3 italic]`btcli config set`[/dark_sea_green3 italic] "
+                + "or "
+                + "[dark_sea_green3 italic]`--partial/--no-partial`[/dark_sea_green3 italic] flag[/dim]"
+            )
+            return False
 
     def wallet_ask(
         self,
@@ -1173,39 +1481,16 @@ class CLIManager:
         :return: created Wallet object
         """
         # Prompt for missing attributes specified in ask_for
-
-        if wallet_path:
-            if wallet_path == "default":
-                wallet_path = defaults.wallet.path
-
-        elif self.config.get("wallet_path"):
-            wallet_path = self.config.get("wallet_path")
-            console.print(
-                f"Using the wallet path from config:[bold magenta] {wallet_path}"
-            )
-
-        if WO.PATH in ask_for and not wallet_path:
-            wallet_path = Prompt.ask(
-                "Enter the [blue]wallet path[/blue]"
-                + " [dark_sea_green3 italic](Hint: You can set this with `btcli config set --wallet-path`)[/dark_sea_green3 italic]",
-                default=defaults.wallet.path,
-            )
-        if wallet_path:
-            wallet_path = os.path.expanduser(wallet_path)
-        else:
-            wallet_path = os.path.expanduser(defaults.wallet.path)
-            console.print(f"Using default wallet path: ({defaults.wallet.path})")
-
         if WO.NAME in ask_for and not wallet_name:
             if self.config.get("wallet_name"):
                 wallet_name = self.config.get("wallet_name")
                 console.print(
-                    f"Using the wallet name from config:[bold cyan] {wallet_name}"
+                    f"Using the [blue]wallet name[/blue] from config:[bold cyan] {wallet_name}"
                 )
             else:
                 wallet_name = Prompt.ask(
                     "Enter the [blue]wallet name[/blue]"
-                    + " [dark_sea_green3 italic](Hint: You can set this with `btcli config set --wallet-name`)[/dark_sea_green3 italic]",
+                    + f" [{COLOR_PALETTE['GENERAL']['HINT']} italic](Hint: You can set this with `btcli config set --wallet-name`)",
                     default=defaults.wallet.name,
                 )
 
@@ -1213,7 +1498,7 @@ class CLIManager:
             if self.config.get("wallet_hotkey"):
                 wallet_hotkey = self.config.get("wallet_hotkey")
                 console.print(
-                    f"Using the wallet hotkey from config:[bold cyan] {wallet_hotkey}"
+                    f"Using the [blue]wallet hotkey[/blue] from config:[bold cyan] {wallet_hotkey}"
                 )
             else:
                 wallet_hotkey = Prompt.ask(
@@ -1221,8 +1506,27 @@ class CLIManager:
                     + " [dark_sea_green3 italic](Hint: You can set this with `btcli config set --wallet-hotkey`)[/dark_sea_green3 italic]",
                     default=defaults.wallet.hotkey,
                 )
+        if wallet_path:
+            if wallet_path == "default":
+                wallet_path = defaults.wallet.path
+
+        elif self.config.get("wallet_path"):
+            wallet_path = self.config.get("wallet_path")
+            console.print(
+                f"Using the [blue]wallet path[/blue] from config:[bold magenta] {wallet_path}"
+            )
+        else:
+            wallet_path = defaults.wallet.path
 
+        if WO.PATH in ask_for and not wallet_path:
+            wallet_path = Prompt.ask(
+                "Enter the [blue]wallet path[/blue]"
+                + " [dark_sea_green3 italic](Hint: You can set this with `btcli config set --wallet-path`)[/dark_sea_green3 italic]",
+                default=defaults.wallet.path,
+            )
         # Create the Wallet object
+        if wallet_path:
+            wallet_path = os.path.expanduser(wallet_path)
         wallet = Wallet(name=wallet_name, path=wallet_path, hotkey=wallet_hotkey)
 
         # Validate the wallet if required
@@ -1252,7 +1556,7 @@ class CLIManager:
         """
         Displays all the wallets and their corresponding hotkeys that are located in the wallet path specified in the config.
 
-        The output display shows each wallet and its associated `ss58` addresses for the coldkey public key and any hotkeys. The output is presented in a hierarchical tree format, with each wallet as a root node and any associated hotkeys as child nodes. The `ss58` address is displayed for each coldkey and hotkey that is not encrypted and exists on the device.
+        The output display shows each wallet and its associated `ss58` addresses for the coldkey public key and any hotkeys. The output is presented in a hierarchical tree format, with each wallet as a root node and any associated hotkeys as child nodes. The `ss58` address (or an `<ENCRYPTED>` marker, for encrypted hotkeys) is displayed for each coldkey and hotkey that exists on the device.
 
         Upon invocation, the command scans the wallet directory and prints a list of all the wallets, indicating whether the
         public keys are available (`?` denotes unavailable or encrypted keys).
@@ -1315,50 +1619,9 @@ class CLIManager:
 
         USAGE
 
-        The command offers various options to customize the output. Users can filter the displayed data by specific
-        netuid, sort by different criteria, and choose to include all the wallets in the user's wallet path location.
-        The output is presented in a tabular format with the following columns:
-
-        - COLDKEY: The SS58 address of the coldkey.
-
-        - HOTKEY: The SS58 address of the hotkey.
-
-        - UID: Unique identifier of the neuron.
-
-        - ACTIVE: Indicates if the neuron is active.
-
-        - STAKE(τ): Amount of stake in the neuron, in TAO.
-
-        - RANK: The rank of the neuron within the network.
-
-        - TRUST: Trust score of the neuron.
-
-        - CONSENSUS: Consensus score of the neuron.
-
-        - INCENTIVE: Incentive score of the neuron.
-
-        - DIVIDENDS: Dividends earned by the neuron.
-
-        - EMISSION(p): Emission received by the neuron, expressed in rho.
-
-        - VTRUST: Validator trust score of the neuron.
-
-        - VPERMIT: Indicates if the neuron has a validator permit.
-
-        - UPDATED: Time since last update.
-
-        - AXON: IP address and port of the neuron.
-
-        - HOTKEY_SS58: Human-readable representation of the hotkey.
-
-
-        # EXAMPLE:
-
         [green]$[/green] btcli wallet overview
 
-        [green]$[/green] btcli wallet overview --all --sort-by stake --sort-order descending
-
-        [green]$[/green] btcli wallet overview -in hk1,hk2 --sort-by stake
+        [green]$[/green] btcli wallet overview --all
 
         [bold]NOTE[/bold]: This command is read-only and does not modify the blockchain state or account configuration.
         It provides a quick and comprehensive view of the user's network presence, making it useful for monitoring account status,
@@ -1408,6 +1671,7 @@ class CLIManager:
                 include_hotkeys,
                 exclude_hotkeys,
                 netuids_filter=netuids,
+                verbose=verbose,
             )
         )
 
@@ -1425,7 +1689,6 @@ class CLIManager:
             None,
             "--amount",
             "-a",
-            prompt=False,
             help="Amount (in TAO) to transfer.",
         ),
         transfer_all: bool = typer.Option(
@@ -1523,7 +1786,7 @@ class CLIManager:
             wallet_name,
             wallet_path,
             wallet_hotkey,
-            ask_for=[WO.NAME, WO.HOTKEY],
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
             validate=WV.WALLET_AND_HOTKEY,
         )
         if not destination_hotkey_name:
@@ -1535,7 +1798,7 @@ class CLIManager:
             wallet_name,
             wallet_path,
             destination_hotkey_name,
-            ask_for=[WO.NAME, WO.HOTKEY],
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
             validate=WV.WALLET_AND_HOTKEY,
         )
         self.initialize_chain(network)
@@ -1591,6 +1854,8 @@ class CLIManager:
 
         [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)
 
         if netuids:
@@ -1601,11 +1866,12 @@ class CLIManager:
             )
 
         # if all-wallets is entered, ask for path
-        ask_for = [WO.NAME] if not all_wallets else []
+        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
         )
+
         self.initialize_chain(network)
         return self._run_command(
             wallets.inspect(
@@ -1691,7 +1957,7 @@ class CLIManager:
             wallet_name,
             wallet_path,
             wallet_hotkey,
-            ask_for=[WO.NAME],
+            ask_for=[WO.NAME, WO.PATH],
             validate=WV.WALLET,
         )
         return self._run_command(
@@ -1750,7 +2016,8 @@ class CLIManager:
 
         if not wallet_name:
             wallet_name = Prompt.ask(
-                "Enter the name of the new wallet", default=defaults.wallet.name
+                f"Enter the name of the [{COLOR_PALETTE['GENERAL']['COLDKEY']}]new wallet (coldkey)",
+                default=defaults.wallet.name,
             )
 
         wallet = Wallet(wallet_name, wallet_hotkey, wallet_path)
@@ -1806,7 +2073,8 @@ class CLIManager:
 
         if not wallet_name:
             wallet_name = Prompt.ask(
-                "Enter the name of the new wallet", default=defaults.wallet.name
+                f"Enter the name of the [{COLOR_PALETTE['GENERAL']['COLDKEY']}]new wallet (coldkey)",
+                default=defaults.wallet.name,
             )
         wallet = Wallet(wallet_name, wallet_hotkey, wallet_path)
 
@@ -1898,6 +2166,7 @@ class CLIManager:
             False,  # Overriden to False
             help="Set to 'True' to protect the generated Bittensor key with a password.",
         ),
+        uri: Optional[str] = Options.uri,
         overwrite: bool = Options.overwrite,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
@@ -1920,12 +2189,14 @@ class CLIManager:
 
         if not wallet_name:
             wallet_name = Prompt.ask(
-                "Enter the wallet name", default=defaults.wallet.name
+                f"Enter the [{COLOR_PALETTE['GENERAL']['COLDKEY']}]wallet name",
+                default=defaults.wallet.name,
             )
 
         if not wallet_hotkey:
             wallet_hotkey = Prompt.ask(
-                "Enter the name of the new hotkey", default=defaults.wallet.hotkey
+                f"Enter the name of the [{COLOR_PALETTE['GENERAL']['HOTKEY']}]new hotkey",
+                default=defaults.wallet.hotkey,
             )
 
         wallet = self.wallet_ask(
@@ -1935,9 +2206,10 @@ class CLIManager:
             ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
             validate=WV.WALLET,
         )
-        n_words = get_n_words(n_words)
+        if not uri:
+            n_words = get_n_words(n_words)
         return self._run_command(
-            wallets.new_hotkey(wallet, n_words, use_password, overwrite)
+            wallets.new_hotkey(wallet, n_words, use_password, uri, overwrite)
         )
 
     def wallet_new_coldkey(
@@ -1952,6 +2224,7 @@ class CLIManager:
             help="The number of words used in the mnemonic. Options: [12, 15, 18, 21, 24]",
         ),
         use_password: Optional[bool] = Options.use_password,
+        uri: Optional[str] = Options.uri,
         overwrite: bool = Options.overwrite,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
@@ -1978,7 +2251,8 @@ class CLIManager:
 
         if not wallet_name:
             wallet_name = Prompt.ask(
-                "Enter the name of the new wallet", default=defaults.wallet.name
+                f"Enter the name of the [{COLOR_PALETTE['GENERAL']['COLDKEY']}]new wallet (coldkey)",
+                default=defaults.wallet.name,
             )
 
         wallet = self.wallet_ask(
@@ -1988,9 +2262,10 @@ class CLIManager:
             ask_for=[WO.NAME, WO.PATH],
             validate=WV.NONE,
         )
-        n_words = get_n_words(n_words)
+        if not uri:
+            n_words = get_n_words(n_words)
         return self._run_command(
-            wallets.new_coldkey(wallet, n_words, use_password, overwrite)
+            wallets.new_coldkey(wallet, n_words, use_password, uri, overwrite)
         )
 
     def wallet_check_ck_swap(
@@ -2025,6 +2300,7 @@ class CLIManager:
         wallet_hotkey: Optional[str] = Options.wallet_hotkey,
         n_words: Optional[int] = None,
         use_password: bool = Options.use_password,
+        uri: Optional[str] = Options.uri,
         overwrite: bool = Options.overwrite,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
@@ -2049,12 +2325,13 @@ class CLIManager:
 
         if not wallet_name:
             wallet_name = Prompt.ask(
-                "Enter the name of the new wallet (coldkey)",
+                f"Enter the name of the [{COLOR_PALETTE['GENERAL']['COLDKEY']}]new wallet (coldkey)",
                 default=defaults.wallet.name,
             )
         if not wallet_hotkey:
             wallet_hotkey = Prompt.ask(
-                "Enter the the name of the new hotkey", default=defaults.wallet.hotkey
+                f"Enter the the name of the [{COLOR_PALETTE['GENERAL']['HOTKEY']}]new hotkey",
+                default=defaults.wallet.hotkey,
             )
 
         self.verbosity_handler(quiet, verbose)
@@ -2065,14 +2342,10 @@ class CLIManager:
             ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
             validate=WV.NONE,
         )
-        n_words = get_n_words(n_words)
+        if not uri:
+            n_words = get_n_words(n_words)
         return self._run_command(
-            wallets.wallet_create(
-                wallet,
-                n_words,
-                use_password,
-                overwrite,
-            )
+            wallets.wallet_create(wallet, n_words, use_password, uri, overwrite)
         )
 
     def wallet_balance(
@@ -2116,8 +2389,18 @@ class CLIManager:
 
         """
         self.verbosity_handler(quiet, verbose)
-
-        if ss58_addresses:
+        wallet = None
+        if all_balances:
+            ask_for = [WO.PATH]
+            validate = WV.NONE
+            wallet = self.wallet_ask(
+                wallet_name,
+                wallet_path,
+                wallet_hotkey,
+                ask_for=ask_for,
+                validate=validate,
+            )
+        elif ss58_addresses:
             valid_ss58s = [
                 ss58 for ss58 in set(ss58_addresses) if is_valid_ss58_address(ss58)
             ]
@@ -2127,20 +2410,45 @@ class CLIManager:
                 print_error(f"Incorrect ss58 address: {invalid_ss58}. Skipping.")
 
             if valid_ss58s:
-                wallet = None
                 ss58_addresses = valid_ss58s
             else:
                 raise typer.Exit()
         else:
-            ask_for = [] if all_balances else [WO.NAME]
-            validate = WV.NONE if all_balances else WV.WALLET
-            wallet = self.wallet_ask(
-                wallet_name,
-                wallet_path,
-                wallet_hotkey,
-                ask_for=ask_for,
-                validate=validate,
-            )
+            if wallet_name:
+                coldkey_or_ss58 = wallet_name
+            else:
+                coldkey_or_ss58 = Prompt.ask(
+                    "Enter the [blue]wallet name[/blue] or [blue]coldkey ss58 addresses[/blue] (comma-separated)",
+                    default=self.config.get("wallet_name") or defaults.wallet.name,
+                )
+
+            # Split and validate ss58 addresses
+            coldkey_or_ss58_list = [x.strip() for x in coldkey_or_ss58.split(",")]
+            if any(is_valid_ss58_address(x) for x in coldkey_or_ss58_list):
+                valid_ss58s = [
+                    ss58 for ss58 in coldkey_or_ss58_list if is_valid_ss58_address(ss58)
+                ]
+                invalid_ss58s = set(coldkey_or_ss58_list) - set(valid_ss58s)
+                for invalid_ss58 in invalid_ss58s:
+                    print_error(f"Incorrect ss58 address: {invalid_ss58}. Skipping.")
+
+                if valid_ss58s:
+                    ss58_addresses = valid_ss58s
+                else:
+                    raise typer.Exit()
+            else:
+                wallet_name = (
+                    coldkey_or_ss58_list[0] if coldkey_or_ss58_list else wallet_name
+                )
+                ask_for = [WO.NAME, WO.PATH]
+                validate = WV.WALLET
+                wallet = self.wallet_ask(
+                    wallet_name,
+                    wallet_path,
+                    wallet_hotkey,
+                    ask_for=ask_for,
+                    validate=validate,
+                )
         subtensor = self.initialize_chain(network)
         return self._run_command(
             wallets.wallet_balance(wallet, subtensor, all_balances, ss58_addresses)
@@ -2166,19 +2474,23 @@ class CLIManager:
         [green]$[/green] btcli wallet history
 
         """
+        # TODO: Fetch effective network and redirect users accordingly - this only works on finney
+        # no_use_config_str = "Using the network [dark_orange]finney[/dark_orange] and ignoring network/chain configs"
 
-        no_use_config_str = "Using the network [dark_orange]finney[/dark_orange] and ignoring network/chain configs"
+        # if self.config.get("network"):
+        #     if self.config.get("network") != "finney":
+        #         console.print(no_use_config_str)
 
-        if self.config.get("network"):
-            if self.config.get("network") != "finney":
-                console.print(no_use_config_str)
+        # For Rao games
+        print_error("This command is disabled on the 'rao' network.")
+        raise typer.Exit()
 
         self.verbosity_handler(quiet, verbose)
         wallet = self.wallet_ask(
             wallet_name,
             wallet_path,
             wallet_hotkey,
-            ask_for=[WO.NAME],
+            ask_for=[WO.NAME, WO.PATH],
             validate=WV.WALLET,
         )
         return self._run_command(wallets.wallet_history(wallet))
@@ -2189,69 +2501,42 @@ class CLIManager:
         wallet_path: Optional[str] = Options.wallet_path,
         wallet_hotkey: Optional[str] = Options.wallet_hotkey,
         network: Optional[list[str]] = Options.network,
-        display_name: str = typer.Option(
+        name: str = typer.Option(
             "",
-            "--display-name",
-            "--display",
+            "--name",
             help="The display name for the identity.",
         ),
-        legal_name: str = typer.Option(
-            "",
-            "--legal-name",
-            "--legal",
-            help="The legal name for the identity.",
-        ),
         web_url: str = typer.Option(
             "",
             "--web-url",
             "--web",
             help="The web URL for the identity.",
         ),
-        riot_handle: str = typer.Option(
-            "",
-            "--riot-handle",
-            "--riot",
-            help="The Riot handle for the identity.",
-        ),
-        email: str = typer.Option(
-            "",
-            help="The email address for the identity.",
-        ),
-        pgp_fingerprint: str = typer.Option(
-            "",
-            "--pgp-fingerprint",
-            "--pgp",
-            help="The PGP fingerprint for the identity.",
-        ),
         image_url: str = typer.Option(
             "",
             "--image-url",
             "--image",
             help="The image URL for the identity.",
         ),
-        info_: str = typer.Option(
+        discord: str = typer.Option(
             "",
-            "--info",
-            "-i",
-            help="The info for the identity.",
+            "--discord",
+            help="The Discord handle for the identity.",
         ),
-        twitter_url: str = typer.Option(
+        description: str = typer.Option(
             "",
-            "-x",
-            "-𝕏",
-            "--twitter-url",
-            "--twitter",
-            help="The 𝕏 (Twitter) URL for the identity.",
+            "--description",
+            help="The description for the identity.",
         ),
-        validator_id: Optional[bool] = typer.Option(
-            None,
-            "--validator/--not-validator",
-            help="Are you updating a validator hotkey identity?",
+        additional: str = typer.Option(
+            "",
+            "--additional",
+            help="Additional details for the identity.",
         ),
-        subnet_netuid: Optional[int] = typer.Option(
-            None,
-            "--netuid",
-            help="Netuid if you are updating identity of a subnet owner",
+        github_repo: str = typer.Option(
+            "",
+            "--github",
+            help="The GitHub repository for the identity.",
         ),
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
@@ -2279,94 +2564,67 @@ class CLIManager:
             wallet_name,
             wallet_path,
             wallet_hotkey,
-            ask_for=[WO.HOTKEY, WO.NAME],
-            validate=WV.WALLET_AND_HOTKEY,
+            ask_for=[WO.NAME],
+            validate=WV.WALLET,
         )
 
-        if not any(
-            [
-                display_name,
-                legal_name,
-                web_url,
-                riot_handle,
-                email,
-                pgp_fingerprint,
-                image_url,
-                info_,
-                twitter_url,
-            ]
-        ):
-            console.print(
-                "[yellow]All fields are optional. Press Enter to skip a field.[/yellow]"
-            )
-            text_rejection = partial(
-                retry_prompt,
-                rejection=lambda x: sys.getsizeof(x) > 113,
-                rejection_text="[red]Error:[/red] Identity field must be <= 64 raw bytes.",
-            )
+        current_identity = self._run_command(
+            wallets.get_id(
+                self.initialize_chain(network),
+                wallet.coldkeypub.ss58_address,
+                "Current on-chain identity",
+            ),
+            exit_early=False,
+        )
 
-            def pgp_check(s: str):
-                try:
-                    if s.startswith("0x"):
-                        s = s[2:]  # Strip '0x'
-                    pgp_fingerprint_encoded = binascii.unhexlify(s.replace(" ", ""))
-                except Exception:
-                    return True
-                return True if len(pgp_fingerprint_encoded) != 20 else False
-
-            display_name = display_name or text_rejection("Display name")
-            legal_name = legal_name or text_rejection("Legal name")
-            web_url = web_url or text_rejection("Web URL")
-            riot_handle = riot_handle or text_rejection("Riot handle")
-            email = email or text_rejection("Email address")
-            pgp_fingerprint = pgp_fingerprint or retry_prompt(
-                "PGP fingerprint (Eg: A1B2 C3D4 E5F6 7890 1234 5678 9ABC DEF0 1234 5678)",
-                lambda s: False if not s else pgp_check(s),
-                "[red]Error:[/red] PGP Fingerprint must be exactly 20 bytes.",
-            )
-            image_url = image_url or text_rejection("Image URL")
-            info_ = info_ or text_rejection("Enter info")
-            twitter_url = twitter_url or text_rejection("𝕏 (Twitter) URL")
-
-            validator_id = validator_id or Confirm.ask(
-                "Are you updating a [bold blue]validator hotkey[/bold blue] identity or a [bold blue]subnet "
-                "owner[/bold blue] identity?\n"
-                "Enter [bold green]Y[/bold green] for [bold]validator hotkey[/bold] or [bold red]N[/bold red] for "
-                "[bold]subnet owner[/bold]",
-                show_choices=True,
-            )
+        if prompt:
+            if not Confirm.ask(
+                "Cost to register an [blue]Identity[/blue] is [blue]0.1 TAO[/blue],"
+                " are you sure you wish to continue?"
+            ):
+                console.print(":cross_mark: Aborted!")
+                raise typer.Exit()
 
-            if validator_id is False:
-                subnet_netuid = IntPrompt.ask("Enter the netuid of the subnet you own")
+        identity = prompt_for_identity(
+            current_identity,
+            name,
+            web_url,
+            image_url,
+            discord,
+            description,
+            additional,
+            github_repo,
+        )
 
         return self._run_command(
             wallets.set_id(
                 wallet,
                 self.initialize_chain(network),
-                display_name,
-                legal_name,
-                web_url,
-                pgp_fingerprint,
-                riot_handle,
-                email,
-                image_url,
-                twitter_url,
-                info_,
-                validator_id,
-                subnet_netuid,
+                identity["name"],
+                identity["url"],
+                identity["image"],
+                identity["discord"],
+                identity["description"],
+                identity["additional"],
+                identity["github_repo"],
                 prompt,
             )
         )
 
     def wallet_get_id(
         self,
-        target_ss58_address: str = typer.Option(
-            None,
+        wallet_name: Optional[str] = Options.wallet_name,
+        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
+        wallet_path: Optional[str] = Options.wallet_path,
+        coldkey_ss58=typer.Option(
+            None,
+            "--ss58",
+            "--coldkey_ss58",
+            "--coldkey.ss58_address",
+            "--coldkey.ss58",
             "--key",
             "-k",
-            "--ss58",
-            help="The coldkey or hotkey ss58 address to query.",
-            prompt=True,
+            help="Coldkey address of the wallet",
         ),
         network: Optional[list[str]] = Options.network,
         quiet: bool = Options.quiet,
@@ -2389,13 +2647,28 @@ class CLIManager:
 
         [bold]Note[/bold]: This command is primarily used for informational purposes and has no side effects on the blockchain network state.
         """
-        if not is_valid_ss58_address(target_ss58_address):
-            print_error("You have entered an incorrect ss58 address. Please try again")
-            raise typer.Exit()
+        wallet = None
+        if coldkey_ss58:
+            if not is_valid_ss58_address(coldkey_ss58):
+                print_error("You entered an invalid ss58 address")
+                raise typer.Exit()
+        else:
+            coldkey_or_ss58 = Prompt.ask(
+                "Enter the [blue]wallet name[/blue] or [blue]coldkey ss58 address[/blue]",
+                default=self.config.get("wallet_name") or defaults.wallet.name,
+            )
+            if is_valid_ss58_address(coldkey_or_ss58):
+                coldkey_ss58 = coldkey_or_ss58
+            else:
+                wallet_name = coldkey_or_ss58 if coldkey_or_ss58 else wallet_name
+                wallet = self.wallet_ask(
+                    wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME]
+                )
+                coldkey_ss58 = wallet.coldkeypub.ss58_address
 
         self.verbosity_handler(quiet, verbose)
         return self._run_command(
-            wallets.get_id(self.initialize_chain(network), target_ss58_address)
+            wallets.get_id(self.initialize_chain(network), coldkey_ss58)
         )
 
     def wallet_sign(
@@ -2429,934 +2702,493 @@ class CLIManager:
         self.verbosity_handler(quiet, verbose)
         if use_hotkey is None:
             use_hotkey = Confirm.ask(
-                "Would you like to sign the transaction using your [red]hotkey[/red]?"
-                "\n[Type [red]y[/red] for [red]hotkey[/red] and [blue]n[/blue] for [blue]coldkey[/blue]] "
-                "(default is [blue]coldkey[/blue])",
+                f"Would you like to sign the transaction using your [{COLOR_PALETTE['GENERAL']['HOTKEY']}]hotkey[/{COLOR_PALETTE['GENERAL']['HOTKEY']}]?"
+                f"\n[Type [{COLOR_PALETTE['GENERAL']['HOTKEY']}]y[/{COLOR_PALETTE['GENERAL']['HOTKEY']}] for [{COLOR_PALETTE['GENERAL']['HOTKEY']}]hotkey[/{COLOR_PALETTE['GENERAL']['HOTKEY']}]"
+                f" and [{COLOR_PALETTE['GENERAL']['COLDKEY']}]n[/{COLOR_PALETTE['GENERAL']['COLDKEY']}] for [{COLOR_PALETTE['GENERAL']['COLDKEY']}]coldkey[/{COLOR_PALETTE['GENERAL']['COLDKEY']}]] (default is [{COLOR_PALETTE['GENERAL']['COLDKEY']}]coldkey[/{COLOR_PALETTE['GENERAL']['COLDKEY']}])",
                 default=False,
             )
 
-        ask_for = [WO.HOTKEY, WO.NAME] if use_hotkey else [WO.NAME]
+        ask_for = [WO.HOTKEY, WO.PATH, WO.NAME] if use_hotkey else [WO.NAME, WO.PATH]
         validate = WV.WALLET_AND_HOTKEY if use_hotkey else WV.WALLET
 
         wallet = self.wallet_ask(
             wallet_name, wallet_path, wallet_hotkey, ask_for=ask_for, validate=validate
         )
         if not message:
-            message = typer.prompt("Enter the message to encode and sign")
+            message = Prompt.ask("Enter the [blue]message[/blue] to encode and sign")
 
         return self._run_command(wallets.sign(wallet, message, use_hotkey))
 
-    def root_list(
+    def stake_list(
         self,
         network: Optional[list[str]] = Options.network,
+        wallet_name: Optional[str] = Options.wallet_name,
+        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
+        wallet_path: Optional[str] = Options.wallet_path,
+        coldkey_ss58=typer.Option(
+            None,
+            "--ss58",
+            "--coldkey_ss58",
+            "--coldkey.ss58_address",
+            "--coldkey.ss58",
+            help="Coldkey address of the wallet",
+        ),
+        live: bool = Options.live,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
+        no_prompt: bool = Options.prompt,
+        # TODO add: all-wallets, reuse_last, html_output
     ):
         """
-        Show the neurons (root network validators) in the root network (netuid = 0).
+        Display detailed stake information for a wallet across all subnets.
 
-        USAGE
+        Shows stake allocations, exchange rates, and emissions for each hotkey.
 
-        The command fetches and lists the neurons (root network validators) in the root network, showing their unique identifiers (UIDs), names, addresses, stakes, and whether they are part of the senate (network governance body).
+        [bold]Common Examples:[/bold]
 
-        This command is useful for understanding the composition and governance structure of the Bittensor network's root network. It provides insights into which neurons hold significant influence and responsibility within the Bittensor network.
+        1. Basic stake overview:
+        [green]$[/green] btcli stake list --wallet.name my_wallet
 
-        EXAMPLE
+        2. Live updating view with refresh:
+        [green]$[/green] btcli stake list --wallet.name my_wallet --live
 
-        [green]$[/green] btcli root list
+        3. View specific coldkey by address:
+        [green]$[/green] btcli stake list --ss58 5Dk...X3q
+
+        4. Verbose output with full values:
+        [green]$[/green] btcli stake list --wallet.name my_wallet --verbose
         """
         self.verbosity_handler(quiet, verbose)
+
+        wallet = None
+        if coldkey_ss58:
+            if not is_valid_ss58_address(coldkey_ss58):
+                print_error("You entered an invalid ss58 address")
+                raise typer.Exit()
+        else:
+            if wallet_name:
+                coldkey_or_ss58 = wallet_name
+            else:
+                coldkey_or_ss58 = Prompt.ask(
+                    "Enter the [blue]wallet name[/blue] or [blue]coldkey ss58 address[/blue]",
+                    default=self.config.get("wallet_name") or defaults.wallet.name,
+                )
+            if is_valid_ss58_address(coldkey_or_ss58):
+                coldkey_ss58 = coldkey_or_ss58
+            else:
+                wallet_name = coldkey_or_ss58 if coldkey_or_ss58 else wallet_name
+                wallet = self.wallet_ask(
+                    wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
+                )
+
         return self._run_command(
-            root.root_list(subtensor=self.initialize_chain(network))
+            list_stake.stake_list(
+                wallet,
+                coldkey_ss58,
+                self.initialize_chain(network),
+                live,
+                verbose,
+                no_prompt,
+            )
         )
 
-    def root_set_weights(
+    def stake_add(
         self,
-        network: Optional[list[str]] = Options.network,
+        stake_all: bool = typer.Option(
+            False,
+            "--all-tokens",
+            "--all",
+            "-a",
+            help="When set, the command stakes all the available TAO from the coldkey.",
+        ),
+        amount: float = typer.Option(
+            0.0, "--amount", help="The amount of TAO to stake"
+        ),
+        include_hotkeys: str = typer.Option(
+            "",
+            "--include-hotkeys",
+            "-in",
+            "--hotkey-ss58-address",
+            help="Specifies hotkeys by name or ss58 address to stake to. For example, `-in hk1,hk2`",
+        ),
+        exclude_hotkeys: str = typer.Option(
+            "",
+            "--exclude-hotkeys",
+            "-ex",
+            help="Specifies hotkeys by name or ss58 address to not to stake to (use this option only with `--all-hotkeys`)"
+            " i.e. `--all-hotkeys -ex hk3,hk4`",
+        ),
+        all_hotkeys: bool = typer.Option(
+            False,
+            help="When set, this command stakes to all hotkeys associated with the wallet. Do not use if specifying "
+            "hotkeys in `--include-hotkeys`.",
+        ),
+        netuid: Optional[int] = Options.netuid_not_req,
+        all_netuids: bool = Options.all_netuids,
         wallet_name: str = Options.wallet_name,
         wallet_path: str = Options.wallet_path,
         wallet_hotkey: str = Options.wallet_hotkey,
-        netuids=typer.Option(
-            None,
-            "--netuids",
-            "--netuid",
-            "-n",
-            help="Set the netuid(s) to set weights to. Separate multiple netuids with a comma, for example: `-n 0,1,2`.",
-        ),
-        weights: str = Options.weights,
+        network: Optional[list[str]] = Options.network,
+        rate_tolerance: Optional[float] = Options.rate_tolerance,
+        safe_staking: Optional[bool] = Options.safe_staking,
+        allow_partial_stake: Optional[bool] = Options.allow_partial_stake,
         prompt: bool = Options.prompt,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
     ):
         """
-        Set the weights for different subnets, by setting them in the root network.
+        Stake TAO to one or more hotkeys on specific netuids with your coldkey.
 
-        To use this command, you should specify the netuids and corresponding weights you wish to assign. This command is used by validators registered to the root subnet to influence the distribution of subnet rewards and responsibilities.
+        Stake is always added through your coldkey's free balance. For stake movement, please see `[green]$[/green] btcli stake move` command.
 
-        You must have a comprehensive understanding of the dynamics of the subnets to use this command. It is a powerful tool that directly impacts the subnet's  operational mechanics and reward distribution.
+        [bold]Common Examples:[/bold]
 
-        EXAMPLE
+        1. Interactive staking (guided prompts):
+            [green]$[/green] btcli stake add
+
+        2. Safe staking with rate tolerance of 10% with partial transaction disabled:
+            [green]$[/green] btcli stake add --amount 100 --netuid 1 --safe --tolerance 0.1 --no-partial
+
+        3. Allow partial stake if rates change with tolerance of 10%:
+            [green]$[/green] btcli stake add --amount 300 --safe --partial --tolerance 0.1
 
-        With no spaces between the passed values:
+        4. Unsafe staking with no rate protection:
+            [green]$[/green] btcli stake add --amount 300 --netuid 1 --unsafe
 
-        [green]$[/green] btcli root set-weights --netuids 1,2 --weights 0.2,0.3
+        5. Stake to multiple hotkeys:
+            [green]$[/green] btcli stake add --amount 200 --include-hotkeys hk_ss58_1,hk_ss58_2,hk_ss58_3
 
-        or
+        6. Stake all balance to a subnet:
+            [green]$[/green] btcli stake add --all --netuid 3
 
-        Include double quotes to include spaces between the passed values:
+        [bold]Safe Staking Parameters:[/bold]
+        • [blue]--safe[/blue]: Enables rate tolerance checks
+        • [blue]--tolerance[/blue]: Maximum % rate change allowed (0.05 = 5%)
+        • [blue]--partial[/blue]: Complete partial stake if rates exceed tolerance
 
-        [green]$[/green] btcli root set-weights --netuids "1, 2" --weights "0.2, 0.3"
         """
         self.verbosity_handler(quiet, verbose)
+        safe_staking = self.ask_safe_staking(safe_staking)
+        if safe_staking:
+            rate_tolerance = self.ask_rate_tolerance(rate_tolerance)
+            allow_partial_stake = self.ask_partial_stake(allow_partial_stake)
+            console.print("\n")
+        netuid = get_optional_netuid(netuid, all_netuids)
 
-        if netuids:
-            netuids = parse_to_list(
-                netuids,
-                int,
-                "Netuids must be a comma-separated list of ints, e.g., `--netuid 1,2,3,4`.",
+        if stake_all and amount:
+            print_error(
+                "Cannot specify an amount and 'stake-all'. Choose one or the other."
             )
-        else:
-            netuids = list_prompt(netuids, int, "Enter netuids (e.g: 1, 4, 6)")
+            raise typer.Exit()
 
-        if weights:
-            weights = parse_to_list(
-                weights,
-                float,
-                "Weights must be a comma-separated list of floats, e.g., `--weights 0.3,0.4,0.3`.",
-            )
-        else:
-            weights = list_prompt(
-                weights, float, "Enter weights (e.g. 0.02, 0.03, 0.01)"
-            )
+        if stake_all and not amount:
+            if not Confirm.ask("Stake all the available TAO tokens?", default=False):
+                raise typer.Exit()
 
-        if len(netuids) != len(weights):
-            raise typer.BadParameter(
-                "The number of netuids and weights must be the same."
+        if all_hotkeys and include_hotkeys:
+            print_error(
+                "You have specified hotkeys to include and also the `--all-hotkeys` flag. The flag"
+                "should only be used standalone (to use all hotkeys) or with `--exclude-hotkeys`."
             )
+            raise typer.Exit()
 
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            wallet_hotkey,
-            ask_for=[WO.HOTKEY, WO.NAME],
-            validate=WV.WALLET_AND_HOTKEY,
-        )
-        self._run_command(
-            root.set_weights(
-                wallet, self.initialize_chain(network), netuids, weights, prompt
+        if include_hotkeys and exclude_hotkeys:
+            print_error(
+                "You have specified options for both including and excluding hotkeys. Select one or the other."
             )
-        )
+            raise typer.Exit()
 
-    def root_get_weights(
-        self,
-        network: Optional[list[str]] = Options.network,
-        limit_min_col: Optional[int] = typer.Option(
-            None,
-            "--limit-min-col",
-            "--min",
-            help="Limit the left display of the table to this column.",
-        ),
-        limit_max_col: Optional[int] = typer.Option(
-            None,
-            "--limit-max-col",
-            "--max",
-            help="Limit the right display of the table to this column.",
-        ),
-        reuse_last: bool = Options.reuse_last,
-        html_output: bool = Options.html_output,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Shows a table listing the weights assigned to each subnet in the root network.
+        if not wallet_hotkey and not all_hotkeys and not include_hotkeys:
+            if not wallet_name:
+                wallet_name = Prompt.ask(
+                    "Enter the [blue]wallet name[/blue]",
+                    default=self.config.get("wallet_name") or defaults.wallet.name,
+                )
+            if netuid is not None:
+                hotkey_or_ss58 = Prompt.ask(
+                    "Enter the [blue]wallet hotkey[/blue] name or [blue]ss58 address[/blue] to stake to [dim](or Press Enter to view delegates)[/dim]",
+                )
+            else:
+                hotkey_or_ss58 = Prompt.ask(
+                    "Enter the [blue]hotkey[/blue] name or [blue]ss58 address[/blue] to stake to",
+                    default=self.config.get("wallet_hotkey") or defaults.wallet.hotkey,
+                )
 
-        This command provides visibility into how network responsibilities and rewards are distributed among various subnets. This information is crucial for understanding the current influence and reward distribution across different subnets. Use this command if you are interested in the governance and operational dynamics of the Bittensor network.
+            if hotkey_or_ss58 == "":
+                wallet = self.wallet_ask(
+                    wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
+                )
+                selected_hotkey = self._run_command(
+                    subnets.show(
+                        subtensor=self.initialize_chain(network),
+                        netuid=netuid,
+                        sort=False,
+                        max_rows=12,
+                        prompt=False,
+                        delegate_selection=True,
+                    ),
+                    exit_early=False,
+                )
+                if selected_hotkey is None:
+                    print_error("No delegate selected. Exiting.")
+                    raise typer.Exit()
+                include_hotkeys = selected_hotkey
+            elif is_valid_ss58_address(hotkey_or_ss58):
+                wallet = self.wallet_ask(
+                    wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
+                )
+                include_hotkeys = hotkey_or_ss58
+            else:
+                wallet_hotkey = hotkey_or_ss58
+                wallet = self.wallet_ask(
+                    wallet_name,
+                    wallet_path,
+                    wallet_hotkey,
+                    ask_for=[WO.NAME, WO.HOTKEY, WO.PATH],
+                    validate=WV.WALLET_AND_HOTKEY,
+                )
+                include_hotkeys = wallet.hotkey.ss58_address
 
-        EXAMPLE
+        elif all_hotkeys or include_hotkeys or exclude_hotkeys:
+            wallet = self.wallet_ask(
+                wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
+            )
+        else:
+            wallet = self.wallet_ask(
+                wallet_name,
+                wallet_path,
+                wallet_hotkey,
+                ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
+                validate=WV.WALLET_AND_HOTKEY,
+            )
 
-        [green]$[/green] btcli root get_weights
-        """
-        self.verbosity_handler(quiet, verbose)
-        if (reuse_last or html_output) and self.config.get("use_cache") is False:
-            err_console.print(
-                "Unable to use `--reuse-last` or `--html` when config 'no-cache' is set to 'True'."
-                "Change it to 'False' using `btcli config set`."
+        if include_hotkeys:
+            include_hotkeys = parse_to_list(
+                include_hotkeys,
+                str,
+                "Hotkeys must be a comma-separated list of ss58s, e.g., `--include-hotkeys 5Grw....,5Grw....`.",
+                is_ss58=True,
             )
-            raise typer.Exit()
-        if not reuse_last:
-            subtensor = self.initialize_chain(network)
         else:
-            subtensor = None
+            include_hotkeys = []
+
+        if exclude_hotkeys:
+            exclude_hotkeys = parse_to_list(
+                exclude_hotkeys,
+                str,
+                "Hotkeys must be a comma-separated list of ss58s, e.g., `--exclude-hotkeys 5Grw....,5Grw....`.",
+                is_ss58=True,
+            )
+        else:
+            exclude_hotkeys = []
+
+        # TODO: Ask amount for each subnet explicitly if more than one
+        if not stake_all and not amount:
+            free_balance = self._run_command(
+                wallets.wallet_balance(
+                    wallet, self.initialize_chain(network), False, None
+                ),
+                exit_early=False,
+            )
+            if free_balance == Balance.from_tao(0):
+                print_error("You dont have any balance to stake.")
+                raise typer.Exit()
+            if netuid is not None:
+                amount = FloatPrompt.ask(
+                    f"Amount to [{COLOR_PALETTE['GENERAL']['SUBHEADING_MAIN']}]stake (TAO τ)"
+                )
+            else:
+                amount = FloatPrompt.ask(
+                    f"Amount to [{COLOR_PALETTE['GENERAL']['SUBHEADING_MAIN']}]stake to each netuid (TAO τ)"
+                )
+
+            if amount <= 0:
+                print_error(f"You entered an incorrect stake amount: {amount}")
+                raise typer.Exit()
+            if Balance.from_tao(amount) > free_balance:
+                print_error(
+                    f"You dont have enough balance to stake. Current free Balance: {free_balance}."
+                )
+                raise typer.Exit()
+
         return self._run_command(
-            root.get_weights(
-                subtensor,
-                limit_min_col,
-                limit_max_col,
-                reuse_last,
-                html_output,
-                not self.config.get("use_cache", True),
+            add_stake.stake_add(
+                wallet,
+                self.initialize_chain(network),
+                netuid,
+                stake_all,
+                amount,
+                prompt,
+                all_hotkeys,
+                include_hotkeys,
+                exclude_hotkeys,
+                safe_staking,
+                rate_tolerance,
+                allow_partial_stake,
             )
         )
 
-    def root_boost(
+    def stake_remove(
         self,
         network: Optional[list[str]] = Options.network,
         wallet_name: str = Options.wallet_name,
-        wallet_path: Optional[str] = Options.wallet_path,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        netuid: int = Options.netuid,
+        wallet_path: str = Options.wallet_path,
+        wallet_hotkey: str = Options.wallet_hotkey,
+        netuid: Optional[int] = Options.netuid_not_req,
+        all_netuids: bool = Options.all_netuids,
+        unstake_all: bool = typer.Option(
+            False,
+            "--unstake-all",
+            "--all",
+            hidden=True,
+            help="When set, this command unstakes all staked TAO + Alpha from the all hotkeys.",
+        ),
+        unstake_all_alpha: bool = typer.Option(
+            False,
+            "--unstake-all-alpha",
+            "--all-alpha",
+            hidden=True,
+            help="When set, this command unstakes all staked Alpha from the all hotkeys.",
+        ),
         amount: float = typer.Option(
-            None,
-            "--amount",
-            "--increase",
-            "-a",
-            prompt="Enter the boost amount (added to existing weight)",
-            help="Amount (float) to boost (added to the existing weight), (e.g. 0.01)",
+            0.0, "--amount", "-a", help="The amount of TAO to unstake."
+        ),
+        hotkey_ss58_address: str = typer.Option(
+            "",
+            help="The ss58 address of the hotkey to unstake from.",
+        ),
+        include_hotkeys: str = typer.Option(
+            "",
+            "--include-hotkeys",
+            "-in",
+            help="Specifies the hotkeys by name or ss58 address to unstake from. For example, `-in hk1,hk2`",
+        ),
+        exclude_hotkeys: str = typer.Option(
+            "",
+            "--exclude-hotkeys",
+            "-ex",
+            help="Specifies the hotkeys by name or ss58 address not to unstake from (only use with `--all-hotkeys`)"
+            " i.e. `--all-hotkeys -ex hk3,hk4`",
+        ),
+        all_hotkeys: bool = typer.Option(
+            False,
+            help="When set, this command unstakes from all the hotkeys associated with the wallet. Do not use if specifying "
+            "hotkeys in `--include-hotkeys`.",
         ),
+        rate_tolerance: Optional[float] = Options.rate_tolerance,
+        safe_staking: Optional[bool] = Options.safe_staking,
+        allow_partial_stake: Optional[bool] = Options.allow_partial_stake,
         prompt: bool = Options.prompt,
+        interactive: bool = typer.Option(
+            False,
+            "--interactive",
+            "-i",
+            help="Enter interactive mode for unstaking.",
+        ),
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
     ):
         """
-        Increase (boost) the weights for a specific subnet in the root network. Any amount provided will be added to the subnet's existing weight.
+        Unstake TAO from one or more hotkeys and transfer them back to the user's coldkey wallet.
 
-        EXAMPLE
+        This command is used to withdraw TAO or Alpha stake from different hotkeys.
 
-        [green]$[/green] btcli root boost --netuid 1 --increase 0.01
+        [bold]Common Examples:[/bold]
+
+        1. Interactive unstaking (guided prompts):
+            [green]$[/green] btcli stake remove
+
+        2. Safe unstaking with 10% rate tolerance:
+            [green]$[/green] btcli stake remove --amount 100 --netuid 1 --safe --tolerance 0.1
+
+        3. Allow partial unstake if rates change:
+            [green]$[/green] btcli stake remove --amount 300 --safe --partial
+
+        4. Unstake from multiple hotkeys:
+            [green]$[/green] btcli stake remove --amount 200 --include-hotkeys hk1,hk2,hk3
+
+        5. Unstake all from a hotkey:
+            [green]$[/green] btcli stake remove --all
+
+        6. Unstake all Alpha from a hotkey and stake to Root:
+            [green]$[/green] btcli stake remove --all-alpha
+
+        [bold]Safe Staking Parameters:[/bold]
+        • [blue]--safe[/blue]: Enables rate tolerance checks during unstaking
+        • [blue]--tolerance[/blue]: Max allowed rate change (0.05 = 5%)
+        • [blue]--partial[/blue]: Complete partial unstake if rates exceed tolerance
         """
         self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            wallet_hotkey,
-            ask_for=[WO.NAME, WO.HOTKEY],
-            validate=WV.WALLET_AND_HOTKEY,
-        )
-        return self._run_command(
-            root.set_boost(
-                wallet, self.initialize_chain(network), netuid, amount, prompt
-            )
-        )
-
-    def root_slash(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: Optional[str] = Options.wallet_path,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        netuid: int = Options.netuid,
-        amount: float = typer.Option(
-            None,
-            "--amount",
-            "--decrease",
-            "-a",
-            prompt="Enter the slash amount (subtracted from the existing weight)",
-            help="Amount (float) to slash (subtract from the existing weight), (e.g. 0.01)",
-        ),
-        prompt: bool = Options.prompt,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Decrease (slash) the weights for a specific subnet in the root network. Any amount provided will be subtracted from the subnet's existing weight.
-
-        EXAMPLE
-
-        [green]$[/green] btcli root slash --netuid 1 --decrease 0.01
-
-        """
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            wallet_hotkey,
-            ask_for=[WO.NAME, WO.HOTKEY],
-            validate=WV.WALLET_AND_HOTKEY,
-        )
-        return self._run_command(
-            root.set_slash(
-                wallet, self.initialize_chain(network), netuid, amount, prompt
-            )
-        )
-
-    def root_senate_vote(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: Optional[str] = Options.wallet_name,
-        wallet_path: Optional[str] = Options.wallet_path,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        proposal: str = typer.Option(
-            None,
-            "--proposal",
-            "--proposal-hash",
-            prompt="Enter the proposal hash",
-            help="The hash of the proposal to vote on.",
-        ),
-        prompt: bool = Options.prompt,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-        vote: bool = typer.Option(
-            None,
-            "--vote-aye/--vote-nay",
-            prompt="Enter y to vote Aye, or enter n to vote Nay",
-            help="The vote casted on the proposal",
-        ),
-    ):
-        """
-        Cast a vote on an active proposal in Bittensor's governance protocol.
-
-        This command is used by Senate members to vote on various proposals that shape the network's future. Use `btcli root proposals` to see the active proposals and their hashes.
-
-        USAGE
-
-        The user must specify the hash of the proposal they want to vote on. The command then allows the Senate member to cast a 'Yes' or 'No' vote, contributing to the decision-making process on the proposal. This command is crucial for Senate members to exercise their voting rights on key proposals. It plays a vital role in the governance and evolution of the Bittensor network.
-
-        EXAMPLE
-
-        [green]$[/green] btcli root senate_vote --proposal <proposal_hash>
-        """
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            wallet_hotkey,
-            ask_for=[WO.NAME, WO.HOTKEY],
-            validate=WV.WALLET_AND_HOTKEY,
-        )
-        return self._run_command(
-            root.senate_vote(
-                wallet, self.initialize_chain(network), proposal, vote, prompt
-            )
-        )
-
-    def root_senate(
-        self,
-        network: Optional[list[str]] = Options.network,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Shows the Senate members of the Bittensor's governance protocol.
-
-        This command lists the delegates involved in the decision-making process of the Bittensor network, showing their names and wallet addresses. This information is crucial for understanding who holds governance roles within the network.
-
-        EXAMPLE
-
-        [green]$[/green] btcli root senate
-        """
-        self.verbosity_handler(quiet, verbose)
-        return self._run_command(root.get_senate(self.initialize_chain(network)))
-
-    def root_register(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: Optional[str] = Options.wallet_name,
-        wallet_path: Optional[str] = Options.wallet_path,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        prompt: bool = Options.prompt,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Register a neuron to the root subnet by recycling some TAO to cover for the registration cost.
-
-        This command adds a new neuron as a validator on the root network. This will allow the neuron owner to set subnet weights.
-
-        # Usage:
-
-        Before registering, the command checks if the specified subnet exists and whether the TAO balance in the user's wallet is sufficient to cover the registration cost. The registration cost is determined by the current recycle amount for the specified subnet. If the balance is insufficient or the subnet does not exist, the command will exit with an appropriate error message.
-
-        # Example usage:
-
-        [green]$[/green] btcli subnets register --netuid 1
-        """
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            wallet_hotkey,
-            ask_for=[WO.NAME, WO.HOTKEY],
-            validate=WV.WALLET_AND_HOTKEY,
-        )
-        return self._run_command(
-            root.register(wallet, self.initialize_chain(network), prompt)
-        )
-
-    def root_proposals(
-        self,
-        network: Optional[list[str]] = Options.network,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        View active proposals for the senate in the Bittensor's governance protocol.
-
-        This command displays the details of ongoing proposals, including proposal hashes, votes, thresholds, and proposal data.
-
-        EXAMPLE
-
-        [green]$[/green] btcli root proposals
-        """
-        self.verbosity_handler(quiet, verbose)
-        return self._run_command(
-            root.proposals(self.initialize_chain(network), verbose)
-        )
-
-    def root_set_take(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: Optional[str] = Options.wallet_name,
-        wallet_path: Optional[str] = Options.wallet_path,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        take: float = typer.Option(None, help="The new take value."),
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Allows users to change their delegate take percentage.
-
-        This command can be used to update the delegate takes individually for every subnet. To run the command, the user must have a configured wallet with both hotkey and coldkey. The command performs the below checks:
-
-            1. The provided hotkey is already a delegate.
-            2. The new take value is within 0-18% range.
-
-        EXAMPLE
-
-        [green]$[/green] btcli root set_take --wallet-name my_wallet --wallet-hotkey my_hotkey
-        """
-        max_value = 0.18
-        min_value = 0.00
-        self.verbosity_handler(quiet, verbose)
-
-        if not take:
-            max_value_style = typer.style(f"Max: {max_value}", fg="magenta")
-            min_value_style = typer.style(f"Min: {min_value}", fg="magenta")
-            prompt_text = typer.style(
-                "Enter take value (0.18 for 18%)", fg="bright_cyan", bold=True
-            )
-            take = FloatPrompt.ask(f"{prompt_text} {min_value_style} {max_value_style}")
-
-        if not (min_value <= take <= max_value):
-            print_error(
-                f"Take value must be between {min_value} and {max_value}. Provided value: {take}"
-            )
-            raise typer.Exit()
-
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            wallet_hotkey,
-            ask_for=[WO.NAME, WO.HOTKEY],
-            validate=WV.WALLET_AND_HOTKEY,
-        )
-
-        return self._run_command(
-            root.set_take(wallet, self.initialize_chain(network), take)
-        )
-
-    def root_delegate_stake(
-        self,
-        delegate_ss58key: str = typer.Option(
-            None,
-            help="The ss58 address of the delegate hotkey to stake TAO to.",
-            prompt="Enter the hotkey ss58 address you want to delegate TAO to.",
-        ),
-        amount: Optional[float] = typer.Option(
-            None, help="The amount of TAO to stake. Do no specify if using `--all`"
-        ),
-        stake_all: Optional[bool] = typer.Option(
-            False,
-            "--all",
-            "-a",
-            help="If specified, the command stakes all available TAO. Do not specify if using"
-            " `--amount`",
-        ),
-        wallet_name: Optional[str] = Options.wallet_name,
-        wallet_path: Optional[str] = Options.wallet_path,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        network: Optional[list[str]] = Options.network,
-        prompt: bool = Options.prompt,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Stakes TAO to a specified delegate hotkey.
-
-        This command allocates the user's TAO to the specified hotkey of a delegate, potentially earning staking rewards in return. If the
-        `--all` flag is used, it delegates the entire TAO balance available in the user's wallet.
-
-        This command should be run by a TAO holder. Compare this command with "btcli stake add" that is typically run by a subnet validator to add stake to their own delegate hotkey.
-
-        EXAMPLE
-
-        [green]$[/green] btcli root delegate-stake --delegate_ss58key <SS58_ADDRESS> --amount <AMOUNT>
-
-        [green]$[/green] btcli root delegate-stake --delegate_ss58key <SS58_ADDRESS> --all
-
-        [blue bold]Note[/blue bold]: This command modifies the blockchain state and may incur transaction fees. The user should ensure the delegate's address and the amount to be staked are correct before executing the command.
-        """
-        self.verbosity_handler(quiet, verbose)
-        if amount and stake_all:
-            err_console.print(
-                "Both `--amount` and `--all` are specified. Choose one or the other."
-            )
-        if not stake_all and not amount:
-            while True:
-                amount = FloatPrompt.ask(
-                    "Amount to [blue]stake (TAO τ)[/blue]", console=console
-                )
-                confirmation = FloatPrompt.ask(
-                    "Confirm the amount to stake [blue](TAO τ)[/blue]",
-                    console=console,
-                )
-                if amount == confirmation:
-                    break
-                else:
-                    err_console.print(
-                        "[red]The amounts do not match. Please try again.[/red]"
-                    )
-
-        wallet = self.wallet_ask(
-            wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME]
-        )
-        return self._run_command(
-            root.delegate_stake(
-                wallet,
-                self.initialize_chain(network),
-                amount,
-                delegate_ss58key,
-                prompt,
-            )
-        )
-
-    def root_undelegate_stake(
-        self,
-        delegate_ss58key: str = typer.Option(
-            None,
-            help="The ss58 address of the delegate to undelegate from.",
-            prompt="Enter the hotkey ss58 address you want to undelegate from",
-        ),
-        amount: Optional[float] = typer.Option(
-            None, help="The amount of TAO to unstake. Do no specify if using `--all`"
-        ),
-        unstake_all: Optional[bool] = typer.Option(
-            False,
-            "--all",
-            "-a",
-            help="If specified, the command undelegates all staked TAO from the delegate. Do not specify if using"
-            " `--amount`",
-        ),
-        wallet_name: Optional[str] = Options.wallet_name,
-        wallet_path: Optional[str] = Options.wallet_path,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        network: Optional[list[str]] = Options.network,
-        prompt: bool = Options.prompt,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Allows users to withdraw their staked TAO from a delegate.
-
-        The user must provide the delegate hotkey's ss58 address and the amount of TAO to undelegate. The function will then send a transaction to the blockchain to process the undelegation. This command can result in a change to the blockchain state and may incur transaction fees.
-
-        EXAMPLE
-
-        [green]$[/green] btcli undelegate --delegate_ss58key <SS58_ADDRESS> --amount <AMOUNT>
-
-        [green]$[/green] btcli undelegate --delegate_ss58key <SS58_ADDRESS> --all
-        """
-        self.verbosity_handler(quiet, verbose)
-        if amount and unstake_all:
-            err_console.print(
-                "Both `--amount` and `--all` are specified. Choose one or the other."
-            )
-        if not unstake_all and not amount:
-            while True:
-                amount = FloatPrompt.ask(
-                    "Amount to [blue]unstake (TAO τ)[/blue]", console=console
-                )
-                confirmation = FloatPrompt.ask(
-                    "Confirm the amount to unstake [blue](TAO τ)[/blue]",
-                    console=console,
-                )
-                if amount == confirmation:
-                    break
-                else:
-                    err_console.print(
-                        "[red]The amounts do not match. Please try again.[/red]"
-                    )
-
-        wallet = self.wallet_ask(
-            wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME]
-        )
-        self._run_command(
-            root.delegate_unstake(
-                wallet,
-                self.initialize_chain(network),
-                amount,
-                delegate_ss58key,
-                prompt,
-            )
-        )
-
-    def root_my_delegates(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: Optional[str] = Options.wallet_name,
-        wallet_path: Optional[str] = Options.wallet_path,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        all_wallets: bool = typer.Option(
-            False,
-            "--all-wallets",
-            "--all",
-            "-a",
-            help="If specified, the command aggregates information across all the wallets.",
-        ),
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Shows a table with the details on the user's delegates.
-
-        The table output includes the following columns:
-
-        - Wallet: The name of the user's wallet (coldkey).
-
-        - OWNER: The name of the delegate who owns the hotkey.
-
-        - SS58: The truncated SS58 address of the delegate's hotkey.
-
-        - Delegation: The amount of TAO staked by the user to the delegate.
-
-        - τ/24h: The earnings from the delegate to the user over the past 24 hours.
-
-        - NOMS: The number of nominators for the delegate.
-
-        - OWNER STAKE(τ): The stake amount owned by the delegate.
-
-        - TOTAL STAKE(τ): The total stake amount held by the delegate.
-
-        - SUBNETS: The list of subnets the delegate is a part of.
-
-        - VPERMIT: Validator permits held by the delegate for various subnets.
-
-        - 24h/kτ: Earnings per 1000 TAO staked over the last 24 hours.
-
-        - Desc: A description of the delegate.
-
-        The command also sums and prints the total amount of TAO delegated across all wallets.
-
-        EXAMPLE
-
-        [green]$[/green] btcli root my-delegates
-        [green]$[/green] btcli root my-delegates --all
-        [green]$[/green] btcli root my-delegates --wallet-name my_wallet
-
-        [blue bold]Note[/blue bold]: This command is not intended to be used directly in user code.
-        """
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            wallet_hotkey,
-            ask_for=([WO.NAME] if not all_wallets else []),
-            validate=WV.WALLET if not all_wallets else WV.NONE,
-        )
-        self._run_command(
-            root.my_delegates(wallet, self.initialize_chain(network), all_wallets)
-        )
-
-    def root_list_delegates(
-        self,
-        network: Optional[list[str]] = Options.network,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Displays a table of Bittensor network-wide delegates, providing a comprehensive overview of delegate statistics and information.
-
-        This table helps users make informed decisions on which delegates to allocate their TAO stake.
-
-        The table columns include:
-
-        - INDEX: The delegate's index in the sorted list.
-
-        - DELEGATE: The name of the delegate.
-
-        - SS58: The delegate's unique ss58 address (truncated for display).
-
-        - NOMINATORS: The count of nominators backing the delegate.
-
-        - OWN STAKE(τ): The amount of delegate's own stake (not the TAO delegated from any nominators).
-
-        - TOTAL STAKE(τ): The delegate's total stake, i.e., the sum of delegate's own stake and nominators' stakes.
-
-        - CHANGE/(4h): The percentage change in the delegate's stake over the last four hours.
-
-        - SUBNETS: The subnets in which the delegate is registered.
-
-        - VPERMIT: Indicates the subnets in which the delegate has validator permits.
-
-        - NOMINATOR/(24h)/kτ: The earnings per 1000 τ staked by nominators in the last 24 hours.
-
-        - DELEGATE/(24h): The total earnings of the delegate in the last 24 hours.
-
-        - DESCRIPTION: A brief description of the delegate's purpose and operations.
-
-        [blue bold]NOTES:[/blue bold]
-
-            - Sorting is done based on the `TOTAL STAKE` column in descending order.
-            - Changes in stake are shown as: increases in green and decreases in red.
-            - Entries with no previous data are marked with `NA`.
-            - Each delegate's name is a hyperlink to more information, if available.
-
-        EXAMPLE
-
-        [green]$[/green] btcli root list_delegates
-
-        [green]$[/green] btcli root list_delegates --subtensor.network finney # can also be `test` or `local`
-
-        [blue bold]NOTE[/blue bold]: This command is intended for use within a
-        console application. It prints directly to the console and does not return any value.
-        """
-        self.verbosity_handler(quiet, verbose)
-
-        if network:
-            if "finney" in network:
-                network = ["wss://archive.chain.opentensor.ai:443"]
-        elif (conf_net := self.config.get("network")) == "finney":
-            network = ["wss://archive.chain.opentensor.ai:443"]
-        elif conf_net:
-            network = [conf_net]
-        else:
-            network = ["wss://archive.chain.opentensor.ai:443"]
-
-        sub = self.initialize_chain(network)
-        return self._run_command(root.list_delegates(sub))
-
-    # TODO: Confirm if we need a command for this - currently registering to root auto makes u delegate
-    def root_nominate(
-        self,
-        wallet_name: Optional[str] = Options.wallet_name,
-        wallet_path: Optional[str] = Options.wallet_path,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        network: Optional[list[str]] = Options.network,
-        prompt: bool = Options.prompt,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Enables a wallet's hotkey to become a delegate.
-
-        This command handles the nomination process, including wallet unlocking and verification of the hotkey's current delegate status.
-
-        The command performs several checks:
-
-            - Verifies that the hotkey is not already a delegate to prevent redundant nominations.
-
-            - Tries to nominate the wallet and reports success or failure.
-
-        Upon success, the wallet's hotkey is registered as a delegate on the network.
-
-        To run the command, the user must have a configured wallet with both hotkey and coldkey. If the wallet is not already nominated, this command will initiate the process.
-
-        EXAMPLE
-
-        [green]$[/green] btcli root nominate
-
-        [green]$[/green] btcli root nominate --wallet-name my_wallet --wallet-hotkey my_hotkey
-
-        [blue bold]Note[/blue bold]: This command prints the output directly to the console. It should not be called programmatically in user code due to its interactive nature and side effects on the network state.
-        """
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            wallet_hotkey,
-            ask_for=[WO.NAME, WO.HOTKEY],
-            validate=WV.WALLET_AND_HOTKEY,
-        )
-        return self._run_command(
-            root.nominate(wallet, self.initialize_chain(network), prompt)
-        )
-
-    def stake_show(
-        self,
-        all_wallets: bool = typer.Option(
-            False,
-            "--all",
-            "--all-wallets",
-            "-a",
-            help="When set, the command checks all the coldkey wallets of the user instead of just the specified wallet.",
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: Optional[str] = Options.wallet_name,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        wallet_path: Optional[str] = Options.wallet_path,
-        reuse_last: bool = Options.reuse_last,
-        html_output: bool = Options.html_output,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Lists all the stake accounts associated with a user's wallet.
-
-        This command provides a comprehensive view of the stakes associated with the user's coldkeys. It shows both the user's own hotkeys and also the hotkeys of the delegates to which this user has staked.
-
-        The command lists all the stake accounts for a specified wallet or all wallets in the user's configuration directory. It displays the coldkey, balance, hotkey details (own hotkey and delegate hotkey), stake amount, and the rate of return.
-
-        The command shows a table with the below columns:
-
-        - Coldkey: The coldkey associated with the wallet.
-
-        - Balance: The balance of the coldkey.
-
-        - Hotkey: The names of the coldkey's own hotkeys and the delegate hotkeys to which this coldkey has staked.
-
-        - Stake: The amount of TAO staked to all the hotkeys.
-
-        - Rate: The rate of return on the stake, shown in TAO per day.
-
-        EXAMPLE
-
-        [green]$[/green] btcli stake show --all
-        """
-        self.verbosity_handler(quiet, verbose)
-        if (reuse_last or html_output) and self.config.get("use_cache") is False:
-            err_console.print(
-                "Unable to use `--reuse-last` or `--html` when config 'no-cache' is set to 'True'. "
-                "Please change the config to 'False' using `btcli config set`"
+        if not unstake_all and not unstake_all_alpha:
+            safe_staking = self.ask_safe_staking(safe_staking)
+            if safe_staking:
+                rate_tolerance = self.ask_rate_tolerance(rate_tolerance)
+                allow_partial_stake = self.ask_partial_stake(allow_partial_stake)
+                console.print("\n")
+
+        if interactive and any(
+            [hotkey_ss58_address, include_hotkeys, exclude_hotkeys, all_hotkeys]
+        ):
+            print_error(
+                "Interactive mode cannot be used with hotkey selection options like --include-hotkeys, --exclude-hotkeys, --all-hotkeys, or --hotkey."
             )
             raise typer.Exit()
-        if not reuse_last:
-            subtensor = self.initialize_chain(network)
-        else:
-            subtensor = None
-
-        if all_wallets:
-            wallet = self.wallet_ask(
-                wallet_name,
-                wallet_path,
-                wallet_hotkey,
-                ask_for=[],
-                validate=WV.NONE,
-            )
-        else:
-            wallet = self.wallet_ask(
-                wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME]
-            )
-
-        return self._run_command(
-            stake.show(
-                wallet,
-                subtensor,
-                all_wallets,
-                reuse_last,
-                html_output,
-                not self.config.get("use_cache", True),
-            )
-        )
-
-    def stake_add(
-        self,
-        stake_all: bool = typer.Option(
-            False,
-            "--all-tokens",
-            "--all",
-            "-a",
-            help="When set, the command stakes all the available TAO from the coldkey.",
-        ),
-        amount: float = typer.Option(
-            0.0, "--amount", help="The amount of TAO to stake"
-        ),
-        max_stake: float = typer.Option(
-            0.0,
-            "--max-stake",
-            "-m",
-            help="Stake is sent to a hotkey only until the hotkey's total stake is less than or equal to this maximum staked TAO. If a hotkey already has stake greater than this amount, then stake is not added to this hotkey.",
-        ),
-        hotkey_ss58_address: str = typer.Option(
-            "",
-            help="The ss58 address of the hotkey to stake to.",
-        ),
-        include_hotkeys: str = typer.Option(
-            "",
-            "--include-hotkeys",
-            "-in",
-            help="Specifies hotkeys by name or ss58 address to stake to. For example, `-in hk1,hk2`",
-        ),
-        exclude_hotkeys: str = typer.Option(
-            "",
-            "--exclude-hotkeys",
-            "-ex",
-            help="Specifies hotkeys by name or ss58 address to not to stake to (use this option only with `--all-hotkeys`)"
-            " i.e. `--all-hotkeys -ex hk3,hk4`",
-        ),
-        all_hotkeys: bool = typer.Option(
-            False,
-            help="When set, this command stakes to all hotkeys associated with the wallet. Do not use if specifying "
-            "hotkeys in `--include-hotkeys`.",
-        ),
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        wallet_hotkey: str = Options.wallet_hotkey,
-        network: Optional[list[str]] = Options.network,
-        prompt: bool = Options.prompt,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """
-        Stake TAO to one or more hotkeys associated with the user's coldkey.
-
-        This command is used by a subnet validator to stake to their own hotkey. Compare this command with "btcli root delegate" that is typically run by a TAO holder to delegate their TAO to a delegate's hotkey.
-
-        This command is used by a subnet validator to allocate stake TAO to their different hotkeys, securing their position and influence on the network.
-
-        EXAMPLE
-
-        [green]$[/green] btcli stake add --amount 100 --wallet-name <my_wallet> --wallet-hotkey <my_hotkey>
-        """
-        self.verbosity_handler(quiet, verbose)
 
-        if stake_all and amount:
-            print_error(
-                "Cannot specify an amount and 'stake-all'. Choose one or the other."
-            )
+        if unstake_all and unstake_all_alpha:
+            print_error("Cannot specify both unstake-all and unstake-all-alpha.")
             raise typer.Exit()
 
-        if not stake_all and not amount and not max_stake:
-            amount = FloatPrompt.ask("Amount to [blue]stake (TAO τ)[/blue]")
+        if not interactive and not unstake_all and not unstake_all_alpha:
+            netuid = get_optional_netuid(netuid, all_netuids)
+            if all_hotkeys and include_hotkeys:
+                print_error(
+                    "You have specified hotkeys to include and also the `--all-hotkeys` flag. The flag"
+                    " should only be used standalone (to use all hotkeys) or with `--exclude-hotkeys`."
+                )
+                raise typer.Exit()
 
-        if stake_all and not amount:
-            if not Confirm.ask("Stake all the available TAO tokens?", default=False):
+            if include_hotkeys and exclude_hotkeys:
+                print_error(
+                    "You have specified both including and excluding hotkeys options. Select one or the other."
+                )
                 raise typer.Exit()
 
-        if all_hotkeys and include_hotkeys:
-            err_console.print(
-                "You have specified hotkeys to include and also the `--all-hotkeys` flag. The flag"
-                "should only be used standalone (to use all hotkeys) or with `--exclude-hotkeys`."
-            )
-            raise typer.Exit()
+            if unstake_all and amount:
+                print_error(
+                    "Cannot specify both a specific amount and 'unstake-all'. Choose one or the other."
+                )
+                raise typer.Exit()
 
-        if include_hotkeys and exclude_hotkeys:
-            err_console.print(
-                "You have specified options for both including and excluding hotkeys. Select one or the other."
-            )
-            raise typer.Exit()
+            if amount and amount <= 0:
+                print_error(f"You entered an incorrect unstake amount: {amount}")
+                raise typer.Exit()
 
         if (
             not wallet_hotkey
+            and not hotkey_ss58_address
             and not all_hotkeys
             and not include_hotkeys
-            and not hotkey_ss58_address
+            and not interactive
+            and not unstake_all
+            and not unstake_all_alpha
         ):
+            if not wallet_name:
+                wallet_name = Prompt.ask(
+                    "Enter the [blue]wallet name[/blue]",
+                    default=self.config.get("wallet_name") or defaults.wallet.name,
+                )
             hotkey_or_ss58 = Prompt.ask(
-                "Enter the [blue]hotkey[/blue] name or [blue]ss58 address[/blue] to stake to",
+                "Enter the [blue]hotkey[/blue] name or [blue]ss58 address[/blue] to unstake from [dim](or Press Enter to view existing staked hotkeys)[/dim]",
             )
-            if is_valid_ss58_address(hotkey_or_ss58):
+            if hotkey_or_ss58 == "":
+                wallet = self.wallet_ask(
+                    wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
+                )
+                interactive = True
+            elif is_valid_ss58_address(hotkey_or_ss58):
                 hotkey_ss58_address = hotkey_or_ss58
                 wallet = self.wallet_ask(
-                    wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME]
+                    wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
                 )
             else:
                 wallet_hotkey = hotkey_or_ss58
@@ -3364,214 +3196,478 @@ class CLIManager:
                     wallet_name,
                     wallet_path,
                     wallet_hotkey,
-                    ask_for=[WO.NAME, WO.HOTKEY],
+                    ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
                     validate=WV.WALLET_AND_HOTKEY,
                 )
 
-        elif all_hotkeys or include_hotkeys or exclude_hotkeys or hotkey_ss58_address:
+        elif unstake_all or unstake_all_alpha:
+            if not wallet_name:
+                wallet_name = Prompt.ask(
+                    "Enter the [blue]wallet name[/blue]",
+                    default=self.config.get("wallet_name") or defaults.wallet.name,
+                )
+            if include_hotkeys:
+                if len(include_hotkeys) > 1:
+                    print_error("Cannot unstake_all from multiple hotkeys at once.")
+                    raise typer.Exit()
+                elif is_valid_ss58_address(include_hotkeys[0]):
+                    hotkey_ss58_address = include_hotkeys[0]
+                else:
+                    print_error("Invalid hotkey ss58 address.")
+                    raise typer.Exit()
+            else:
+                hotkey_or_ss58 = Prompt.ask(
+                    "Enter the [blue]hotkey[/blue] name or [blue]ss58 address[/blue] to unstake all from",
+                    default=self.config.get("wallet_hotkey") or defaults.wallet.hotkey,
+                )
+                if is_valid_ss58_address(hotkey_or_ss58):
+                    hotkey_ss58_address = hotkey_or_ss58
+                    wallet = self.wallet_ask(
+                        wallet_name,
+                        wallet_path,
+                        wallet_hotkey,
+                        ask_for=[WO.NAME, WO.PATH],
+                    )
+                else:
+                    wallet_hotkey = hotkey_or_ss58
+                    wallet = self.wallet_ask(
+                        wallet_name,
+                        wallet_path,
+                        wallet_hotkey,
+                        ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
+                        validate=WV.WALLET_AND_HOTKEY,
+                    )
+            return self._run_command(
+                remove_stake.unstake_all(
+                    wallet=wallet,
+                    subtensor=self.initialize_chain(network),
+                    hotkey_ss58_address=hotkey_ss58_address,
+                    unstake_all_alpha=unstake_all_alpha,
+                    prompt=prompt,
+                )
+            )
+        elif (
+            all_hotkeys
+            or include_hotkeys
+            or exclude_hotkeys
+            or hotkey_ss58_address
+            or interactive
+            or unstake_all
+            or unstake_all_alpha
+        ):
             wallet = self.wallet_ask(
-                wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME]
+                wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
             )
         else:
             wallet = self.wallet_ask(
                 wallet_name,
                 wallet_path,
                 wallet_hotkey,
-                ask_for=[WO.NAME, WO.HOTKEY],
+                ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
                 validate=WV.WALLET_AND_HOTKEY,
             )
 
         if include_hotkeys:
-            included_hotkeys = parse_to_list(
+            include_hotkeys = parse_to_list(
                 include_hotkeys,
                 str,
-                "Hotkeys must be a comma-separated list of ss58s or hotkey names, e.g., "
-                "`--include-hotkeys 5Grw....,5Grw....`.",
+                "Hotkeys must be a comma-separated list of ss58s or names, e.g., `--include-hotkeys hk1,hk2`.",
+                is_ss58=False,
             )
-        else:
-            included_hotkeys = []
 
         if exclude_hotkeys:
-            excluded_hotkeys = parse_to_list(
+            exclude_hotkeys = parse_to_list(
                 exclude_hotkeys,
                 str,
-                "Hotkeys must be a comma-separated list of ss58s or hotkey names, e.g., "
-                "`--exclude-hotkeys 5Grw....,5Grw....`.",
+                "Hotkeys must be a comma-separated list of ss58s or names, e.g., `--exclude-hotkeys hk3,hk4`.",
+                is_ss58=False,
             )
-        else:
-            excluded_hotkeys = []
 
         return self._run_command(
-            stake.stake_add(
-                wallet,
-                self.initialize_chain(network),
-                amount,
-                stake_all,
-                max_stake,
-                included_hotkeys,
-                excluded_hotkeys,
-                all_hotkeys,
-                prompt,
-                hotkey_ss58_address,
+            remove_stake.unstake(
+                wallet=wallet,
+                subtensor=self.initialize_chain(network),
+                hotkey_ss58_address=hotkey_ss58_address,
+                all_hotkeys=all_hotkeys,
+                include_hotkeys=include_hotkeys,
+                exclude_hotkeys=exclude_hotkeys,
+                amount=amount,
+                prompt=prompt,
+                interactive=interactive,
+                netuid=netuid,
+                safe_staking=safe_staking,
+                rate_tolerance=rate_tolerance,
+                allow_partial_stake=allow_partial_stake,
             )
         )
 
-    def stake_remove(
+    def stake_move(
         self,
         network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        wallet_hotkey: str = Options.wallet_hotkey,
-        unstake_all: bool = typer.Option(
-            False,
-            "--unstake-all",
-            "--all",
-            help="When set, this commmand unstakes all staked TAO from the specified hotkeys.",
-        ),
-        amount: float = typer.Option(
-            0.0, "--amount", "-a", help="The amount of TAO to unstake."
+        wallet_name=Options.wallet_name,
+        wallet_path=Options.wallet_path,
+        wallet_hotkey=Options.wallet_hotkey,
+        origin_netuid: Optional[int] = typer.Option(
+            None, "--origin-netuid", help="Origin netuid"
         ),
-        hotkey_ss58_address: str = typer.Option(
-            "",
-            help="The ss58 address of the hotkey to unstake from.",
-        ),
-        keep_stake: float = typer.Option(
-            0.0,
-            "--keep-stake",
-            "--keep",
-            help="Sets the maximum amount of TAO to remain staked in each hotkey.",
+        destination_netuid: Optional[int] = typer.Option(
+            None, "--dest-netuid", help="Destination netuid"
         ),
-        include_hotkeys: str = typer.Option(
-            "",
-            "--include-hotkeys",
-            "-in",
-            help="Specifies the hotkeys by name or ss58 address to unstake from. For example, `-in hk1,hk2`",
+        destination_hotkey: Optional[str] = typer.Option(
+            None, "--dest-ss58", "--dest", help="Destination hotkey", prompt=False
         ),
-        exclude_hotkeys: str = typer.Option(
-            "",
-            "--exclude-hotkeys",
-            "-ex",
-            help="Specifies the hotkeys by name or ss58 address not to unstake from (only use with `--all-hotkeys`)"
-            " i.e. `--all-hotkeys -ex hk3,hk4`",
+        amount: float = typer.Option(
+            None,
+            "--amount",
+            help="The amount of TAO to stake",
+            prompt=False,
         ),
-        all_hotkeys: bool = typer.Option(
-            False,
-            help="When set, this command unstakes from all the hotkeys associated with the wallet. Do not use if specifying "
-            "hotkeys in `--include-hotkeys`.",
+        stake_all: bool = typer.Option(
+            False, "--stake-all", "--all", help="Stake all", prompt=False
         ),
         prompt: bool = Options.prompt,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
     ):
         """
-        Unstake TAO from one or more hotkeys and transfer them back to the user's coldkey.
+        Move staked TAO between hotkeys while keeping the same coldkey ownership.
 
-        This command is used to withdraw TAO previously staked to different hotkeys.
+        This command allows you to:
+        - Move stake from one hotkey to another hotkey
+        - Move stake between different subnets
+        - Keep the same coldkey ownership
 
-        EXAMPLE
+        You can specify:
+        - The origin subnet (--origin-netuid)
+        - The destination subnet (--dest-netuid)
+        - The destination hotkey (--dest-hotkey)
+        - The amount to move (--amount)
 
-        [green]$[/green] btcli stake remove --amount 100 -in hk1,hk2
+        If no arguments are provided, an interactive selection menu will be shown.
 
-        [blue bold]Note[/blue bold]: This command is for users who wish to reallocate their stake or withdraw them from the network. It allows for flexible management of TAO stake across different neurons (hotkeys) on the network.
-        """
-        self.verbosity_handler(quiet, verbose)
+        EXAMPLE
 
-        if all_hotkeys and include_hotkeys:
-            err_console.print(
-                "You have specified hotkeys to include and also the `--all-hotkeys` flag. The flag"
-                "should only be used standalone (to use all hotkeys) or with `--exclude-hotkeys`."
+        [green]$[/green] btcli stake move
+        """
+        console.print(
+            "[dim]This command moves stake from one hotkey to another hotkey while keeping the same coldkey.[/dim]"
+        )
+        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]"
             )
-            raise typer.Exit()
+            if is_valid_ss58_address(dest_wallet_or_ss58):
+                destination_hotkey = dest_wallet_or_ss58
+            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,
+                )
+                destination_hotkey = destination_wallet.hotkey.ss58_address
+        else:
+            if is_valid_ss58_address(destination_hotkey):
+                destination_hotkey = destination_hotkey
+            else:
+                print_error(
+                    "Invalid destination hotkey ss58 address. Please enter a valid ss58 address or wallet name."
+                )
+                raise typer.Exit()
 
-        if include_hotkeys and exclude_hotkeys:
-            err_console.print(
-                "You have specified both including and excluding hotkeys options. Select one or the other."
+        if not wallet_name:
+            wallet_name = Prompt.ask(
+                "Enter the [blue]origin wallet name[/blue]",
+                default=self.config.get("wallet_name") or defaults.wallet.name,
             )
-            raise typer.Exit()
+        wallet = self.wallet_ask(
+            wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
+        )
 
-        if unstake_all and amount:
-            err_console.print(
-                "Cannot specify both a specific amount and 'unstake-all'. Choose one or the other."
+        interactive_selection = False
+        if not wallet_hotkey:
+            origin_hotkey = Prompt.ask(
+                "Enter the [blue]origin hotkey[/blue] name or "
+                "[blue]ss58 address[/blue] where the stake will be moved from "
+                "[dim](or Press Enter to view existing stakes)[/dim]"
             )
-            raise typer.Exit()
-
-        if not unstake_all and not amount and not keep_stake:
-            amount = FloatPrompt.ask("Amount to [blue]unstake (TAO τ)[/blue]")
+            if origin_hotkey == "":
+                interactive_selection = True
 
-        if unstake_all and not amount and prompt:
-            if not Confirm.ask("Unstake all staked TAO tokens?", default=False):
-                raise typer.Exit()
-
-        if (
-            not wallet_hotkey
-            and not hotkey_ss58_address
-            and not all_hotkeys
-            and not include_hotkeys
-        ):
-            hotkey_or_ss58 = Prompt.ask(
-                "Enter the [blue]hotkey[/blue] name or [blue]ss58 address[/blue] to unstake from"
-            )
-            if is_valid_ss58_address(hotkey_or_ss58):
-                hotkey_ss58_address = hotkey_or_ss58
+            elif is_valid_ss58_address(origin_hotkey):
+                origin_hotkey = origin_hotkey
+            else:
                 wallet = self.wallet_ask(
-                    wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME]
+                    wallet_name,
+                    wallet_path,
+                    origin_hotkey,
+                    ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
+                    validate=WV.WALLET_AND_HOTKEY,
                 )
+                origin_hotkey = wallet.hotkey.ss58_address
+        else:
+            if is_valid_ss58_address(wallet_hotkey):
+                origin_hotkey = wallet_hotkey
             else:
-                wallet_hotkey = hotkey_or_ss58
                 wallet = self.wallet_ask(
                     wallet_name,
                     wallet_path,
                     wallet_hotkey,
-                    ask_for=[WO.NAME, WO.HOTKEY],
+                    ask_for=[],
                     validate=WV.WALLET_AND_HOTKEY,
                 )
+                origin_hotkey = wallet.hotkey.ss58_address
 
-        elif all_hotkeys or include_hotkeys or exclude_hotkeys or hotkey_ss58_address:
-            wallet = self.wallet_ask(
-                wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME]
+        if not interactive_selection:
+            if origin_netuid is None:
+                origin_netuid = IntPrompt.ask(
+                    "Enter the [blue]origin subnet[/blue] (netuid) to move stake from"
+                )
+
+            if destination_netuid is None:
+                destination_netuid = IntPrompt.ask(
+                    "Enter the [blue]destination subnet[/blue] (netuid) to move stake to"
+                )
+
+        return self._run_command(
+            move_stake.move_stake(
+                subtensor=self.initialize_chain(network),
+                wallet=wallet,
+                origin_netuid=origin_netuid,
+                origin_hotkey=origin_hotkey,
+                destination_netuid=destination_netuid,
+                destination_hotkey=destination_hotkey,
+                amount=amount,
+                stake_all=stake_all,
+                interactive_selection=interactive_selection,
+                prompt=prompt,
+            )
+        )
+
+    def stake_transfer(
+        self,
+        network: Optional[list[str]] = Options.network,
+        wallet_name: Optional[str] = Options.wallet_name,
+        wallet_path: Optional[str] = Options.wallet_path,
+        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
+        origin_netuid: Optional[int] = typer.Option(
+            None,
+            "--origin-netuid",
+            help="The netuid to transfer stake from",
+        ),
+        dest_netuid: Optional[int] = typer.Option(
+            None,
+            "--dest-netuid",
+            help="The netuid to transfer stake to",
+        ),
+        dest_ss58: Optional[str] = typer.Option(
+            None,
+            "--dest-ss58",
+            "--dest",
+            "--dest-coldkey",
+            help="The destination wallet name or SS58 address to transfer stake to",
+        ),
+        amount: float = typer.Option(
+            None,
+            "--amount",
+            "-a",
+            help="Amount of stake to transfer",
+        ),
+        prompt: bool = Options.prompt,
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+    ):
+        """
+        Transfer stake between coldkeys while keeping the same hotkey ownership.
+
+        This command allows you to:
+        - Transfer stake from one coldkey to another coldkey
+        - Keep the same hotkey ownership
+        - Transfer stake between different subnets
+
+        You can specify:
+        - The origin subnet (--origin-netuid)
+        - The destination subnet (--dest-netuid)
+        - The destination wallet/address (--dest)
+        - The amount to transfer (--amount)
+
+        If no arguments are provided, an interactive selection menu will be shown.
+
+        EXAMPLE
+
+        Transfer 100 TAO from subnet 1 to subnet 2:
+        [green]$[/green] btcli stake transfer --origin-netuid 1 --dest-netuid 2 --dest wallet2 --amount 100
+
+        Using SS58 address:
+        [green]$[/green] btcli stake transfer --origin-netuid 1 --dest-netuid 2 --dest 5FrLxJsyJ5x9n2rmxFwosFraxFCKcXZDngEP9H7qjkKgHLcK --amount 100
+        """
+        console.print(
+            "[dim]This command transfers stake from one coldkey to another while keeping the same hotkey.[/dim]"
+        )
+        self.verbosity_handler(quiet, verbose)
+
+        wallet = self.wallet_ask(
+            wallet_name,
+            wallet_path,
+            wallet_hotkey,
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
+            validate=WV.WALLET_AND_HOTKEY,
+        )
+
+        if not dest_ss58:
+            dest_ss58 = Prompt.ask(
+                "Enter the [blue]destination wallet name[/blue] or [blue]coldkey SS58 address[/blue]"
             )
 
+        if is_valid_ss58_address(dest_ss58):
+            dest_ss58 = dest_ss58
         else:
-            wallet = self.wallet_ask(
-                wallet_name,
+            dest_wallet = self.wallet_ask(
+                dest_ss58,
                 wallet_path,
-                wallet_hotkey,
-                ask_for=[WO.NAME, WO.HOTKEY],
-                validate=WV.WALLET_AND_HOTKEY,
+                None,
+                ask_for=[WO.NAME, WO.PATH],
+                validate=WV.WALLET,
             )
+            dest_ss58 = dest_wallet.coldkeypub.ss58_address
 
-        if include_hotkeys:
-            included_hotkeys = parse_to_list(
-                include_hotkeys,
-                str,
-                "Hotkeys must be a comma-separated list of ss58s or hotkey names, e.g., "
-                "`--include-hotkeys 5Grw....,5Grw....`.",
-            )
+        interactive_selection = False
+        if origin_netuid is None and dest_netuid is None and not amount:
+            interactive_selection = True
         else:
-            included_hotkeys = []
+            if origin_netuid is None:
+                origin_netuid = IntPrompt.ask(
+                    "Enter the [blue]origin subnet[/blue] (netuid)"
+                )
+            if not amount:
+                amount = FloatPrompt.ask("Enter the [blue]amount[/blue] to transfer")
 
-        if exclude_hotkeys:
-            excluded_hotkeys = parse_to_list(
-                exclude_hotkeys,
-                str,
-                "Hotkeys must be a comma-separated list of ss58s or hotkey names, e.g., "
-                "`--exclude-hotkeys 5Grw....,5Grw....`.",
+            if dest_netuid is None:
+                dest_netuid = IntPrompt.ask(
+                    "Enter the [blue]destination subnet[/blue] (netuid)"
+                )
+
+        return self._run_command(
+            move_stake.transfer_stake(
+                wallet=wallet,
+                subtensor=self.initialize_chain(network),
+                origin_netuid=origin_netuid,
+                dest_netuid=dest_netuid,
+                dest_coldkey_ss58=dest_ss58,
+                amount=amount,
+                interactive_selection=interactive_selection,
+                prompt=prompt,
             )
+        )
+
+    def stake_swap(
+        self,
+        network: Optional[list[str]] = Options.network,
+        wallet_name: Optional[str] = Options.wallet_name,
+        wallet_path: Optional[str] = Options.wallet_path,
+        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
+        origin_netuid: Optional[int] = typer.Option(
+            None,
+            "--origin-netuid",
+            "-o",
+            "--origin",
+            help="The netuid to swap stake from",
+        ),
+        dest_netuid: Optional[int] = typer.Option(
+            None,
+            "--dest-netuid",
+            "-d",
+            "--dest",
+            help="The netuid to swap stake to",
+        ),
+        amount: float = typer.Option(
+            None,
+            "--amount",
+            "-a",
+            help="Amount of stake to swap",
+        ),
+        swap_all: bool = typer.Option(
+            False,
+            "--swap-all",
+            "--all",
+            help="Swap all available stake",
+        ),
+        prompt: bool = Options.prompt,
+        wait_for_inclusion: bool = Options.wait_for_inclusion,
+        wait_for_finalization: bool = Options.wait_for_finalization,
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+    ):
+        """
+        Swap stake between different subnets while keeping the same coldkey-hotkey pair ownership.
+
+        This command allows you to:
+        - Move stake from one subnet to another subnet
+        - Keep the same coldkey ownership
+        - Keep the same hotkey ownership
+
+        You can specify:
+        - The origin subnet (--origin-netuid)
+        - The destination subnet (--dest-netuid)
+        - The amount to swap (--amount)
+
+        If no arguments are provided, an interactive selection menu will be shown.
+
+        EXAMPLE
+
+        Swap 100 TAO from subnet 1 to subnet 2:
+        [green]$[/green] btcli stake swap --wallet-name default --wallet-hotkey default --origin-netuid 1 --dest-netuid 2 --amount 100
+        """
+        console.print(
+            "[dim]This command moves stake from one subnet to another subnet while keeping the same coldkey-hotkey pair.[/dim]"
+        )
+        self.verbosity_handler(quiet, verbose)
+
+        wallet = self.wallet_ask(
+            wallet_name,
+            wallet_path,
+            wallet_hotkey,
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
+            validate=WV.WALLET_AND_HOTKEY,
+        )
+
+        interactive_selection = False
+        if origin_netuid is None and dest_netuid is None and not amount:
+            interactive_selection = True
         else:
-            excluded_hotkeys = []
+            if origin_netuid is None:
+                origin_netuid = IntPrompt.ask(
+                    "Enter the [blue]origin subnet[/blue] (netuid)"
+                )
+            if dest_netuid is None:
+                dest_netuid = IntPrompt.ask(
+                    "Enter the [blue]destination subnet[/blue] (netuid)"
+                )
+            if not amount and not swap_all:
+                amount = FloatPrompt.ask("Enter the [blue]amount[/blue] to swap")
 
         return self._run_command(
-            stake.unstake(
-                wallet,
-                self.initialize_chain(network),
-                hotkey_ss58_address,
-                all_hotkeys,
-                included_hotkeys,
-                excluded_hotkeys,
-                amount,
-                keep_stake,
-                unstake_all,
-                prompt,
+            move_stake.swap_stake(
+                wallet=wallet,
+                subtensor=self.initialize_chain(network),
+                origin_netuid=origin_netuid,
+                destination_netuid=dest_netuid,
+                amount=amount,
+                swap_all=swap_all,
+                interactive_selection=interactive_selection,
+                prompt=prompt,
+                wait_for_inclusion=wait_for_inclusion,
+                wait_for_finalization=wait_for_finalization,
             )
         )
 
@@ -3611,7 +3707,7 @@ class CLIManager:
             wallet_name,
             wallet_path,
             wallet_hotkey,
-            ask_for=[WO.NAME, WO.HOTKEY],
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
             validate=WV.WALLET_AND_HOTKEY,
         )
 
@@ -3642,23 +3738,12 @@ class CLIManager:
         wallet_hotkey: str = Options.wallet_hotkey,
         wallet_path: str = Options.wallet_path,
         network: Optional[list[str]] = Options.network,
-        netuid: Optional[int] = typer.Option(
-            None,
-            help="The netuid of the subnet, (e.g. 4)",
-            prompt=False,
-        ),
-        all_netuids: bool = typer.Option(
-            False,
-            "--all-netuids",
-            "--all",
-            "--allnetuids",
-            help="When this flag is used it sets child hotkeys on all subnets.",
-        ),
+        netuid: Optional[int] = Options.netuid_not_req,
+        all_netuids: bool = Options.all_netuids,
         proportions: list[float] = typer.Option(
             [],
             "--proportions",
             "--prop",
-            "-p",
             help="Enter the stake weight proportions for the child hotkeys (sum should be less than or equal to 1)",
             prompt=False,
         ),
@@ -3678,17 +3763,10 @@ class CLIManager:
         EXAMPLE
 
         [green]$[/green] btcli stake child set -c 5FCL3gmjtQV4xxxxuEPEFQVhyyyyqYgNwX7drFLw7MSdBnxP -c 5Hp5dxxxxtGg7pu8dN2btyyyyVA1vELmM9dy8KQv3LxV8PA7 --hotkey default --netuid 1 -p 0.3 -p 0.7
-        """
-        self.verbosity_handler(quiet, verbose)
-        if all_netuids and netuid:
-            err_console.print("Specify either a netuid or `--all`, not both.")
-            raise typer.Exit()
-        if all_netuids:
-            netuid = None
-        elif not netuid:
-            netuid = IntPrompt.ask(
-                "Enter a netuid (leave blank for all)", default=None, show_default=True
-            )
+        """
+        self.verbosity_handler(quiet, verbose)
+        netuid = get_optional_netuid(netuid, all_netuids)
+
         children = list_prompt(
             children,
             str,
@@ -3896,7 +3974,8 @@ class CLIManager:
 
         if not param_name or not param_value:
             hyperparams = self._run_command(
-                sudo.get_hyperparameters(self.initialize_chain(network), netuid)
+                sudo.get_hyperparameters(self.initialize_chain(network), netuid),
+                exit_early=False,
             )
             if not hyperparams:
                 raise typer.Exit()
@@ -3926,11 +4005,11 @@ class CLIManager:
 
         if not param_value:
             param_value = Prompt.ask(
-                f"Enter the new value for [dark_orange]{param_name}[/dark_orange] in the VALUE column format"
+                f"Enter the new value for [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{param_name}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] in the VALUE column format"
             )
 
         wallet = self.wallet_ask(
-            wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME]
+            wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
         )
         return self._run_command(
             sudo.sudo_set_hyperparameter(
@@ -3952,8 +4031,6 @@ class CLIManager:
         """
         Shows a list of the hyperparameters for the specified subnet.
 
-        The output of this command is the same as that of `btcli subnets hyperparameters`.
-
         EXAMPLE
 
         [green]$[/green] btcli sudo get --netuid 1
@@ -3963,98 +4040,448 @@ class CLIManager:
             sudo.get_hyperparameters(self.initialize_chain(network), netuid)
         )
 
-    def subnets_list(
+    def sudo_senate(
         self,
         network: Optional[list[str]] = Options.network,
-        reuse_last: bool = Options.reuse_last,
-        html_output: bool = Options.html_output,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
     ):
         """
-        List all subnets and their detailed information.
+        Shows the Senate members of the Bittensor's governance protocol.
+
+        This command lists the delegates involved in the decision-making process of the Bittensor network, showing their names and wallet addresses. This information is crucial for understanding who holds governance roles within the network.
+
+        EXAMPLE
+        [green]$[/green] btcli sudo senate
+        """
+        self.verbosity_handler(quiet, verbose)
+        return self._run_command(sudo.get_senate(self.initialize_chain(network)))
 
-        This command displays a table with the below columns:
+    def sudo_proposals(
+        self,
+        network: Optional[list[str]] = Options.network,
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+    ):
+        """
+        View active proposals for the senate in the Bittensor's governance protocol.
 
-        - NETUID: The subnet's netuid.
-        - N: The number of neurons (subnet validators and subnet miners) in the subnet.
-        - MAX_N: The maximum allowed number of neurons in the subnet.
-        - EMISSION: The percentage of emissions to the subnet as of the last tempo.
-        - TEMPO: The subnet's tempo, expressed in number of blocks.
-        - RECYCLE: The recycle register cost for this subnet.
-        - POW: The proof of work (PoW) difficulty.
-        - SUDO: The subnet owner's name or the owner's ss58 address.
+        This command displays the details of ongoing proposals, including proposal hashes, votes, thresholds, and proposal data.
 
         EXAMPLE
+        [green]$[/green] btcli sudo proposals
+        """
+        self.verbosity_handler(quiet, verbose)
+        return self._run_command(
+            sudo.proposals(self.initialize_chain(network), verbose)
+        )
 
-        [green]$[/green] btcli subnets list
+    def sudo_senate_vote(
+        self,
+        network: Optional[list[str]] = Options.network,
+        wallet_name: Optional[str] = Options.wallet_name,
+        wallet_path: Optional[str] = Options.wallet_path,
+        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
+        proposal: str = typer.Option(
+            None,
+            "--proposal",
+            "--proposal-hash",
+            prompt="Enter the proposal hash",
+            help="The hash of the proposal to vote on.",
+        ),
+        prompt: bool = Options.prompt,
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+        vote: bool = typer.Option(
+            None,
+            "--vote-aye/--vote-nay",
+            prompt="Enter y to vote Aye, or enter n to vote Nay",
+            help="The vote casted on the proposal",
+        ),
+    ):
+        """
+        Cast a vote on an active proposal in Bittensor's governance protocol.
+
+        This command is used by Senate members to vote on various proposals that shape the network's future. Use `btcli sudo proposals` to see the active proposals and their hashes.
+
+        USAGE
+        The user must specify the hash of the proposal they want to vote on. The command then allows the Senate member to cast a 'Yes' or 'No' vote, contributing to the decision-making process on the proposal. This command is crucial for Senate members to exercise their voting rights on key proposals. It plays a vital role in the governance and evolution of the Bittensor network.
+
+        EXAMPLE
+        [green]$[/green] btcli sudo senate_vote --proposal <proposal_hash>
         """
         self.verbosity_handler(quiet, verbose)
-        if (reuse_last or html_output) and self.config.get("use_cache") is False:
-            err_console.print(
-                "Unable to use `--reuse-last` or `--html` when config 'no-cache' is set to 'True'. "
-                "Change the config to 'False' using `btcli config set`."
+        wallet = self.wallet_ask(
+            wallet_name,
+            wallet_path,
+            wallet_hotkey,
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
+            validate=WV.WALLET_AND_HOTKEY,
+        )
+        return self._run_command(
+            sudo.senate_vote(
+                wallet, self.initialize_chain(network), proposal, vote, prompt
+            )
+        )
+
+    def sudo_set_take(
+        self,
+        network: Optional[list[str]] = Options.network,
+        wallet_name: Optional[str] = Options.wallet_name,
+        wallet_path: Optional[str] = Options.wallet_path,
+        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
+        take: float = typer.Option(None, help="The new take value."),
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+    ):
+        """
+        Allows users to change their delegate take percentage.
+
+        This command can be used to update the delegate takes. To run the command, the user must have a configured wallet with both hotkey and coldkey.
+        The command makes sure the new take value is within 0-18% range.
+
+        EXAMPLE
+        [green]$[/green] btcli sudo set-take --wallet-name my_wallet --wallet-hotkey my_hotkey
+        """
+        max_value = 0.18
+        min_value = 0.00
+        self.verbosity_handler(quiet, verbose)
+
+        wallet = self.wallet_ask(
+            wallet_name,
+            wallet_path,
+            wallet_hotkey,
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
+            validate=WV.WALLET_AND_HOTKEY,
+        )
+
+        self._run_command(
+            sudo.display_current_take(self.initialize_chain(network), wallet),
+            exit_early=False,
+        )
+
+        if not take:
+            take = FloatPrompt.ask(
+                f"Enter [blue]take value[/blue] (0.18 for 18%) [blue]Min: {min_value} Max: {max_value}"
+            )
+        if not (min_value <= take <= max_value):
+            print_error(
+                f"Take value must be between {min_value} and {max_value}. Provided value: {take}"
             )
             raise typer.Exit()
-        if reuse_last:
-            subtensor = None
-        else:
-            subtensor = self.initialize_chain(network)
+
+        return self._run_command(
+            sudo.set_take(wallet, self.initialize_chain(network), take)
+        )
+
+    def sudo_get_take(
+        self,
+        network: Optional[list[str]] = Options.network,
+        wallet_name: Optional[str] = Options.wallet_name,
+        wallet_path: Optional[str] = Options.wallet_path,
+        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+    ):
+        """
+        Allows users to check their delegate take percentage.
+
+        This command can be used to fetch the delegate take of your hotkey.
+
+        EXAMPLE
+        [green]$[/green] btcli sudo get-take --wallet-name my_wallet --wallet-hotkey my_hotkey
+        """
+        self.verbosity_handler(quiet, verbose)
+
+        wallet = self.wallet_ask(
+            wallet_name,
+            wallet_path,
+            wallet_hotkey,
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
+            validate=WV.WALLET_AND_HOTKEY,
+        )
+
+        self._run_command(
+            sudo.display_current_take(self.initialize_chain(network), wallet)
+        )
+
+    def subnets_list(
+        self,
+        network: Optional[list[str]] = Options.network,
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+        live_mode: bool = Options.live,
+    ):
+        """
+         List all subnets and their detailed information.
+
+         [bold]Common Examples:[/bold]
+
+         1. List all subnets:
+         [green]$[/green] btcli subnets list
+
+         2. List all subnets in live mode:
+         [green]$[/green] btcli subnets list --live
+
+        [bold]Output Columns:[/bold]
+         • [white]Netuid[/white] - Subnet identifier number
+         • [white]Name[/white] - Subnet name with currency symbol (τ/α/β etc)
+         • [white]Price (τ_in/α_in)[/white] - Exchange rate (TAO per alpha token)
+         • [white]Market Cap (α * Price)[/white] - Total value in TAO (alpha tokens × price)
+         • [white]Emission (τ)[/white] - TAO rewards emitted per block to subnet
+         • [white]P (τ_in, α_in)[/white] - Pool reserves (Tao reserves, alpha reserves) in liquidity pool
+         • [white]Stake (α_out)[/white] - Total staked alpha tokens across all hotkeys (alpha outstanding)
+         • [white]Supply (α)[/white] - Circulating alpha token supply
+         • [white]Tempo (k/n)[/white] - Block interval for subnet updates
+
+         EXAMPLE
+
+         [green]$[/green] btcli subnets list
+        """
+        self.verbosity_handler(quiet, verbose)
+        subtensor = self.initialize_chain(network)
         return self._run_command(
             subnets.subnets_list(
                 subtensor,
-                reuse_last,
-                html_output,
+                False,  # reuse-last
+                False,  # html-output
                 not self.config.get("use_cache", True),
+                verbose,
+                live_mode,
+            )
+        )
+
+    def subnets_price(
+        self,
+        network: Optional[list[str]] = Options.network,
+        netuids: str = typer.Option(
+            None,
+            "--netuids",
+            "--netuid",
+            "-n",
+            help="Netuid(s) to show the price for.",
+        ),
+        interval_hours: int = typer.Option(
+            24,
+            "--interval-hours",
+            "--interval",
+            help="The number of hours to show the historical price for.",
+        ),
+        all_netuids: bool = typer.Option(
+            False,
+            "--all-netuids",
+            "--all",
+            help="Show the price for all subnets.",
+        ),
+        log_scale: bool = typer.Option(
+            False,
+            "--log-scale",
+            "--log",
+            help="Show the price in log scale.",
+        ),
+        html_output: bool = Options.html_output,
+    ):
+        """
+        Shows the historical price of a subnet for the past 24 hours.
+
+        This command displays the historical price of a subnet for the past 24 hours.
+        If the `--all` flag is used, the command will display the price for all subnets in html format.
+        If the `--html` flag is used, the command will display the price in an HTML chart.
+        If the `--log-scale` flag is used, the command will display the price in log scale.
+        If no html flag is used, the command will display the price in the cli.
+
+        EXAMPLE
+
+        [green]$[/green] btcli subnets price --netuid 1
+        [green]$[/green] btcli subnets price --netuid 1 --html --log
+        [green]$[/green] btcli subnets price --all --html
+        [green]$[/green] btcli subnets price --netuids 1,2,3,4 --html
+        """
+        if netuids:
+            netuids = parse_to_list(
+                netuids,
+                int,
+                "Netuids must be a comma-separated list of ints, e.g., `--netuids 1,2,3,4`.",
+            )
+        if all_netuids and netuids:
+            print_error("Cannot specify both --netuid and --all-netuids")
+            raise typer.Exit()
+
+        if not netuids and not all_netuids:
+            netuids = Prompt.ask(
+                "Enter the [blue]netuid(s)[/blue] to view the price of in comma-separated format [dim](or Press Enter to view all subnets)[/dim]",
+            )
+            if not netuids:
+                all_netuids = True
+                html_output = True
+            else:
+                netuids = parse_to_list(
+                    netuids,
+                    int,
+                    "Netuids must be a comma-separated list of ints, e.g., `--netuids 1,2,3,4`.",
+                )
+
+        if all_netuids:
+            html_output = True
+
+        if html_output and is_linux():
+            print_linux_dependency_message()
+
+        return self._run_command(
+            price.price(
+                self.initialize_chain(network),
+                netuids,
+                all_netuids,
+                interval_hours,
+                html_output,
+                log_scale,
+            )
+        )
+
+    def subnets_show(
+        self,
+        network: Optional[list[str]] = Options.network,
+        netuid: int = Options.netuid,
+        sort: bool = typer.Option(
+            False,
+            "--sort",
+            help="Sort the subnets by uid.",
+        ),
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+        prompt: bool = Options.prompt,
+    ):
+        """
+        Displays detailed information about a subnet including participants and their state.
+
+        EXAMPLE
+
+        [green]$[/green] btcli subnets list
+        """
+        self.verbosity_handler(quiet, verbose)
+        subtensor = self.initialize_chain(network)
+        return self._run_command(
+            subnets.show(
+                subtensor=subtensor,
+                netuid=netuid,
+                sort=sort,
+                max_rows=None,
+                delegate_selection=False,
+                verbose=verbose,
+                prompt=prompt,
             )
         )
 
-    def subnets_lock_cost(
+    def subnets_burn_cost(
         self,
         network: Optional[list[str]] = Options.network,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
     ):
         """
-        Shows the required amount of TAO to be locked for creating a new subnet, i.e., cost of registering a new subnet.
+        Shows the required amount of TAO to be recycled for creating a new subnet, i.e., cost of registering a new subnet.
 
         The current implementation anneals the cost of creating a subnet over a period of two days. If the displayed cost is unappealing to you, check back in a day or two to see if it has decreased to a more affordable level.
 
         EXAMPLE
 
-        [green]$[/green] btcli subnets lock_cost
+        [green]$[/green] btcli subnets burn_cost
         """
         self.verbosity_handler(quiet, verbose)
-        return self._run_command(subnets.lock_cost(self.initialize_chain(network)))
+        return self._run_command(subnets.burn_cost(self.initialize_chain(network)))
 
     def subnets_create(
         self,
         wallet_name: str = Options.wallet_name,
         wallet_path: str = Options.wallet_path,
+        wallet_hotkey: str = Options.wallet_hotkey,
         network: Optional[list[str]] = Options.network,
+        subnet_name: Optional[str] = typer.Option(
+            None, "--subnet-name", "--name", help="Name of the subnet"
+        ),
+        github_repo: Optional[str] = typer.Option(
+            None, "--github-repo", "--repo", help="GitHub repository URL"
+        ),
+        subnet_contact: Optional[str] = typer.Option(
+            None,
+            "--subnet-contact",
+            "--contact",
+            "--email",
+            help="Contact email for subnet",
+        ),
+        subnet_url: Optional[str] = typer.Option(
+            None, "--subnet-url", "--url", help="Subnet URL"
+        ),
+        discord: Optional[str] = typer.Option(
+            None, "--discord-handle", "--discord", help="Discord handle"
+        ),
+        description: Optional[str] = typer.Option(
+            None, "--description", help="Description"
+        ),
+        additional_info: Optional[str] = typer.Option(
+            None, "--additional-info", help="Additional information"
+        ),
         prompt: bool = Options.prompt,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
     ):
         """
-        Registers a new subnet.
+        Registers a new subnet on the network.
 
-        EXAMPLE
+        This command allows you to create a new subnet and set the subnet's identity.
+        You also have the option to set your own identity after the registration is complete.
+
+        [bold]Common Examples:[/bold]
 
+        1. Interactive subnet creation:
         [green]$[/green] btcli subnets create
+
+        2. Create with GitHub repo and contact email:
+        [green]$[/green] btcli subnets create --subnet-name MySubnet --github-repo https://github.com/myorg/mysubnet --subnet-contact team@mysubnet.net
         """
         self.verbosity_handler(quiet, verbose)
         wallet = self.wallet_ask(
             wallet_name,
             wallet_path,
-            None,
-            ask_for=[WO.NAME],
-            validate=WV.WALLET,
+            wallet_hotkey,
+            ask_for=[
+                WO.NAME,
+                WO.HOTKEY,
+                WO.PATH,
+            ],
+            validate=WV.WALLET_AND_HOTKEY,
         )
-        return self._run_command(
-            subnets.create(wallet, self.initialize_chain(network), prompt)
+        identity = prompt_for_subnet_identity(
+            subnet_name=subnet_name,
+            github_repo=github_repo,
+            subnet_contact=subnet_contact,
+            subnet_url=subnet_url,
+            discord=discord,
+            description=description,
+            additional=additional_info,
+        )
+        success = self._run_command(
+            subnets.create(wallet, self.initialize_chain(network), identity, prompt),
+            exit_early=False,
         )
 
+        if success and prompt:
+            set_id = Confirm.ask(
+                "[dark_sea_green3]Do you want to set/update your identity?",
+                default=False,
+                show_default=True,
+            )
+            if set_id:
+                self.wallet_set_id(
+                    wallet_name=wallet.name,
+                    wallet_hotkey=wallet.hotkey,
+                    wallet_path=wallet.path,
+                    network=network,
+                    prompt=prompt,
+                    quiet=quiet,
+                    verbose=verbose,
+                )
+
     def subnets_pow_register(
         self,
         wallet_name: Optional[str] = Options.wallet_name,
@@ -4128,7 +4555,7 @@ class CLIManager:
                     wallet_name,
                     wallet_path,
                     wallet_hotkey,
-                    ask_for=[WO.NAME, WO.HOTKEY],
+                    ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
                     validate=WV.WALLET_AND_HOTKEY,
                 ),
                 self.initialize_chain(network),
@@ -4257,6 +4684,12 @@ class CLIManager:
             )
             raise typer.Exit()
 
+        # For Rao games
+        effective_network = get_effective_network(self.config, network)
+        if is_rao_network(effective_network):
+            print_error("This command is disabled on the 'rao' network.")
+            raise typer.Exit()
+
         if reuse_last:
             if netuid is not None:
                 console.print("Cannot specify netuid when using `--reuse-last`")
@@ -4359,7 +4792,7 @@ class CLIManager:
             wallet_name,
             wallet_path,
             wallet_hotkey,
-            ask_for=[WO.NAME, WO.HOTKEY],
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
             validate=WV.WALLET_AND_HOTKEY,
         )
 
@@ -4457,7 +4890,7 @@ class CLIManager:
             wallet_name,
             wallet_path,
             wallet_hotkey,
-            ask_for=[WO.NAME, WO.HOTKEY],
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
             validate=WV.WALLET_AND_HOTKEY,
         )
         return self._run_command(