bittensor-cli 9.19.0rc2__tar.gz → 9.20.0__tar.gz

{bittensor_cli-9.19.0rc2 → bittensor_cli-9.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bittensor-cli
-Version: 9.19.0rc2
+Version: 9.20.0
 Summary: Bittensor CLI
 Author: bittensor.com
 Requires-Python: >=3.10
@@ -32,7 +32,8 @@ Requires-Dist: PyYAML~=6.0
 Requires-Dist: rich>=13.7,<15.0
 Requires-Dist: scalecodec==1.2.12
 Requires-Dist: typer>=0.16
-Requires-Dist: bittensor-wallet>=4.0.0
+Requires-Dist: typing_extensions>4.0.0; python_version<'3.11'
+Requires-Dist: bittensor-wallet==4.0.1
 Requires-Dist: packaging
 Requires-Dist: plotille>=5.0.0
 Requires-Dist: plotly>=6.0.0

{bittensor_cli-9.19.0rc2 → bittensor_cli-9.20.0}/bittensor_cli/cli.py

@@ -641,8 +641,8 @@ def get_creation_data(
     return mnemonic, seed, json_path, json_password
 
 
-def config_selector(conf: dict, title: str):
-    def curses_selector(stdscr):
+def config_selector(conf: dict[str, bool], title: str) -> dict[str, bool]:
+    def curses_selector(stdscr) -> dict[str, bool]:
         """
         Enhanced Curses TUI to make selections.
         """
@@ -698,7 +698,7 @@ def config_selector(conf: dict, title: str):
     return curses.wrapper(curses_selector)
 
 
-def version_callback(value: bool):
+def version_callback(value: bool) -> None:
     """
     Prints the current version/branch-name
     """
@@ -716,7 +716,7 @@ def version_callback(value: bool):
         raise typer.Exit()
 
 
-def commands_callback(value: bool):
+def commands_callback(value: bool) -> None:
     """
     Prints a tree of commands for the app
     """
@@ -726,7 +726,7 @@ def commands_callback(value: bool):
         raise typer.Exit()
 
 
-def debug_callback(value: bool):
+def debug_callback(value: bool) -> None:
     if value:
         debug_file_loc = Path(
             os.getenv("BTCLI_DEBUG_FILE")
@@ -1389,7 +1389,7 @@ class CLIManager:
         Generates a rich.Tree of the commands, subcommands, and groups of this app
         """
 
-        def build_rich_tree(data: dict, parent: Tree):
+        def build_rich_tree(data: dict, parent: Tree) -> None:
             for group, content in data.get("groups", {}).items():
                 group_node = parent.add(
                     f"[bold cyan]{group}[/]"
@@ -1943,7 +1943,7 @@ class CLIManager:
         with open(self.config_path, "w") as f:
             safe_dump(self.config, f)
 
-    def get_config(self):
+    def get_config(self) -> None:
         """
         Prints the current config file in a table.
         """
@@ -2079,7 +2079,7 @@ class CLIManager:
             print_error(f"Proxy {name} not found in address book.")
         self.config_get_proxies()
 
-    def config_get_proxies(self):
+    def config_get_proxies(self) -> None:
         """
         Displays the current proxies address book
 
@@ -2228,7 +2228,7 @@ class CLIManager:
             console.print("Proxy updated")
             self.config_get_proxies()
 
-    def config_clear_proxy_book(self):
+    def config_clear_proxy_book(self) -> None:
         """
         Clears the proxy address book. Use with caution.
         Really only useful if you have corrupted your proxy address book.
@@ -4144,7 +4144,11 @@ class CLIManager:
         self,
         action: str = typer.Argument(
             None,
-            help="Action to perform: 'announce' to announce intent, 'execute' to complete swap after delay, 'dispute' to freeze the swap.",
+            help=(
+                "Action to perform: 'announce' to announce intent, "
+                "'execute' to complete swap after delay, 'dispute' to freeze the swap, "
+                "'clear' to withdraw announcement, 'check' to view status."
+            ),
         ),
         wallet_name: Optional[str] = Options.wallet_name,
         wallet_path: Optional[str] = Options.wallet_path,
@@ -4176,6 +4180,9 @@ class CLIManager:
         If you suspect compromise, you can [bold]Dispute[/bold] an active announcement to freeze
         all activity for the coldkey until the triumvirate can intervene.
 
+        If you want to withdraw your announcement, you can [bold]Clear[/bold] (withdraw) an announcement once the
+        reannouncement delay has elapsed.
+
         EXAMPLES
 
         Step 1 - Announce your intent to swap:
@@ -4190,9 +4197,13 @@ class CLIManager:
 
         [green]$[/green] btcli wallet swap-coldkey dispute
 
-        Check status of pending swaps:
+        Clear (withdraw) an announcement:
+
+        [green]$[/green] btcli wallet swap-coldkey clear
 
-        [green]$[/green] btcli wallet swap-check
+        Check status of your swap:
+
+        [green]$[/green] btcli wallet swap-coldkey check
         """
         self.verbosity_handler(quiet, verbose, prompt=False, json_output=False)
 
@@ -4201,18 +4212,19 @@ class CLIManager:
                 "\n[bold][blue]Coldkey Swap Actions:[/blue][/bold]\n"
                 "  [dark_sea_green3]announce[/dark_sea_green3] - Start the swap process (pays fee, starts delay timer)\n"
                 "  [dark_sea_green3]execute[/dark_sea_green3]  - Complete the swap (after delay period)\n"
-                "  [dark_sea_green3]dispute[/dark_sea_green3]  - Freeze the swap process if you suspect compromise\n\n"
-                "  [dim]You can check the current status of your swap with 'btcli wallet swap-check'.[/dim]\n"
+                "  [dark_sea_green3]dispute[/dark_sea_green3]  - Freeze the swap process if you suspect compromise\n"
+                "  [dark_sea_green3]clear[/dark_sea_green3]    - Withdraw your swap announcement\n"
+                "  [dark_sea_green3]check[/dark_sea_green3]    - Check the status of your swap\n\n"
             )
             action = Prompt.ask(
                 "Select action",
-                choices=["announce", "execute", "dispute"],
+                choices=["announce", "execute", "dispute", "clear", "check"],
                 default="announce",
             )
 
-        if action.lower() not in ("announce", "execute", "dispute"):
+        if action.lower() not in ("announce", "execute", "dispute", "clear", "check"):
             print_error(
-                f"Invalid action: {action}. Must be 'announce', 'execute', or 'dispute'."
+                f"Invalid action: {action}. Must be 'announce', 'execute', 'dispute', 'clear', or 'check'."
             )
             raise typer.Exit(1)
 
@@ -4233,7 +4245,7 @@ class CLIManager:
         )
 
         new_wallet_coldkey_ss58 = None
-        if action != "dispute":
+        if action not in ("dispute", "clear", "check"):
             if not new_wallet_or_ss58:
                 new_wallet_or_ss58 = Prompt.ask(
                     "Enter the [blue]new wallet name[/blue] or [blue]SS58 address[/blue] of the new coldkey",
@@ -4285,6 +4297,24 @@ class CLIManager:
                     mev_protection=mev_protection,
                 )
             )
+        elif action == "clear":
+            return self._run_command(
+                wallets.clear_coldkey_swap_announcement(
+                    wallet=wallet,
+                    subtensor=self.initialize_chain(network),
+                    decline=decline,
+                    quiet=quiet,
+                    prompt=prompt,
+                    mev_protection=mev_protection,
+                )
+            )
+        elif action == "check":
+            return self._run_command(
+                wallets.check_swap_status(
+                    subtensor=self.initialize_chain(network),
+                    origin_ss58=wallet.coldkeypub.ss58_address,
+                )
+            )
         else:
             return self._run_command(
                 wallets.execute_coldkey_swap(
@@ -9807,13 +9837,18 @@ class CLIManager:
     def proxy_remove(
         self,
         delegate: Annotated[
-            str,
+            Optional[str],
             typer.Option(
                 callback=is_valid_ss58_address_param,
-                prompt="Enter the SS58 address of the delegate to remove, e.g. 5dxds...",
-                help="The SS58 address of the delegate to remove",
+                prompt=False,
+                help="The SS58 address of the delegate to remove (required if --all is not used)",
             ),
-        ] = "",
+        ] = None,
+        all_: bool = typer.Option(
+            False,
+            "--all",
+            help="Remove all proxies associated with this account",
+        ),
         network: Optional[list[str]] = Options.network,
         proxy_type: ProxyType = Options.proxy_type,
         delay: int = typer.Option(0, help="Delay, in number of blocks"),
@@ -9840,10 +9875,10 @@ class CLIManager:
         [green]$[/green] btcli proxy remove --delegate 5GDel... --proxy-type Transfer
 
         """
-        # TODO should add a --all flag to call Proxy.remove_proxies ?
         logger.debug(
             "args:\n"
             f"delegate: {delegate}\n"
+            f"all: {all_}\n"
             f"network: {network}\n"
             f"proxy_type: {proxy_type}\n"
             f"delay: {delay}\n"
@@ -9851,6 +9886,41 @@ class CLIManager:
             f"wait_for_inclusion: {wait_for_inclusion}\n"
             f"era: {period}\n"
         )
+        # Validate that --delegate and --all are not used together
+        if all_ and delegate:
+            if not json_output:
+                print_error("--delegate cannot be used together with --all flag.")
+            else:
+                json_console.print_json(
+                    data={
+                        "success": False,
+                        "message": "--delegate cannot be used together with --all flag.",
+                        "extrinsic_identifier": None,
+                    }
+                )
+            return
+
+        # If --all is not used and delegate is not provided, prompt or error
+        if not all_ and not delegate:
+            if not prompt:
+                if not json_output:
+                    print_error(
+                        "Either --delegate must be provided or --all flag must be used."
+                    )
+                else:
+                    json_console.print_json(
+                        data={
+                            "success": False,
+                            "message": "Either --delegate must be provided or --all flag must be used.",
+                            "extrinsic_identifier": None,
+                        }
+                    )
+                return
+            delegate = Prompt.ask(
+                "Enter the SS58 address of the delegate to remove, e.g. 5dxds..."
+            )
+            delegate = is_valid_ss58_address_param(delegate)
+
         self.verbosity_handler(quiet, verbose, json_output, prompt)
         wallet = self.wallet_ask(
             wallet_name=wallet_name,
@@ -9873,6 +9943,7 @@ class CLIManager:
                 wait_for_finalization=wait_for_finalization,
                 period=period,
                 json_output=json_output,
+                remove_all=all_,
             )
         )
 
@@ -10275,11 +10346,11 @@ class CLIManager:
                 )
         return True
 
-    def run(self):
+    def run(self) -> None:
         self.app()
 
 
-def main():
+def main() -> None:
     manager = CLIManager()
     manager.run()
 

{bittensor_cli-9.19.0rc2 → bittensor_cli-9.20.0}/bittensor_cli/src/__init__.py

@@ -692,6 +692,7 @@ HYPERPARAMS = {
     "alpha_low": ("", RootSudoOnly.FALSE),  # Derived from alpha_values
     "subnet_is_active": ("", RootSudoOnly.FALSE),  # Set via btcli subnets start
     "yuma_version": ("", RootSudoOnly.FALSE),  # Related to yuma3_enabled
+    "max_allowed_uids": ("sudo_set_max_allowed_uids", RootSudoOnly.FALSE),
 }
 
 HYPERPARAMS_MODULE = {
@@ -941,6 +942,12 @@ HYPERPARAMS_METADATA = {
         "owner_settable": True,
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#yuma3",
     },
+    "max_allowed_uids": {
+        "description": "Maximum number of UIDs (neurons) on the subnet, essentially 'untrimming'.",
+        "side_effects": "See description for min_allowed_uids",
+        "owner_settable": True,
+        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#maxalloweduids",
+    },
 }
 
 # Help Panels for cli help

{bittensor_cli-9.19.0rc2 → bittensor_cli-9.20.0}/bittensor_cli/src/bittensor/chain_data.py

@@ -1,7 +1,8 @@
 from abc import abstractmethod
 from dataclasses import dataclass
+from collections.abc import Sequence
 from enum import Enum
-from typing import Optional, Any, Union
+from typing import Optional, Any, Union, Callable, Hashable
 
 import netaddr
 from scalecodec.utils.ss58 import ss58_encode
@@ -16,6 +17,11 @@ from bittensor_cli.src.bittensor.utils import (
     get_netuid_and_subuid_by_storage_index,
 )
 
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
+
 
 class ChainDataType(Enum):
     NeuronInfo = 1
@@ -69,9 +75,12 @@ def _chr_str(codes: tuple[int]) -> str:
     return "".join(map(chr, codes))
 
 
-def process_nested(data: Union[tuple, dict], chr_transform):
+def process_nested(
+    data: Sequence[dict[Hashable, tuple[int]]] | dict | Any,
+    chr_transform: Callable[[tuple[int]], str],
+) -> list[dict[Hashable, str]] | dict[Hashable, str] | Any:
     """Processes nested data structures by applying a transformation function to their elements."""
-    if isinstance(data, (list, tuple)):
+    if isinstance(data, Sequence):
         if len(data) > 0 and isinstance(data[0], dict):
             return [
                 {k: chr_transform(v) for k, v in item.items()}
@@ -79,9 +88,12 @@ def process_nested(data: Union[tuple, dict], chr_transform):
                 else None
                 for item in data
             ]
+        # TODO @abe why do we kind of silently fail here?
         return {}
     elif isinstance(data, dict):
         return {k: chr_transform(v) for k, v in data.items()}
+    else:
+        return data
 
 
 @dataclass
@@ -127,17 +139,17 @@ class InfoBase:
     """Base dataclass for info objects."""
 
     @abstractmethod
-    def _fix_decoded(self, decoded: Any) -> "InfoBase":
+    def _fix_decoded(self, decoded: Any) -> Self:
         raise NotImplementedError(
             "This is an abstract method and must be implemented in a subclass."
         )
 
     @classmethod
-    def from_any(cls, data: Any) -> "InfoBase":
+    def from_any(cls, data: Any) -> Self:
         return cls._fix_decoded(data)
 
     @classmethod
-    def list_from_any(cls, data_list: list[Any]) -> list["InfoBase"]:
+    def list_from_any(cls, data_list: list[Any]) -> list[Self]:
         return [cls.from_any(data) for data in data_list]
 
     def __getitem__(self, item):

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

@@ -297,7 +297,7 @@ class SubtensorInterface:
         self,
         hotkey_ss58: str,
         coldkey_ss58: str,
-        netuid: Optional[int] = None,
+        netuid: int,
         block_hash: Optional[str] = None,
     ) -> Balance:
         """
@@ -305,42 +305,18 @@ class SubtensorInterface:
 
         :param hotkey_ss58: The SS58 address of the hotkey.
         :param coldkey_ss58: The SS58 address of the coldkey.
-        :param netuid: The subnet ID to filter by. If provided, only returns stake for this specific
-            subnet.
+        :param netuid: The subnet ID for the stake query.
         :param block_hash: The block hash at which to query the stake information.
 
         :return: Balance: The stake under the coldkey - hotkey pairing.
         """
-        alpha_shares, hotkey_alpha, hotkey_shares = await asyncio.gather(
-            self.query(
-                module="SubtensorModule",
-                storage_function="Alpha",
-                params=[hotkey_ss58, coldkey_ss58, netuid],
-                block_hash=block_hash,
-            ),
-            self.query(
-                module="SubtensorModule",
-                storage_function="TotalHotkeyAlpha",
-                params=[hotkey_ss58, netuid],
-                block_hash=block_hash,
-            ),
-            self.query(
-                module="SubtensorModule",
-                storage_function="TotalHotkeyShares",
-                params=[hotkey_ss58, netuid],
-                block_hash=block_hash,
-            ),
+        result = await self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_info_for_hotkey_coldkey_netuid",
+            params=[hotkey_ss58, coldkey_ss58, netuid],
+            block_hash=block_hash,
         )
-
-        alpha_shares_as_float = fixed_to_float(alpha_shares or 0)
-        hotkey_shares_as_float = fixed_to_float(hotkey_shares or 0)
-
-        if hotkey_shares_as_float == 0:
-            return Balance.from_rao(0).set_unit(netuid=netuid)
-
-        stake = alpha_shares_as_float / hotkey_shares_as_float * (hotkey_alpha or 0)
-
-        return Balance.from_rao(int(stake)).set_unit(netuid=netuid)
+        return StakeInfo.from_any(result).stake
 
     # Alias
     get_stake = get_stake_for_coldkey_and_hotkey
@@ -1249,6 +1225,9 @@ class SubtensorInterface:
             )
         inner_hash = ""
         if mev_protection:
+            max_mev_era = 8
+            if era is None or era["period"] > max_mev_era:
+                era = {"period": max_mev_era}
             next_nonce = await self.substrate.get_account_next_index(
                 keypair.ss58_address
             )
@@ -1292,8 +1271,8 @@ class SubtensorInterface:
             err_msg = format_error_message(e)
             if mev_protection and "'result': 'invalid'" in str(e).lower():
                 err_msg = (
-                    f"MEV Shield extrinsic rejected as invalid. "
-                    f"This usually means the MEV Shield NextKey changed between fetching and submission."
+                    "MEV Shield extrinsic rejected as invalid. "
+                    "This usually means the MEV Shield NextKey changed between fetching and submission."
                 )
             if proxy and "Invalid Transaction" in err_msg:
                 extrinsic_fee, signer_balance = await asyncio.gather(
@@ -1310,6 +1289,84 @@ class SubtensorInterface:
                     )
             return False, err_msg, None
 
+    async def sign_and_send_batch_extrinsic(
+        self,
+        calls: list[GenericCall],
+        wallet: Wallet,
+        wait_for_inclusion: bool = True,
+        wait_for_finalization: bool = False,
+        era: Optional[dict[str, int]] = None,
+        proxy: Optional[str] = None,
+        nonce: Optional[int] = None,
+        sign_with: Literal["coldkey", "hotkey", "coldkeypub"] = "coldkey",
+        announce_only: bool = False,
+        mev_protection: bool = False,
+        block_hash: Optional[str] = None,
+    ) -> tuple[bool, str, Optional[AsyncExtrinsicReceipt]]:
+        """
+        Wraps multiple extrinsic calls into a single Utility.batch_all transaction
+        and submits it. This reduces fees by combining N separate transactions into one.
+
+        batch_all is atomic: if any call in the batch fails, the entire batch reverts.
+
+        For a single call, this delegates directly to sign_and_send_extrinsic without
+        wrapping, so there's no overhead for non-batch use cases.
+
+        :param calls: list of prepared GenericCall objects to batch together.
+        :param wallet: the wallet whose key will sign the extrinsic.
+        :param wait_for_inclusion: wait until the extrinsic is included on chain.
+        :param wait_for_finalization: wait until the extrinsic is finalized on chain.
+        :param era: validity period in blocks for the transaction.
+        :param proxy: the real account if using a proxy. None otherwise.
+        :param nonce: explicit nonce for submission. Fetched automatically if None.
+        :param sign_with: which wallet keypair signs the extrinsic.
+        :param announce_only: make the call as a proxy announcement.
+        :param mev_protection: encrypt the extrinsic via MEV Shield.
+        :param block_hash: cached block hash for compose_call. Fetched if None.
+
+        :return: (success, error message or inner hash, extrinsic receipt | None)
+        """
+        if not calls:
+            return False, "No calls to batch", None
+
+        # No need to wrap a single call in a batch
+        if len(calls) == 1:
+            return await self.sign_and_send_extrinsic(
+                call=calls[0],
+                wallet=wallet,
+                wait_for_inclusion=wait_for_inclusion,
+                wait_for_finalization=wait_for_finalization,
+                era=era,
+                proxy=proxy,
+                nonce=nonce,
+                sign_with=sign_with,
+                announce_only=announce_only,
+                mev_protection=mev_protection,
+            )
+
+        if block_hash is None:
+            block_hash = await self.substrate.get_chain_head()
+
+        batch_call = await self.substrate.compose_call(
+            call_module="Utility",
+            call_function="batch_all",
+            call_params={"calls": calls},
+            block_hash=block_hash,
+        )
+
+        return await self.sign_and_send_extrinsic(
+            call=batch_call,
+            wallet=wallet,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+            era=era,
+            proxy=proxy,
+            nonce=nonce,
+            sign_with=sign_with,
+            announce_only=announce_only,
+            mev_protection=mev_protection,
+        )
+
     async def get_children(self, hotkey, netuid) -> tuple[bool, list, str]:
         """
         This method retrieves the children of a given hotkey and netuid. It queries the SubtensorModule's ChildKeys
@@ -1488,25 +1545,6 @@ class SubtensorInterface:
 
         return all_delegates_details
 
-    async def get_stake_for_coldkey_and_hotkey_on_netuid(
-        self,
-        hotkey_ss58: str,
-        coldkey_ss58: str,
-        netuid: int,
-        block_hash: Optional[str] = None,
-    ) -> "Balance":
-        """Returns the stake under a coldkey - hotkey - netuid pairing"""
-        _result = await self.query(
-            "SubtensorModule",
-            "Alpha",
-            [hotkey_ss58, coldkey_ss58, netuid],
-            block_hash,
-        )
-        if _result is None:
-            return Balance(0).set_unit(netuid)
-        else:
-            return Balance.from_rao(fixed_to_float(_result)).set_unit(int(netuid))
-
     async def get_mechagraph_info(
         self, netuid: int, mech_id: int, block_hash: Optional[str] = None
     ) -> Optional[MetagraphInfo]:
@@ -2387,7 +2425,7 @@ class SubtensorInterface:
             After manual claim, claimable (available) stake will be added to subnet stake.
         """
         root_stake, root_claimable_rate, root_claimed = await asyncio.gather(
-            self.get_stake_for_coldkey_and_hotkey_on_netuid(
+            self.get_stake(
                 coldkey_ss58=coldkey_ss58,
                 hotkey_ss58=hotkey_ss58,
                 netuid=0,

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

@@ -1757,8 +1757,9 @@ def prompt_for_subnet_identity(
             "github_repo",
             "[blue]GitHub repository URL [dim](optional)[/blue]",
             github_repo,
-            lambda x: x
-            and (not is_valid_github_url(x) or len(x.encode("utf-8")) > 1024),
+            lambda x: (
+                x and (not is_valid_github_url(x) or len(x.encode("utf-8")) > 1024)
+            ),
             "[red]Error:[/red] Please enter a valid GitHub repository URL (e.g., https://github.com/username/repo).",
         ),
         (

{bittensor_cli-9.19.0rc2 → bittensor_cli-9.20.0}/bittensor_cli/src/commands/proxy.py

@@ -255,8 +255,8 @@ async def create_proxy(
 async def remove_proxy(
     subtensor: "SubtensorInterface",
     wallet: "Wallet",
-    proxy_type: ProxyType,
-    delegate: str,
+    proxy_type: Optional[ProxyType],
+    delegate: Optional[str],
     delay: int,
     prompt: bool,
     decline: bool,
@@ -265,18 +265,35 @@ async def remove_proxy(
     wait_for_finalization: bool,
     period: int,
     json_output: bool,
+    remove_all: bool = False,
 ) -> None:
     """
-    Executes the remove proxy call on the chain
+    Executes the remove proxy call on the chain.
+
+    If remove_all is True, removes all proxies for the account.
+    Otherwise, removes a specific proxy identified by delegate, proxy_type, and delay.
     """
+    # Handle confirmation prompt
     if prompt:
-        if not confirm_action(
-            f"This will remove a proxy of type {proxy_type.value} for delegate {delegate}."
-            f"Do you want to proceed?",
-            decline=decline,
-            quiet=quiet,
-        ):
-            return None
+        if remove_all:
+            confirmation = Prompt.ask(
+                "[red]WARNING:[/red] This will remove ALL proxies associated with this account.\n"
+                "[red]All proxy relationships will be permanently lost.[/red]\n"
+                "To proceed, enter [red]REMOVE[/red]"
+            )
+            if confirmation != "REMOVE":
+                print_error("Invalid input. Operation cancelled.")
+                return None
+        else:
+            if not confirm_action(
+                f"This will remove a proxy of type {proxy_type.value} for delegate {delegate}. "
+                f"Do you want to proceed?",
+                decline=decline,
+                quiet=quiet,
+            ):
+                return None
+
+    # Unlock wallet
     if not (ulw := unlock_key(wallet, print_out=not json_output)).success:
         if not json_output:
             print_error(ulw.message)
@@ -289,15 +306,25 @@ async def remove_proxy(
                 }
             )
         return None
-    call = await subtensor.substrate.compose_call(
-        call_module="Proxy",
-        call_function="remove_proxy",
-        call_params={
-            "proxy_type": proxy_type.value,
-            "delay": delay,
-            "delegate": delegate,
-        },
-    )
+
+    # Compose the appropriate call
+    if remove_all:
+        call = await subtensor.substrate.compose_call(
+            call_module="Proxy",
+            call_function="remove_proxies",
+            call_params={},
+        )
+    else:
+        call = await subtensor.substrate.compose_call(
+            call_module="Proxy",
+            call_function="remove_proxy",
+            call_params={
+                "proxy_type": proxy_type.value,
+                "delay": delay,
+                "delegate": delegate,
+            },
+        )
+
     return await submit_proxy(
         subtensor=subtensor,
         wallet=wallet,