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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bittensor-cli
-Version: 9.19.0
+Version: 9.20.0
 Summary: Bittensor CLI
 Author: bittensor.com
 Requires-Python: >=3.10

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

@@ -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(

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

@@ -76,9 +76,9 @@ def _chr_str(codes: tuple[int]) -> str:
 
 
 def process_nested(
-    data: Sequence[dict[Hashable, tuple[int]]] | dict,
+    data: Sequence[dict[Hashable, tuple[int]]] | dict | Any,
     chr_transform: Callable[[tuple[int]], str],
-) -> list[dict[Hashable, str]] | dict[Hashable, str]:
+) -> list[dict[Hashable, str]] | dict[Hashable, str] | Any:
     """Processes nested data structures by applying a transformation function to their elements."""
     if isinstance(data, Sequence):
         if len(data) > 0 and isinstance(data[0], dict):
@@ -93,7 +93,7 @@ def process_nested(
     elif isinstance(data, dict):
         return {k: chr_transform(v) for k, v in data.items()}
     else:
-        raise TypeError(f"Unsupported data type {type(data)}")
+        return data
 
 
 @dataclass

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

@@ -1271,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(
@@ -1289,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

{bittensor_cli-9.19.0 → bittensor_cli-9.20.0}/bittensor_cli/src/commands/stake/add.py

@@ -467,62 +467,169 @@ async def stake_add(
     if not unlock_key(wallet).success:
         return
 
+    # Build the list of (netuid, hotkey, amount, current_stake, price_limit) tuples
+    # that describe each staking operation we need to perform.
+    # The zip aligns netuids with amounts/balances (which are populated per
+    # hotkey-netuid pair, but the zip truncates to len(netuids), matching the
+    # original execution order). Each netuid's amount/price applies to all hotkeys.
+    operations = []
+    if safe_staking:
+        for ni, am, curr, price in zip(
+            netuids, amounts_to_stake, current_stake_balances, prices_with_tolerance
+        ):
+            for _, staking_address in hotkeys_to_stake_to:
+                operations.append((ni, staking_address, am, curr, price))
+    else:
+        for ni, am, curr in zip(netuids, amounts_to_stake, current_stake_balances):
+            for _, staking_address in hotkeys_to_stake_to:
+                operations.append((ni, staking_address, am, curr, None))
+
+    total_ops = len(operations)
+    use_batch = total_ops > 1
+
     successes = defaultdict(dict)
     error_messages = defaultdict(dict)
     extrinsic_ids = defaultdict(dict)
-    with console.status(f"\n:satellite: Staking on netuid(s): {netuids} ...") as status:
-        if safe_staking:
-            stake_coroutines = {}
-            for i, (ni, am, curr, price_with_tolerance) in enumerate(
-                zip(
-                    netuids,
-                    amounts_to_stake,
-                    current_stake_balances,
-                    prices_with_tolerance,
-                )
-            ):
-                for _, staking_address in hotkeys_to_stake_to:
-                    # Regular extrinsic for root subnet
-                    if ni == 0:
-                        stake_coroutines[(ni, staking_address)] = stake_extrinsic(
-                            netuid_i=ni,
-                            amount_=am,
-                            current=curr,
-                            staking_address_ss58=staking_address,
-                            status_=status,
+
+    if use_batch:
+        # Batch path: compose all calls, submit as a single Utility.batch_all transaction
+        with console.status(
+            f"\n:satellite: Batching {total_ops} stake operations on netuid(s): {netuids} ..."
+        ) as status:
+            batch_block_hash = await subtensor.substrate.get_chain_head()
+            current_balance = await subtensor.get_balance(
+                coldkey_ss58, block_hash=batch_block_hash
+            )
+
+            # compose_call with a block_hash does no I/O, so no need for gather
+            calls = []
+            for ni, hk, am, _, price in operations:
+                if safe_staking and ni != 0:
+                    calls.append(
+                        await subtensor.substrate.compose_call(
+                            call_module="SubtensorModule",
+                            call_function="add_stake_limit",
+                            call_params={
+                                "hotkey": hk,
+                                "netuid": ni,
+                                "amount_staked": am.rao,
+                                "limit_price": price.rao,
+                                "allow_partial": allow_partial_stake,
+                            },
+                            block_hash=batch_block_hash,
                         )
-                    else:
-                        stake_coroutines[(ni, staking_address)] = safe_stake_extrinsic(
-                            netuid_=ni,
-                            amount_=am,
-                            current_stake=curr,
-                            hotkey_ss58_=staking_address,
-                            price_limit=price_with_tolerance,
-                            status_=status,
+                    )
+                else:
+                    calls.append(
+                        await subtensor.substrate.compose_call(
+                            call_module="SubtensorModule",
+                            call_function="add_stake",
+                            call_params={
+                                "hotkey": hk,
+                                "netuid": ni,
+                                "amount_staked": am.rao,
+                            },
+                            block_hash=batch_block_hash,
                         )
-        else:
-            stake_coroutines = {
-                (ni, staking_address): stake_extrinsic(
-                    netuid_i=ni,
-                    amount_=am,
-                    current=curr,
-                    staking_address_ss58=staking_address,
-                    status_=status,
-                )
-                for i, (ni, am, curr) in enumerate(
-                    zip(netuids, amounts_to_stake, current_stake_balances)
+                    )
+
+            success, err_msg, response = await subtensor.sign_and_send_batch_extrinsic(
+                calls=list(calls),
+                wallet=wallet,
+                era={"period": era},
+                proxy=proxy,
+                mev_protection=mev_protection,
+                block_hash=batch_block_hash,
+            )
+
+            if success and mev_protection:
+                inner_hash = err_msg
+                success, mev_error, response = await wait_for_extrinsic_by_hash(
+                    subtensor=subtensor,
+                    extrinsic_hash=inner_hash,
+                    submit_block_hash=response.block_hash,
+                    status=status,
                 )
-                for _, staking_address in hotkeys_to_stake_to
-            }
-        # We can gather them all at once but balance reporting will be in race-condition.
-        for (ni, staking_address), coroutine in stake_coroutines.items():
-            success, er_msg, ext_receipt = await coroutine
-            successes[ni][staking_address] = success
-            error_messages[ni][staking_address] = er_msg
+                if not success:
+                    err_msg = mev_error
+
+            # batch_all is atomic: all succeed or all revert
+            for ni, hk, am, curr, _ in operations:
+                successes[ni][hk] = success
+                error_messages[ni][hk] = "" if success else err_msg
+
             if success:
-                extrinsic_ids[ni][
-                    staking_address
-                ] = await ext_receipt.get_extrinsic_identifier()
+                ext_id = await response.get_extrinsic_identifier()
+                for ni, hk, _, _, _ in operations:
+                    extrinsic_ids[ni][hk] = ext_id
+
+                if not json_output:
+                    await print_extrinsic_id(response)
+                    new_block_hash = await subtensor.substrate.get_chain_head()
+                    new_balance = await subtensor.get_balance(
+                        coldkey_ss58, block_hash=new_block_hash
+                    )
+                    print_success(
+                        f"[dark_sea_green3]Batch finalized. "
+                        f"Staked across {total_ops} operations.[/dark_sea_green3]"
+                    )
+                    console.print(
+                        f"Balance:\n  [blue]{current_balance}[/blue] :arrow_right: "
+                        f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_balance}"
+                    )
+                    for ni, hk, am, curr, _ in operations:
+                        new_stake = await subtensor.get_stake(
+                            hotkey_ss58=hk,
+                            coldkey_ss58=coldkey_ss58,
+                            netuid=ni,
+                            block_hash=new_block_hash,
+                        )
+                        console.print(
+                            f"Subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]"
+                            f"{ni}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] "
+                            f"Hotkey: [{COLOR_PALETTE['GENERAL']['HOTKEY']}]{hk}"
+                            f"[/{COLOR_PALETTE['GENERAL']['HOTKEY']}] "
+                            f"Stake:\n"
+                            f"  [blue]{curr}[/blue] "
+                            f":arrow_right: "
+                            f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_stake}"
+                        )
+            else:
+                print_error(
+                    f":cross_mark: [red]Batch staking failed[/red]: {err_msg}",
+                    status=status,
+                )
+    else:
+        # Single operation path: use the existing per-operation extrinsics
+        with console.status(
+            f"\n:satellite: Staking on netuid(s): {netuids} ..."
+        ) as status:
+            for ni, staking_address, am, curr, price in operations:
+                if safe_staking and ni != 0:
+                    result = await safe_stake_extrinsic(
+                        netuid_=ni,
+                        amount_=am,
+                        current_stake=curr,
+                        hotkey_ss58_=staking_address,
+                        price_limit=price,
+                        status_=status,
+                    )
+                else:
+                    result = await stake_extrinsic(
+                        netuid_i=ni,
+                        amount_=am,
+                        current=curr,
+                        staking_address_ss58=staking_address,
+                        status_=status,
+                    )
+                success, er_msg, ext_receipt = result
+                successes[ni][staking_address] = success
+                error_messages[ni][staking_address] = er_msg
+                if success and ext_receipt:
+                    extrinsic_ids[ni][
+                        staking_address
+                    ] = await ext_receipt.get_extrinsic_identifier()
+
     if json_output:
         json_console.print_json(
             data={

{bittensor_cli-9.19.0 → bittensor_cli-9.20.0}/bittensor_cli/src/commands/stake/remove.py

@@ -329,43 +329,163 @@ async def unstake(
     if not unlock_key(wallet).success:
         return False
 
+    total_ops = len(unstake_operations)
+    use_batch = total_ops > 1
     successes = []
-    with console.status("\n:satellite: Performing unstaking operations...") as status:
-        for op in unstake_operations:
-            common_args = {
-                "wallet": wallet,
-                "subtensor": subtensor,
-                "netuid": op["netuid"],
-                "amount": op["amount_to_unstake"],
-                "hotkey_ss58": op["hotkey_ss58"],
-                "status": status,
-                "era": era,
-                "proxy": proxy,
-                "mev_protection": mev_protection,
-            }
 
-            if safe_staking and op["netuid"] != 0:
-                func = _safe_unstake_extrinsic
-                specific_args = {
-                    "price_limit": op["price_with_tolerance"],
-                    "allow_partial_stake": allow_partial_stake,
-                }
-            else:
-                func = _unstake_extrinsic
-                specific_args = {"current_stake": op["current_stake_balance"]}
+    if use_batch:
+        # Batch path: compose all calls, submit as a single Utility.batch_all transaction
+        with console.status(
+            f"\n:satellite: Batching {total_ops} unstake operations..."
+        ) as status:
+            batch_block_hash = await subtensor.substrate.get_chain_head()
+            current_balance = await subtensor.get_balance(
+                coldkey_ss58, block_hash=batch_block_hash
+            )
 
-            suc, ext_receipt = await func(**common_args, **specific_args)
-            ext_id = await ext_receipt.get_extrinsic_identifier() if suc else None
+            # compose_call with a block_hash does no I/O, so no need for gather
+            calls = []
+            for op in unstake_operations:
+                if safe_staking and op["netuid"] != 0:
+                    calls.append(
+                        await subtensor.substrate.compose_call(
+                            call_module="SubtensorModule",
+                            call_function="remove_stake_limit",
+                            call_params={
+                                "hotkey": op["hotkey_ss58"],
+                                "netuid": op["netuid"],
+                                "amount_unstaked": op["amount_to_unstake"].rao,
+                                "limit_price": op["price_with_tolerance"],
+                                "allow_partial": allow_partial_stake,
+                            },
+                            block_hash=batch_block_hash,
+                        )
+                    )
+                else:
+                    calls.append(
+                        await subtensor.substrate.compose_call(
+                            call_module="SubtensorModule",
+                            call_function="remove_stake",
+                            call_params={
+                                "hotkey": op["hotkey_ss58"],
+                                "netuid": op["netuid"],
+                                "amount_unstaked": op["amount_to_unstake"].rao,
+                            },
+                            block_hash=batch_block_hash,
+                        )
+                    )
 
-            successes.append(
-                {
+            success, err_msg, response = await subtensor.sign_and_send_batch_extrinsic(
+                calls=list(calls),
+                wallet=wallet,
+                era={"period": era},
+                proxy=proxy,
+                mev_protection=mev_protection,
+                block_hash=batch_block_hash,
+            )
+
+            if success and mev_protection:
+                inner_hash = err_msg
+                success, mev_error, response = await wait_for_extrinsic_by_hash(
+                    subtensor=subtensor,
+                    extrinsic_hash=inner_hash,
+                    submit_block_hash=response.block_hash,
+                    status=status,
+                )
+                if not success:
+                    err_msg = mev_error
+
+            ext_id = (
+                await response.get_extrinsic_identifier()
+                if success and response
+                else None
+            )
+
+            for op in unstake_operations:
+                successes.append(
+                    {
+                        "netuid": op["netuid"],
+                        "hotkey_ss58": op["hotkey_ss58"],
+                        "unstake_amount": op["amount_to_unstake"].tao,
+                        "success": success,
+                        "extrinsic_identifier": ext_id,
+                    }
+                )
+
+            if success:
+                if not json_output:
+                    await print_extrinsic_id(response)
+                    new_block_hash = await subtensor.substrate.get_chain_head()
+                    new_balance = await subtensor.get_balance(
+                        coldkey_ss58, block_hash=new_block_hash
+                    )
+                    print_success(
+                        f"Batch finalized. Unstaked across {total_ops} operations."
+                    )
+                    console.print(
+                        f"Balance:\n  [blue]{current_balance}[/blue] :arrow_right: "
+                        f"[{COLOR_PALETTE.S.AMOUNT}]{new_balance}"
+                    )
+                    for op in unstake_operations:
+                        new_stake = await subtensor.get_stake(
+                            hotkey_ss58=op["hotkey_ss58"],
+                            coldkey_ss58=coldkey_ss58,
+                            netuid=op["netuid"],
+                            block_hash=new_block_hash,
+                        )
+                        console.print(
+                            f"Subnet: [{COLOR_PALETTE.G.SUBHEAD}]{op['netuid']}"
+                            f"[/{COLOR_PALETTE.G.SUBHEAD}] "
+                            f"Hotkey: [{COLOR_PALETTE.G.HK}]{op['hotkey_ss58']}"
+                            f"[/{COLOR_PALETTE.G.HK}] "
+                            f"Stake:\n  [blue]{op['current_stake_balance']}[/blue] "
+                            f":arrow_right: [{COLOR_PALETTE.S.AMOUNT}]{new_stake}"
+                        )
+            else:
+                print_error(
+                    f":cross_mark: [red]Batch unstaking failed[/red]: {err_msg}",
+                    status=status,
+                )
+    else:
+        # Single operation path: use the existing per-operation extrinsics
+        with console.status(
+            "\n:satellite: Performing unstaking operations..."
+        ) as status:
+            for op in unstake_operations:
+                common_args = {
+                    "wallet": wallet,
+                    "subtensor": subtensor,
                     "netuid": op["netuid"],
+                    "amount": op["amount_to_unstake"],
                     "hotkey_ss58": op["hotkey_ss58"],
-                    "unstake_amount": op["amount_to_unstake"].tao,
-                    "success": suc,
-                    "extrinsic_identifier": ext_id,
+                    "status": status,
+                    "era": era,
+                    "proxy": proxy,
+                    "mev_protection": mev_protection,
                 }
-            )
+
+                if safe_staking and op["netuid"] != 0:
+                    func = _safe_unstake_extrinsic
+                    specific_args = {
+                        "price_limit": op["price_with_tolerance"],
+                        "allow_partial_stake": allow_partial_stake,
+                    }
+                else:
+                    func = _unstake_extrinsic
+                    specific_args = {"current_stake": op["current_stake_balance"]}
+
+                suc, ext_receipt = await func(**common_args, **specific_args)
+                ext_id = await ext_receipt.get_extrinsic_identifier() if suc else None
+
+                successes.append(
+                    {
+                        "netuid": op["netuid"],
+                        "hotkey_ss58": op["hotkey_ss58"],
+                        "unstake_amount": op["amount_to_unstake"].tao,
+                        "success": suc,
+                        "extrinsic_identifier": ext_id,
+                    }
+                )
 
     console.print(
         f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]Unstaking operations completed."
@@ -504,7 +624,7 @@ async def unstake_all(
             stake_amount = stake.stake
 
             try:
-                current_price = subnet_info.price.tao
+                _ = subnet_info.price.tao
                 extrinsic_type = (
                     "unstake_all" if not unstake_all_alpha else "unstake_all_alpha"
                 )
@@ -554,24 +674,101 @@ async def unstake_all(
     if not unlock_key(wallet).success:
         return
     successes = {}
-    with console.status("Unstaking all stakes...") as status:
-        for hotkey_ss58 in hotkey_ss58s:
-            success, ext_receipt = await _unstake_all_extrinsic(
+    use_batch = len(hotkey_ss58s) > 1
+
+    if use_batch:
+        # Batch path: compose unstake_all calls for all hotkeys into one transaction
+        with console.status(
+            f"Batching unstake-all for {len(hotkey_ss58s)} hotkeys..."
+        ) as status:
+            batch_block_hash = await subtensor.substrate.get_chain_head()
+            call_function = "unstake_all_alpha" if unstake_all_alpha else "unstake_all"
+            # compose_call with a block_hash does no I/O, so no need for gather
+            calls = []
+            for hk in hotkey_ss58s:
+                calls.append(
+                    await subtensor.substrate.compose_call(
+                        call_module="SubtensorModule",
+                        call_function=call_function,
+                        call_params={"hotkey": hk},
+                        block_hash=batch_block_hash,
+                    )
+                )
+
+            success, err_msg, response = await subtensor.sign_and_send_batch_extrinsic(
+                calls=list(calls),
                 wallet=wallet,
-                subtensor=subtensor,
-                hotkey_ss58=hotkey_ss58,
-                hotkey_name=hotkey_names.get(hotkey_ss58, hotkey_ss58),
-                unstake_all_alpha=unstake_all_alpha,
-                status=status,
-                era=era,
+                era={"period": era},
                 proxy=proxy,
                 mev_protection=mev_protection,
+                block_hash=batch_block_hash,
             )
-            ext_id = await ext_receipt.get_extrinsic_identifier() if success else None
-            successes[hotkey_ss58] = {
-                "success": success,
-                "extrinsic_identifier": ext_id,
-            }
+
+            if success and mev_protection:
+                inner_hash = err_msg
+                success, mev_error, response = await wait_for_extrinsic_by_hash(
+                    subtensor=subtensor,
+                    extrinsic_hash=inner_hash,
+                    submit_block_hash=response.block_hash,
+                    status=status,
+                )
+                if not success:
+                    err_msg = mev_error
+
+            ext_id = (
+                await response.get_extrinsic_identifier()
+                if success and response
+                else None
+            )
+
+            for hk in hotkey_ss58s:
+                successes[hk] = {
+                    "success": success,
+                    "extrinsic_identifier": ext_id,
+                }
+
+            if success:
+                await print_extrinsic_id(response)
+                msg_modifier = "Alpha " if unstake_all_alpha else ""
+                new_block_hash = await subtensor.substrate.get_chain_head()
+                new_balance = await subtensor.get_balance(
+                    coldkey_ss58, block_hash=new_block_hash
+                )
+                print_success(
+                    f"Batch finalized. Unstaked all {msg_modifier}stakes "
+                    f"from {len(hotkey_ss58s)} hotkeys."
+                )
+                console.print(
+                    f"Balance:\n  [blue]{current_wallet_balance}[/blue] "
+                    f":arrow_right: [{COLOR_PALETTE.S.AMOUNT}]{new_balance}"
+                )
+            else:
+                print_error(
+                    f":cross_mark: [red]Batch unstake-all failed[/red]: {err_msg}",
+                    status=status,
+                )
+    else:
+        # Single hotkey path: use existing per-hotkey extrinsic
+        with console.status("Unstaking all stakes...") as status:
+            for hotkey_ss58 in hotkey_ss58s:
+                success, ext_receipt = await _unstake_all_extrinsic(
+                    wallet=wallet,
+                    subtensor=subtensor,
+                    hotkey_ss58=hotkey_ss58,
+                    hotkey_name=hotkey_names.get(hotkey_ss58, hotkey_ss58),
+                    unstake_all_alpha=unstake_all_alpha,
+                    status=status,
+                    era=era,
+                    proxy=proxy,
+                    mev_protection=mev_protection,
+                )
+                ext_id = (
+                    await ext_receipt.get_extrinsic_identifier() if success else None
+                )
+                successes[hotkey_ss58] = {
+                    "success": success,
+                    "extrinsic_identifier": ext_id,
+                }
     if json_output:
         json_console.print(json.dumps({"success": successes}))
 

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

@@ -2224,7 +2224,7 @@ async def announce_coldkey_swap(
         console.print(details_table)
         console.print(
             f"\n[dim]After the delay, run:"
-            f"\n[green]btcli wallet swap-coldkey execute --new-coldkey {new_coldkey_ss58}[/green]"
+            f"\n[green]btcli wallet swap-coldkey execute --new-coldkey {new_coldkey_ss58} --wallet-name {wallet.name}[/green]"
         )
 
     return True
@@ -2345,6 +2345,134 @@ async def dispute_coldkey_swap(
     return True
 
 
+async def clear_coldkey_swap_announcement(
+    wallet: Wallet,
+    subtensor: SubtensorInterface,
+    decline: bool = False,
+    quiet: bool = False,
+    prompt: bool = True,
+    mev_protection: bool = False,
+) -> bool:
+    """Clear (withdraw) a pending coldkey swap announcement.
+
+    The announcement can only be cleared after the reannouncement delay has elapsed
+    past the execution block, and the swap must not be disputed.
+
+    Args:
+        wallet: Wallet that owns the announcement (must be the announcing coldkey).
+        subtensor: Connection to the Bittensor network.
+        decline: If True, default to declining at confirmation prompt.
+        quiet: If True, skip confirmation prompts and proceed.
+        prompt: If True, show confirmation prompts.
+        mev_protection: If True, encrypt the extrinsic with MEV protection.
+
+    Returns:
+        bool: True if the clear extrinsic was included successfully, else False.
+    """
+    block_hash = await subtensor.substrate.get_chain_head()
+    announcement, dispute, current_block, reannounce_delay = await asyncio.gather(
+        subtensor.get_coldkey_swap_announcement(
+            wallet.coldkeypub.ss58_address, block_hash=block_hash
+        ),
+        subtensor.get_coldkey_swap_dispute(
+            wallet.coldkeypub.ss58_address, block_hash=block_hash
+        ),
+        subtensor.substrate.get_block_number(block_hash=block_hash),
+        subtensor.get_coldkey_swap_reannouncement_delay(block_hash=block_hash),
+    )
+
+    if not announcement:
+        print_error(
+            f"No coldkey swap announcement found for {wallet.coldkeypub.ss58_address}.\n"
+            "Nothing to clear."
+        )
+        return False
+
+    if dispute is not None:
+        console.print(
+            f"[yellow]Swap is disputed at block {dispute}.[/yellow] "
+            "Cannot clear a disputed announcement."
+        )
+        return False
+
+    clear_block = announcement.execution_block + reannounce_delay
+    if current_block < clear_block:
+        remaining = clear_block - current_block
+        console.print(
+            f"[yellow]Cannot clear yet.[/yellow] "
+            f"You can clear after block {clear_block} ({blocks_to_duration(remaining)} from now).\n"
+            f"Current block: {current_block}"
+        )
+        return False
+
+    info = create_key_value_table("Clear Coldkey Swap Announcement\n")
+    info.add_row(
+        "Coldkey", f"[{COLORS.G.CK}]{wallet.coldkeypub.ss58_address}[/{COLORS.G.CK}]"
+    )
+    info.add_row("Announced Hash", f"[dim]{announcement.new_coldkey_hash}[/dim]")
+    info.add_row("Execution Block", str(announcement.execution_block))
+    info.add_row(
+        "Status",
+        "[yellow]Pending[/yellow]"
+        if current_block < announcement.execution_block
+        else "[green]Ready[/green]",
+    )
+    console.print(info)
+
+    if prompt and not confirm_action(
+        "Proceed with clearing this swap announcement?",
+        decline=decline,
+        quiet=quiet,
+    ):
+        return False
+
+    if not unlock_key(wallet).success:
+        return False
+
+    with console.status(
+        ":satellite: Clearing coldkey swap announcement on-chain..."
+    ) as status:
+        call = await subtensor.substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function="clear_coldkey_swap_announcement",
+            call_params={},
+        )
+        success, err_msg, ext_receipt = await subtensor.sign_and_send_extrinsic(
+            call,
+            wallet,
+            wait_for_inclusion=True,
+            wait_for_finalization=True,
+            mev_protection=mev_protection,
+        )
+
+        if not success:
+            print_error(f"Failed to clear coldkey swap announcement: {err_msg}")
+            return False
+
+        if mev_protection:
+            inner_hash = err_msg
+            mev_success, mev_error, ext_receipt = await wait_for_extrinsic_by_hash(
+                subtensor=subtensor,
+                extrinsic_hash=inner_hash,
+                submit_block_hash=ext_receipt.block_hash,
+                status=status,
+            )
+            if not mev_success:
+                print_error(
+                    f"Failed to clear coldkey swap announcement: {mev_error}",
+                    status=status,
+                )
+                return False
+
+        print_success("[dark_sea_green3]Coldkey swap announcement cleared.")
+        await print_extrinsic_id(ext_receipt)
+
+    console.print(
+        "\n[dim]Your coldkey is no longer locked by a pending swap announcement.[/dim]"
+    )
+    return True
+
+
 async def execute_coldkey_swap(
     wallet: Wallet,
     subtensor: SubtensorInterface,
@@ -2506,10 +2634,11 @@ async def check_swap_status(
     """
     block_hash = await subtensor.substrate.get_chain_head()
     if origin_ss58:
-        announcement, dispute, current_block = await asyncio.gather(
+        announcement, dispute, current_block, reannounce_delay = await asyncio.gather(
             subtensor.get_coldkey_swap_announcement(origin_ss58, block_hash=block_hash),
             subtensor.get_coldkey_swap_dispute(origin_ss58, block_hash=block_hash),
             subtensor.substrate.get_block_number(block_hash=block_hash),
+            subtensor.get_coldkey_swap_reannouncement_delay(block_hash=block_hash),
         )
         if not announcement:
             console.print(
@@ -2521,10 +2650,11 @@ async def check_swap_status(
         disputes = [(origin_ss58, dispute)] if dispute is not None else []
 
     else:
-        announcements, disputes, current_block = await asyncio.gather(
+        announcements, disputes, current_block, reannounce_delay = await asyncio.gather(
             subtensor.get_coldkey_swap_announcements(block_hash=block_hash),
             subtensor.get_coldkey_swap_disputes(block_hash=block_hash),
             subtensor.substrate.get_block_number(block_hash=block_hash),
+            subtensor.get_coldkey_swap_reannouncement_delay(block_hash=block_hash),
         )
         if not announcements:
             console.print(
@@ -2563,6 +2693,7 @@ async def check_swap_status(
         Column("Execution Block", justify="right", style="dark_sea_green3"),
         Column("Time Remaining", justify="right", style="yellow"),
         Column("Status", justify="center", style="green"),
+        Column("Clear Announcement", justify="right", style="yellow"),
         title=f"\n[{COLOR_PALETTE['GENERAL']['HEADER']}]Pending Coldkey Swap Announcements\nCurrent Block: {current_block}\n",
         show_header=True,
         show_edge=False,
@@ -2577,18 +2708,28 @@ async def check_swap_status(
     for announcement in announcements:
         dispute_block = dispute_map.get(announcement.coldkey)
         remaining_blocks = announcement.execution_block - current_block
+        clear_block = announcement.execution_block + reannounce_delay
+        clear_remaining = clear_block - current_block
         if dispute_block is not None:
             status = "[red]Disputed[/red]"
             time_str = f"Disputed @ {dispute_block}"
             status_label = "disputed"
+            clear_str = "[red]Disputed[/red]"
         elif remaining_blocks <= 0:
             status = "Ready"
             time_str = "[green]Ready[/green]"
             status_label = "ready"
+            if clear_remaining <= 0:
+                clear_str = "[green]Ready[/green]"
+            else:
+                clear_str = (
+                    f"Block {clear_block} ({blocks_to_duration(clear_remaining)})"
+                )
         else:
             status = "Pending"
             time_str = blocks_to_duration(remaining_blocks)
             status_label = "pending"
+            clear_str = f"Block {clear_block} ({blocks_to_duration(clear_remaining)})"
         hash_display = f"{announcement.new_coldkey_hash[:12]}...{announcement.new_coldkey_hash[-6:]}"
 
         table.add_row(
@@ -2597,6 +2738,7 @@ async def check_swap_status(
             str(announcement.execution_block),
             time_str,
             status,
+            clear_str,
         )
 
         payload["announcements"].append(
@@ -2607,6 +2749,8 @@ async def check_swap_status(
                 "status": status_label,
                 "time_remaining_blocks": max(0, remaining_blocks),
                 "disputed_block": dispute_block,
+                "clear_block": clear_block,
+                "clear_remaining_blocks": max(0, clear_remaining),
             }
         )
 
@@ -2617,5 +2761,7 @@ async def check_swap_status(
     console.print(table)
     console.print(
         "\n[dim]To execute a ready swap:[/dim] "
-        "[green]btcli wallet swap-coldkey execute[/green]"
+        "[green]btcli wallet swap-coldkey execute[/green]\n"
+        "[dim]To clear (withdraw) an announcement:[/dim] "
+        "[green]btcli wallet swap-coldkey clear[/green]"
     )

{bittensor_cli-9.19.0 → bittensor_cli-9.20.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "bittensor-cli"
-version = "9.19.0"
+version = "9.20.0"
 description = "Bittensor CLI"
 readme = "README.md"
 authors = [