bittensor-cli 8.4.2__py3-none-any.whl → 9.0.0rc1__py3-none-any.whl

bittensor_cli/cli.py

@@ -1,8 +1,6 @@
 #!/usr/bin/env python3
 import asyncio
-import binascii
 import curses
-from functools import partial
 import os.path
 import re
 import ssl
@@ -19,21 +17,22 @@ 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, stake, move
 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 +42,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,
 )
 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.2"
+__version__ = "9.0.0rc1"
 
 
 _core_version = re.match(r"^\d+\.\d+\.\d+", __version__).group(0)
@@ -127,6 +134,8 @@ class Options:
     use_password = typer.Option(
         True,
         help="Set this to `True` to protect the generated Bittensor key with a password.",
+        is_flag=True,
+        flag_value=False,
     )
     public_hex_key = typer.Option(None, help="The public key in hex format.")
     ss58_address = typer.Option(
@@ -162,6 +171,17 @@ class Options:
         None,
         help="The netuid of the subnet in the root network, (e.g. 1).",
         prompt=True,
+        callback=validate_netuid,
+    )
+    netuid_not_req = typer.Option(
+        None,
+        help="The netuid of the subnet in the root network, (e.g. 1).",
+        prompt=False,
+    )
+    all_netuids = typer.Option(
+        False,
+        help="Use all netuids",
+        prompt=False,
     )
     weights = typer.Option(
         None,
@@ -207,6 +227,17 @@ 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,
+    )
 
 
 def list_prompt(init_var: list, list_type: type, help_text: str) -> list:
@@ -249,7 +280,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(
@@ -269,6 +301,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
@@ -418,12 +476,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
@@ -434,7 +501,6 @@ 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)
@@ -448,7 +514,9 @@ class CLIManager:
             "use_cache": True,
             "metagraph_cols": {
                 "UID": True,
-                "STAKE": True,
+                "GLOBAL_STAKE": True,
+                "LOCAL_STAKE": True,
+                "STAKE_WEIGHT": True,
                 "RANK": True,
                 "TRUST": True,
                 "CONSENSUS": True,
@@ -476,7 +544,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)
@@ -506,15 +573,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,
@@ -563,7 +621,9 @@ 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)
@@ -600,16 +660,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"]
@@ -624,59 +689,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()
@@ -702,6 +733,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(
@@ -711,8 +757,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)
@@ -723,8 +769,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(
@@ -769,22 +821,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,
@@ -815,13 +894,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`
         """
@@ -837,7 +916,7 @@ 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 (
@@ -854,7 +933,12 @@ class CLIManager:
             finally:
                 if initiated is False:
                     asyncio.create_task(cmd).cancel()
-                    raise typer.Exit()
+                if exit_early is True:
+                    try:
+                        raise typer.Exit()
+                    except Exception as e:  # ensures we always exit cleanly
+                        if not isinstance(e, typer.Exit):
+                            err_console.print(f"An unknown error has occurred: {e}")
 
         if sys.version_info < (3, 10):
             # For Python 3.9 or lower
@@ -866,11 +950,21 @@ class CLIManager:
     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):
@@ -1178,39 +1272,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,
                 )
 
@@ -1218,7 +1289,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(
@@ -1226,8 +1297,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
@@ -1383,7 +1473,7 @@ class CLIManager:
                 "Netuids must be a comma-separated list of ints, e.g., `--netuids 1,2,3,4`.",
             )
 
-        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
@@ -1413,6 +1503,7 @@ class CLIManager:
                 include_hotkeys,
                 exclude_hotkeys,
                 netuids_filter=netuids,
+                verbose=verbose,
             )
         )
 
@@ -1430,12 +1521,9 @@ class CLIManager:
             None,
             "--amount",
             "-a",
-            prompt=False,
+            prompt=True,
             help="Amount (in TAO) to transfer.",
         ),
-        transfer_all: bool = typer.Option(
-            False, "--all", prompt=False, help="Transfer all available balance."
-        ),
         wallet_name: str = Options.wallet_name,
         wallet_path: str = Options.wallet_path,
         wallet_hotkey: str = Options.wallet_hotkey,
@@ -1471,25 +1559,20 @@ class CLIManager:
             wallet_name,
             wallet_path,
             wallet_hotkey,
-            ask_for=[WO.NAME],
+            ask_for=[WO.NAME, WO.PATH],
             validate=WV.WALLET,
         )
+
+        # For Rao games - temporarily commented out
+        # 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()
+
         subtensor = self.initialize_chain(network)
-        if transfer_all and amount:
-            print_error("Cannot specify an amount and '--all' flag.")
-            raise typer.Exit()
-        elif transfer_all:
-            amount = 0
-        elif not amount:
-            amount = FloatPrompt.ask("Enter amount (in TAO) to transfer.")
         return self._run_command(
             wallets.transfer(
-                wallet,
-                subtensor,
-                destination_ss58_address,
-                amount,
-                transfer_all,
-                prompt,
+                wallet, subtensor, destination_ss58_address, amount, prompt
             )
         )
 
@@ -1528,7 +1611,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:
@@ -1540,7 +1623,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)
@@ -1596,6 +1679,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:
@@ -1606,11 +1691,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(
@@ -1672,7 +1758,6 @@ class CLIManager:
             "--max-successes",
             help="Set the maximum number of times to successfully run the faucet for this command.",
         ),
-        prompt: bool = Options.prompt,
     ):
         """
         Obtain test TAO tokens by performing Proof of Work (PoW).
@@ -1696,7 +1781,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(
@@ -1711,7 +1796,6 @@ class CLIManager:
                 output_in_place,
                 verbose,
                 max_successes,
-                prompt,
             )
         )
 
@@ -1754,7 +1838,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)
@@ -1808,7 +1893,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)
 
@@ -1841,6 +1927,8 @@ class CLIManager:
         use_password: bool = typer.Option(
             False,  # Overriden to False
             help="Set to 'True' to protect the generated Bittensor key with a password.",
+            is_flag=True,
+            flag_value=True,
         ),
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
@@ -1897,7 +1985,10 @@ class CLIManager:
         use_password: bool = typer.Option(
             False,  # Overriden to False
             help="Set to 'True' to protect the generated Bittensor key with a password.",
+            is_flag=True,
+            flag_value=True,
         ),
+        uri: Optional[str] = Options.uri,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
     ):
@@ -1919,12 +2010,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(
@@ -1934,8 +2027,9 @@ class CLIManager:
             ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
             validate=WV.WALLET,
         )
-        n_words = get_n_words(n_words)
-        return self._run_command(wallets.new_hotkey(wallet, n_words, use_password))
+        if not uri:
+            n_words = get_n_words(n_words)
+        return self._run_command(wallets.new_hotkey(wallet, n_words, use_password, uri))
 
     def wallet_new_coldkey(
         self,
@@ -1949,6 +2043,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,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
     ):
@@ -1974,7 +2069,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(
@@ -1984,8 +2080,11 @@ class CLIManager:
             ask_for=[WO.NAME, WO.PATH],
             validate=WV.NONE,
         )
-        n_words = get_n_words(n_words)
-        return self._run_command(wallets.new_coldkey(wallet, n_words, use_password))
+        if not uri:
+            n_words = get_n_words(n_words)
+        return self._run_command(
+            wallets.new_coldkey(wallet, n_words, use_password, uri)
+        )
 
     def wallet_check_ck_swap(
         self,
@@ -2019,6 +2118,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,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
     ):
@@ -2042,12 +2142,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)
@@ -2058,12 +2159,14 @@ 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,
+                uri,
             )
         )
 
@@ -2108,8 +2211,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)
             ]
@@ -2119,20 +2232,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)
@@ -2158,19 +2296,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))
@@ -2181,69 +2323,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,
@@ -2271,94 +2386,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,
+                identity["name"],
+                identity["url"],
+                identity["image"],
+                identity["discord"],
+                identity["description"],
+                identity["additional"],
+                identity["github_repo"],
                 prompt,
-                subnet_netuid,
             )
         )
 
     def wallet_get_id(
         self,
-        target_ss58_address: str = typer.Option(
+        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,
@@ -2381,13 +2469,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(
@@ -2421,882 +2524,127 @@ 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).
-
-        USAGE
-
-        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).
-
-        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.
+        """List all stake accounts for wallet."""
+        self.verbosity_handler(quiet, verbose)
 
-        EXAMPLE
+        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]
+                )
 
-        [green]$[/green] btcli root list
-        """
-        self.verbosity_handler(quiet, verbose)
         return self._run_command(
-            root.root_list(subtensor=self.initialize_chain(network))
+            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"
+        ),
+        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.",
+        ),
+        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,
         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.
-
-        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.
-
-        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.
-
-        EXAMPLE
-
-        With no spaces between the passed values:
-
-        [green]$[/green] btcli root set-weights --netuids 1,2 --weights 0.2,0.3
-
-        or
-
-        Include double quotes to include spaces between the passed values:
-
-        [green]$[/green] btcli root set-weights --netuids "1, 2" --weights "0.2, 0.3"
-        """
-        self.verbosity_handler(quiet, verbose)
-
-        if netuids:
-            netuids = parse_to_list(
-                netuids,
-                int,
-                "Netuids must be a comma-separated list of ints, e.g., `--netuid 1,2,3,4`.",
-            )
-        else:
-            netuids = list_prompt(netuids, int, "Enter netuids (e.g: 1, 4, 6)")
-
-        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 len(netuids) != len(weights):
-            raise typer.BadParameter(
-                "The number of netuids and weights must be the same."
-            )
-
-        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
-            )
-        )
-
-    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.
-
-        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.
-
-        EXAMPLE
-
-        [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`."
-            )
-            raise typer.Exit()
-        if not reuse_last:
-            subtensor = self.initialize_chain(network)
-        else:
-            subtensor = None
-        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),
-            )
-        )
-
-    def root_boost(
-        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",
-            "--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)",
-        ),
-        prompt: bool = Options.prompt,
-        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.
-
-        EXAMPLE
-
-        [green]$[/green] btcli root boost --netuid 1 --increase 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_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)))
-
-    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`"
-            )
-            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.
+        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.
 
@@ -3307,16 +2655,14 @@ class CLIManager:
         [green]$[/green] btcli stake add --amount 100 --wallet-name <my_wallet> --wallet-hotkey <my_hotkey>
         """
         self.verbosity_handler(quiet, verbose)
+        netuid = get_optional_netuid(netuid, all_netuids)
 
         if stake_all and amount:
-            print_error(
+            err_console.print(
                 "Cannot specify an amount and 'stake-all'. Choose one or the other."
             )
             raise typer.Exit()
 
-        if not stake_all and not amount and not max_stake:
-            amount = FloatPrompt.ask("Amount to [blue]stake (TAO τ)[/blue]")
-
         if stake_all and not amount:
             if not Confirm.ask("Stake all the available TAO tokens?", default=False):
                 raise typer.Exit()
@@ -3334,40 +2680,66 @@ class CLIManager:
             )
             raise typer.Exit()
 
-        if (
-            not wallet_hotkey
-            and not all_hotkeys
-            and not include_hotkeys
-            and not hotkey_ss58_address
-        ):
-            hotkey_or_ss58 = Prompt.ask(
-                "Enter the [blue]hotkey[/blue] name or [blue]ss58 address[/blue] to stake to",
-            )
-            if is_valid_ss58_address(hotkey_or_ss58):
-                hotkey_ss58_address = hotkey_or_ss58
+        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,
+                )
+
+            if 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]
+                )
+                selected_hotkey = self._run_command(
+                    subnets.show(
+                        subtensor=self.initialize_chain(network),
+                        netuid=netuid,
+                        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],
+                    ask_for=[WO.NAME, WO.HOTKEY, WO.PATH],
                     validate=WV.WALLET_AND_HOTKEY,
                 )
+                include_hotkeys = wallet.hotkey.ss58_address
 
-        elif all_hotkeys or include_hotkeys or exclude_hotkeys or hotkey_ss58_address:
+        elif all_hotkeys or include_hotkeys or exclude_hotkeys:
             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,
             )
 
@@ -3375,8 +2747,8 @@ class CLIManager:
             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....`.",
+                "Hotkeys must be a comma-separated list of ss58s, e.g., `--include-hotkeys 5Grw....,5Grw....`.",
+                is_ss58=True,
             )
         else:
             included_hotkeys = []
@@ -3385,24 +2757,54 @@ class CLIManager:
             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....`.",
+                "Hotkeys must be a comma-separated list of ss58s, e.g., `--exclude-hotkeys 5Grw....,5Grw....`.",
+                is_ss58=True,
             )
         else:
             excluded_hotkeys = []
 
+        # TODO: Ask amount for each subnet explicitly if more than one
+        if not stake_all and not amount and not max_stake:
+            free_balance, staked_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(
             stake.stake_add(
                 wallet,
                 self.initialize_chain(network),
-                amount,
+                netuid,
                 stake_all,
+                amount,
+                False,
+                prompt,
                 max_stake,
+                all_hotkeys,
                 included_hotkeys,
                 excluded_hotkeys,
-                all_hotkeys,
-                prompt,
-                hotkey_ss58_address,
             )
         )
 
@@ -3412,11 +2814,21 @@ class CLIManager:
         wallet_name: str = Options.wallet_name,
         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",
-            help="When set, this commmand unstakes all staked TAO from the specified hotkeys.",
+            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(
             0.0, "--amount", "-a", help="The amount of TAO to unstake."
@@ -3450,6 +2862,12 @@ class CLIManager:
             "hotkeys in `--include-hotkeys`.",
         ),
         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,
     ):
@@ -3465,31 +2883,45 @@ class CLIManager:
         [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)
+        # TODO: Coldkey related unstakes need to be updated. Patching for now.
+        unstake_all_alpha = False
+        unstake_all = False
 
-        if all_hotkeys and include_hotkeys:
+        if interactive and any(
+            [hotkey_ss58_address, include_hotkeys, exclude_hotkeys, all_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`."
+                "Interactive mode cannot be used with hotkey selection options like --include-hotkeys, --exclude-hotkeys, --all-hotkeys, or --hotkey."
             )
             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 unstake_all and unstake_all_alpha:
+            err_console.print("Cannot specify both unstake-all and unstake-all-alpha.")
             raise typer.Exit()
 
-        if unstake_all and amount:
-            err_console.print(
-                "Cannot specify both a specific amount and 'unstake-all'. Choose one or the other."
-            )
-            raise typer.Exit()
+        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:
+                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 include_hotkeys and exclude_hotkeys:
+                err_console.print(
+                    "You have specified both including and excluding hotkeys options. Select one or the other."
+                )
+                raise typer.Exit()
 
-        if not unstake_all and not amount and not keep_stake:
-            amount = FloatPrompt.ask("Amount to [blue]unstake (TAO τ)[/blue]")
+            if unstake_all and amount:
+                err_console.print(
+                    "Cannot specify both a specific amount and 'unstake-all'. Choose one or the other."
+                )
+                raise typer.Exit()
 
-        if unstake_all and not amount and prompt:
-            if not Confirm.ask("Unstake all staked TAO tokens?", default=False):
+            if amount and amount <= 0:
+                print_error(f"You entered an incorrect unstake amount: {amount}")
                 raise typer.Exit()
 
         if (
@@ -3497,14 +2929,27 @@ class CLIManager:
             and not hotkey_ss58_address
             and not all_hotkeys
             and not include_hotkeys
+            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 unstake from"
+                "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
@@ -3512,56 +2957,436 @@ 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 (
+            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, WO.PATH]
+            )
+        else:
             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, WO.HOTKEY],
+                validate=WV.WALLET_AND_HOTKEY,
+            )
+
+        if include_hotkeys:
+            included_hotkeys = parse_to_list(
+                include_hotkeys,
+                str,
+                "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,
+                str,
+                "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.unstake(
+                wallet,
+                self.initialize_chain(network),
+                hotkey_ss58_address,
+                all_hotkeys,
+                included_hotkeys,
+                excluded_hotkeys,
+                amount,
+                keep_stake,
+                unstake_all,
+                prompt,
+                interactive,
+                netuid=netuid,
+                unstake_all_alpha=unstake_all_alpha,
+            )
+        )
+
+    def stake_move(
+        self,
+        network: Optional[list[str]] = Options.network,
+        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"
+        ),
+        destination_netuid: Optional[int] = typer.Option(
+            None, "--dest-netuid", help="Destination netuid"
+        ),
+        destination_hotkey: Optional[str] = typer.Option(
+            None, "--dest-ss58", "--dest", help="Destination hotkey", prompt=False
+        ),
+        amount: float = typer.Option(
+            None,
+            "--amount",
+            help="The amount of TAO to stake",
+            prompt=False,
+        ),
+        stake_all: bool = typer.Option(
+            False, "--stake-all", "--all", help="Stake all", prompt=False
+        ),
+        prompt: bool = Options.prompt,
+    ):
+        """
+        Move staked TAO between hotkeys while keeping the same coldkey ownership.
+
+        This command allows you to:
+        - Move stake from one hotkey to another hotkey
+        - Move stake between different subnets
+        - Keep the same coldkey ownership
+
+        You can specify:
+        - The origin subnet (--origin-netuid)
+        - The destination subnet (--dest-netuid)
+        - The destination hotkey (--dest-hotkey)
+        - The amount to move (--amount)
+
+        If no arguments are provided, an interactive selection menu will be shown.
+
+        EXAMPLE
+
+        [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]"
+            )
+            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 not wallet_name:
+            wallet_name = Prompt.ask(
+                "Enter the [blue]origin wallet name[/blue]",
+                default=self.config.get("wallet_name") or defaults.wallet.name,
+            )
+        wallet = self.wallet_ask(
+            wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
+        )
+
+        interactive_selection = False
+        if not wallet_hotkey:
+            origin_hotkey = Prompt.ask(
+                "Enter the [blue]origin hotkey[/blue] name or "
+                "[blue]ss58 address[/blue] where the stake will be moved from "
+                "[dim](or Press Enter to view existing stakes)[/dim]"
+            )
+            if origin_hotkey == "":
+                interactive_selection = True
+
+            elif is_valid_ss58_address(origin_hotkey):
+                origin_hotkey = origin_hotkey
+            else:
+                wallet = self.wallet_ask(
+                    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 = self.wallet_ask(
+                    wallet_name,
+                    wallet_path,
+                    wallet_hotkey,
+                    ask_for=[],
+                    validate=WV.WALLET_AND_HOTKEY,
+                )
+                origin_hotkey = wallet.hotkey.ss58_address
+
+        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.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.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.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,
             )
         )
 
@@ -3601,7 +3426,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,
         )
 
@@ -3632,18 +3457,8 @@ 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",
@@ -3656,10 +3471,9 @@ class CLIManager:
         wait_for_finalization: bool = Options.wait_for_finalization,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
-        prompt: bool = Options.prompt,
     ):
         """
-        Set child hotkeys on a specified subnet (or all). Overrides currently set children.
+        Set child hotkeys on specified subnets.
 
         Users can specify the 'proportion' to delegate to child hotkeys (ss58 address). The sum of proportions cannot be greater than 1.
 
@@ -3670,15 +3484,8 @@ class CLIManager:
         [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
-            )
+        netuid = get_optional_netuid(netuid, all_netuids)
+
         children = list_prompt(
             children,
             str,
@@ -3703,7 +3510,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(
@@ -3715,7 +3522,6 @@ class CLIManager:
                 proportions=proportions,
                 wait_for_finalization=wait_for_finalization,
                 wait_for_inclusion=wait_for_inclusion,
-                prompt=prompt,
             )
         )
 
@@ -3741,10 +3547,9 @@ class CLIManager:
         wait_for_finalization: bool = Options.wait_for_finalization,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
-        prompt: bool = Options.prompt,
     ):
         """
-        Remove all children hotkeys on a specified subnet (or all).
+        Remove all children hotkeys on a specified subnet.
 
         This command is used to remove delegated authority from all child hotkeys, removing their position and influence on the subnet.
 
@@ -3757,7 +3562,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 all_netuids and netuid:
@@ -3776,7 +3581,6 @@ class CLIManager:
                 netuid,
                 wait_for_inclusion,
                 wait_for_finalization,
-                prompt=prompt,
             )
         )
 
@@ -3813,153 +3617,308 @@ class CLIManager:
         verbose: bool = Options.verbose,
     ):
         """
-        Get and set your child hotkey take on a specified subnet.
+        Get and set your child hotkey take on a specified subnet.
+
+        The child hotkey take must be between 0 - 18%.
+
+        EXAMPLE
+
+        To get the current take value, do not use the '--take' option:
+
+            [green]$[/green] btcli stake child take --hotkey <child_hotkey> --netuid 1
+
+        To set a new take value, use the '--take' option:
+
+            [green]$[/green] btcli stake child take --hotkey <child_hotkey> --take 0.12 --netuid 1
+        """
+        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 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 netuid (leave blank for all)", default=None, show_default=True
+            )
+        return self._run_command(
+            children_hotkeys.childkey_take(
+                wallet=wallet,
+                subtensor=self.initialize_chain(network),
+                netuid=netuid,
+                take=take,
+                hotkey=hotkey,
+                wait_for_inclusion=wait_for_inclusion,
+                wait_for_finalization=wait_for_finalization,
+                prompt=prompt,
+            )
+        )
+
+    def sudo_set(
+        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,
+        netuid: int = Options.netuid,
+        param_name: str = typer.Option(
+            "", "--param", "--parameter", help="The subnet hyperparameter to set"
+        ),
+        param_value: str = typer.Option(
+            "", "--value", help="Value to set the hyperparameter to."
+        ),
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+    ):
+        """
+        Used to set hyperparameters for a specific subnet.
+
+        This command allows subnet owners to modify hyperparameters such as its tempo, emission rates, and other hyperparameters.
+
+        EXAMPLE
+
+        [green]$[/green] btcli sudo set --netuid 1 --param tempo --value 400
+        """
+        self.verbosity_handler(quiet, verbose)
+
+        hyperparams = self._run_command(
+            sudo.get_hyperparameters(self.initialize_chain(network), netuid),
+            exit_early=False,
+        )
+
+        if not hyperparams:
+            raise typer.Exit()
+
+        if not param_name:
+            hyperparam_list = [field.name for field in fields(SubnetHyperparameters)]
+            console.print("Available hyperparameters:\n")
+            for idx, param in enumerate(hyperparam_list, start=1):
+                console.print(f"  {idx}. {param}")
+            console.print()
+            choice = IntPrompt.ask(
+                "Enter the [bold]number[/bold] of the hyperparameter",
+                choices=[str(i) for i in range(1, len(hyperparam_list) + 1)],
+                show_choices=False,
+            )
+            param_name = hyperparam_list[choice - 1]
+
+        if not param_value:
+            param_value = Prompt.ask(
+                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, WO.PATH]
+        )
+        return self._run_command(
+            sudo.sudo_set_hyperparameter(
+                wallet,
+                self.initialize_chain(network),
+                netuid,
+                param_name,
+                param_value,
+            )
+        )
+
+    def sudo_get(
+        self,
+        network: Optional[list[str]] = Options.network,
+        netuid: int = Options.netuid,
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+    ):
+        """
+        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
+        """
+        self.verbosity_handler(quiet, verbose)
+        return self._run_command(
+            sudo.get_hyperparameters(self.initialize_chain(network), netuid)
+        )
+
+    def sudo_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 sudo senate
+        """
+        self.verbosity_handler(quiet, verbose)
+        return self._run_command(sudo.get_senate(self.initialize_chain(network)))
+
+    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.
 
-        The child hotkey take must be between 0 - 18%.
+        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)))
 
-        To get the current take value, do not use the '--take' option:
+    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.
 
-            [green]$[/green] btcli stake child take --hotkey <child_hotkey> --netuid 1
+        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.
 
-        To set a new take value, use the '--take' option:
+        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.
 
-            [green]$[/green] btcli stake child take --hotkey <child_hotkey> --take 0.12 --netuid 1
+        EXAMPLE
+        [green]$[/green] btcli sudo 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],
+            ask_for=[WO.NAME, WO.PATH, WO.HOTKEY],
             validate=WV.WALLET_AND_HOTKEY,
         )
-        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 netuid (leave blank for all)", default=None, show_default=True
-            )
         return self._run_command(
-            children_hotkeys.childkey_take(
-                wallet=wallet,
-                subtensor=self.initialize_chain(network),
-                netuid=netuid,
-                take=take,
-                hotkey=hotkey,
-                wait_for_inclusion=wait_for_inclusion,
-                wait_for_finalization=wait_for_finalization,
-                prompt=prompt,
+            sudo.senate_vote(
+                wallet, self.initialize_chain(network), proposal, vote, prompt
             )
         )
 
-    def sudo_set(
+    def sudo_set_take(
         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,
-        netuid: int = Options.netuid,
-        param_name: str = typer.Option(
-            "", "--param", "--parameter", help="The subnet hyperparameter to set"
-        ),
-        param_value: str = typer.Option(
-            "", "--value", help="Value to set the hyperparameter to."
-        ),
+        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,
     ):
         """
-        Used to set hyperparameters for a specific subnet.
+        Allows users to change their delegate take percentage.
 
-        This command allows subnet owners to modify hyperparameters such as its tempo, emission rates, and other hyperparameters.
+        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 --netuid 1 --param tempo --value 400
+        [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)
 
-        if not param_name or not param_value:
-            hyperparams = self._run_command(
-                sudo.get_hyperparameters(self.initialize_chain(network), netuid)
-            )
-            if not hyperparams:
-                raise typer.Exit()
+        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 param_name:
-            hyperparam_list = [field.name for field in fields(SubnetHyperparameters)]
-            console.print("Available hyperparameters:\n")
-            for idx, param in enumerate(hyperparam_list, start=1):
-                console.print(f"  {idx}. {param}")
-            console.print()
-            choice = IntPrompt.ask(
-                "Enter the [bold]number[/bold] of the hyperparameter",
-                choices=[str(i) for i in range(1, len(hyperparam_list) + 1)],
-                show_choices=False,
-            )
-            param_name = hyperparam_list[choice - 1]
+        self._run_command(
+            sudo.display_current_take(self.initialize_chain(network), wallet),
+            exit_early=False,
+        )
 
-        if param_name in ["alpha_high", "alpha_low"]:
-            param_name = "alpha_values"
-            low_val = FloatPrompt.ask(
-                "Enter the new value for [dark_orange]alpha_low[/dark_orange]"
-            )
-            high_val = FloatPrompt.ask(
-                "Enter the new value for [dark_orange]alpha_high[/dark_orange]"
+        if not take:
+            take = FloatPrompt.ask(
+                f"Enter [blue]take value[/blue] (0.18 for 18%) [blue]Min: {min_value} Max: {max_value}"
             )
-            param_value = f"{low_val},{high_val}"
-
-        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"
+        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]
-        )
         return self._run_command(
-            sudo.sudo_set_hyperparameter(
-                wallet,
-                self.initialize_chain(network),
-                netuid,
-                param_name,
-                param_value,
-            )
+            sudo.set_take(wallet, self.initialize_chain(network), take)
         )
 
-    def sudo_get(
+    def sudo_get_take(
         self,
         network: Optional[list[str]] = Options.network,
-        netuid: int = Options.netuid,
+        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,
     ):
         """
-        Shows a list of the hyperparameters for the specified subnet.
+        Allows users to check their delegate take percentage.
 
-        The output of this command is the same as that of `btcli subnets hyperparameters`.
+        This command can be used to fetch the delegate take of your hotkey.
 
         EXAMPLE
-
-        [green]$[/green] btcli sudo get --netuid 1
+        [green]$[/green] btcli sudo get-take --wallet-name my_wallet --wallet-hotkey my_hotkey
         """
         self.verbosity_handler(quiet, verbose)
-        return self._run_command(
-            sudo.get_hyperparameters(self.initialize_chain(network), netuid)
+
+        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,
-        reuse_last: bool = Options.reuse_last,
-        html_output: bool = Options.html_output,
+        # reuse_last: bool = Options.reuse_last,
+        # html_output: bool = Options.html_output,
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
+        live_mode: bool = Options.live,
     ):
         """
         List all subnets and their detailed information.
@@ -3980,48 +3939,189 @@ class CLIManager:
         [green]$[/green] btcli subnets list
         """
         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`."
-            )
-            raise typer.Exit()
-        if reuse_last:
-            subtensor = None
-        else:
-            subtensor = self.initialize_chain(network)
+        # 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`."
+        #     )
+        #     raise typer.Exit()
+        # if reuse_last:
+        #     subtensor = None
+        # else:
+        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,
+        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,
+                netuid,
+                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,
@@ -4037,13 +4137,44 @@ class CLIManager:
         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,
@@ -4092,7 +4223,6 @@ class CLIManager:
             "-tbp",
             help="Set the number of threads per block for CUDA.",
         ),
-        prompt: bool = Options.prompt,
     ):
         """
         Register a neuron (a subnet validator or a subnet miner) using Proof of Work (POW).
@@ -4118,7 +4248,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),
@@ -4130,7 +4260,6 @@ class CLIManager:
                 use_cuda,
                 dev_id,
                 threads_per_block,
-                prompt=prompt,
             )
         )
 
@@ -4161,7 +4290,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(
@@ -4247,6 +4376,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`")
@@ -4290,7 +4425,6 @@ class CLIManager:
         ),
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
-        prompt: bool = Options.prompt,
     ):
         """
         Reveal weights for a specific subnet.
@@ -4349,7 +4483,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,
         )
 
@@ -4362,7 +4496,6 @@ class CLIManager:
                 weights,
                 salt,
                 __version_as_int__,
-                prompt=prompt,
             )
         )
 
@@ -4388,7 +4521,6 @@ class CLIManager:
         ),
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
-        prompt: bool = Options.prompt,
     ):
         """
 
@@ -4447,7 +4579,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(
@@ -4459,7 +4591,6 @@ class CLIManager:
                 weights,
                 salt,
                 __version_as_int__,
-                prompt=prompt,
             )
         )