From 9fbb88c883628c9ea029c2188df39eca1bcea189 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Tue, 27 May 2025 18:38:12 -0700
Subject: [PATCH 01/20] add `unstake_all_extrinsic`s

---
 .../core/extrinsics/asyncex/unstaking.py      | 105 +++++++++++++----
 bittensor/core/extrinsics/unstaking.py        | 109 ++++++++++++++----
 2 files changed, 166 insertions(+), 48 deletions(-)

diff --git a/bittensor/core/extrinsics/asyncex/unstaking.py b/bittensor/core/extrinsics/asyncex/unstaking.py
index 0d0bf6670e..c9d7d8652d 100644
--- a/bittensor/core/extrinsics/asyncex/unstaking.py
+++ b/bittensor/core/extrinsics/asyncex/unstaking.py
@@ -30,22 +30,21 @@ async def unstake_extrinsic(
     """Removes stake into the wallet coldkey from the specified hotkey ``uid``.
 
     Args:
-        subtensor (bittensor.core.async_subtensor.AsyncSubtensor): AsyncSubtensor instance.
-        wallet (bittensor_wallet.Wallet): Bittensor wallet object.
-        hotkey_ss58 (Optional[str]): The ``ss58`` address of the hotkey to unstake from. By default, the wallet hotkey
-            is used.
-        netuid (Optional[int]): The subnet uid to unstake from.
-        amount (Union[Balance, float]): Amount to stake as Bittensor balance, or ``float`` interpreted as Tao.
-        wait_for_inclusion (bool): If set, waits for the extrinsic to enter a block before returning ``True``, or
-            returns ``False`` if the extrinsic fails to enter the block within the timeout.
-        wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning
-            ``True``, or returns ``False`` if the extrinsic fails to be finalized within the timeout.
+        subtensor: AsyncSubtensor instance.
+        wallet: Bittensor wallet object.
+        hotkey_ss58: The ``ss58`` address of the hotkey to unstake from. By default, the wallet hotkey is used.
+        netuid: The subnet uid to unstake from.
+        amount: Amount to stake as Bittensor balance, or ``float`` interpreted as Tao.
+        wait_for_inclusion: If set, waits for the extrinsic to enter a block before returning ``True``, or returns
+            ``False`` if the extrinsic fails to enter the block within the timeout.
+        wait_for_finalization: If set, waits for the extrinsic to be finalized on the chain before returning ``True``,
+            or returns ``False`` if the extrinsic fails to be finalized within the timeout.
         safe_staking: If true, enables price safety checks
         allow_partial_stake: If true, allows partial unstaking if price tolerance exceeded
         rate_tolerance: Maximum allowed price decrease percentage (0.005 = 0.5%)
-        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted.
-            If the transaction is not included in a block within that number of blocks, it will expire and be rejected.
-            You can think of it as an expiration date for the transaction.
+        period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+            transaction is not included in a block within that number of blocks, it will expire and be rejected. You can
+            think of it as an expiration date for the transaction.
         unstake_all: If true, unstakes all tokens. Default is ``False``.
 
     Returns:
@@ -200,6 +199,66 @@ async def unstake_extrinsic(
         return False
 
 
+async def unstake_all_extrinsic(
+    subtensor: "AsyncSubtensor",
+    wallet: "Wallet",
+    hotkey_ss58: str,
+    netuid: int,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+    period: Optional[int] = None,
+) -> tuple[bool, str]:
+    """Unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
+
+    Arguments:
+        subtensor: Subtensor instance.
+        wallet: The wallet of the stake owner.
+        hotkey_ss58: The SS58 address of the hotkey to unstake from.
+        netuid: The unique identifier of the subnet.
+        wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
+        wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
+        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's
+            submitted. If the transaction is not included in a block within that number of blocks, it will expire
+            and be rejected. You can think of it as an expiration date for the transaction. Default is `None`.
+
+    Returns:
+        tuple[bool, str]:
+            A tuple containing:
+            - `True` and a success message if the unstake operation succeeded;
+            - `False` and an error message otherwise.
+    """
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False, unlock.message
+
+    call_params = {
+        "hotkey": hotkey_ss58,
+        "netuids": [netuid],
+    }
+
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="unstake_all",
+        call_params=call_params,
+    )
+
+    success, message = await subtensor.sign_and_send_extrinsic(
+        call=call,
+        wallet=wallet,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+        nonce_key="coldkeypub",
+        sign_with="coldkey",
+        use_nonce=True,
+        period=period,
+        raise_error=True,
+    )
+    if not wait_for_finalization and not wait_for_inclusion:
+        return True, "Not waiting for finalization or inclusion."
+
+    return success, message
+
+
 async def unstake_multiple_extrinsic(
     subtensor: "AsyncSubtensor",
     wallet: "Wallet",
@@ -214,18 +273,18 @@ async def unstake_multiple_extrinsic(
     """Removes stake from each ``hotkey_ss58`` in the list, using each amount, to a common coldkey.
 
     Args:
-        subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
-        wallet (bittensor_wallet.Wallet): The wallet with the coldkey to unstake to.
-        hotkey_ss58s (List[str]): List of hotkeys to unstake from.
-        netuids (List[int]): List of netuids to unstake from.
-        amounts (List[Union[Balance, float]]): List of amounts to unstake. If ``None``, unstake all.
-        wait_for_inclusion (bool): If set, waits for the extrinsic to enter a block before returning ``True``, or
+        subtensor: Subtensor instance.
+        wallet: The wallet with the coldkey to unstake to.
+        hotkey_ss58s: List of hotkeys to unstake from.
+        netuids: List of netuids to unstake from.
+        amounts: List of amounts to unstake. If ``None``, unstake all.
+        wait_for_inclusion: If set, waits for the extrinsic to enter a block before returning ``True``, or
             returns ``False`` if the extrinsic fails to enter the block within the timeout.
-        wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning
+        wait_for_finalization: If set, waits for the extrinsic to be finalized on the chain before returning
             ``True``, or returns ``False`` if the extrinsic fails to be finalized within the timeout.
-        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted.
-            If the transaction is not included in a block within that number of blocks, it will expire and be rejected.
-            You can think of it as an expiration date for the transaction.
+        period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+            transaction is not included in a block within that number of blocks, it will expire and be rejected. You can
+            think of it as an expiration date for the transaction.
         unstake_all: If true, unstakes all tokens. Default is ``False``.
 
     Returns:
diff --git a/bittensor/core/extrinsics/unstaking.py b/bittensor/core/extrinsics/unstaking.py
index 9e252cdaaf..c596ff4cc5 100644
--- a/bittensor/core/extrinsics/unstaking.py
+++ b/bittensor/core/extrinsics/unstaking.py
@@ -29,22 +29,21 @@ def unstake_extrinsic(
     """Removes stake into the wallet coldkey from the specified hotkey ``uid``.
 
     Args:
-        subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
-        wallet (bittensor_wallet.Wallet): Bittensor wallet object.
-        hotkey_ss58 (Optional[str]): The ``ss58`` address of the hotkey to unstake from. By default, the wallet hotkey
-            is used.
-        netuid (Optional[int]): Subnet unique id.
-        amount (Union[Balance]): Amount to stake as Bittensor balance.
-        wait_for_inclusion (bool): If set, waits for the extrinsic to enter a block before returning ``True``, or
-            returns ``False`` if the extrinsic fails to enter the block within the timeout.
-        wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning
-            ``True``, or returns ``False`` if the extrinsic fails to be finalized within the timeout.
-        safe_staking: If true, enables price safety checks
+        subtensor: Subtensor instance.
+        wallet: Bittensor wallet object.
+        hotkey_ss58: The ``ss58`` address of the hotkey to unstake from. By default, the wallet hotkey is used.
+        netuid: Subnet unique id.
+        amount: Amount to stake as Bittensor balance.
+        wait_for_inclusion: If set, waits for the extrinsic to enter a block before returning ``True``, or returns
+            ``False`` if the extrinsic fails to enter the block within the timeout.
+        wait_for_finalization: If set, waits for the extrinsic to be finalized on the chain before returning ``True``,
+            or returns ``False`` if the extrinsic fails to be finalized within the timeout.
+        safe_staking: If true, enables price safety checks.
         allow_partial_stake: If true, allows partial unstaking if price tolerance exceeded
         rate_tolerance: Maximum allowed price decrease percentage (0.005 = 0.5%)
-        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted.
-            If the transaction is not included in a block within that number of blocks, it will expire and be rejected.
-            You can think of it as an expiration date for the transaction.
+        period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+            transaction is not included in a block within that number of blocks, it will expire and be rejected. You can
+            think of it as an expiration date for the transaction.
         unstake_all: If true, unstakes all tokens. Default is ``False``.
 
     Returns:
@@ -197,6 +196,66 @@ def unstake_extrinsic(
         return False
 
 
+def unstake_all_extrinsic(
+    subtensor: "Subtensor",
+    wallet: "Wallet",
+    hotkey_ss58: str,
+    netuid: int,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+    period: Optional[int] = None,
+) -> tuple[bool, str]:
+    """Unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
+
+    Arguments:
+        subtensor: Subtensor instance.
+        wallet: The wallet of the stake owner.
+        hotkey_ss58: The SS58 address of the hotkey to unstake from.
+        netuid: The unique identifier of the subnet.
+        wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
+        wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
+        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's
+            submitted. If the transaction is not included in a block within that number of blocks, it will expire
+            and be rejected. You can think of it as an expiration date for the transaction. Default is `None`.
+
+    Returns:
+        tuple[bool, str]:
+            A tuple containing:
+            - `True` and a success message if the unstake operation succeeded;
+            - `False` and an error message otherwise.
+    """
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False, unlock.message
+
+    call_params = {
+        "hotkey": hotkey_ss58,
+        "netuids": [netuid],
+    }
+
+    call = subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="unstake_all",
+        call_params=call_params,
+    )
+
+    success, message = subtensor.sign_and_send_extrinsic(
+        call=call,
+        wallet=wallet,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+        nonce_key="coldkeypub",
+        sign_with="coldkey",
+        use_nonce=True,
+        period=period,
+        raise_error=True,
+    )
+    if not wait_for_finalization and not wait_for_inclusion:
+        return True, "Not waiting for finalization or inclusion."
+
+    return success, message
+
+
 def unstake_multiple_extrinsic(
     subtensor: "Subtensor",
     wallet: "Wallet",
@@ -211,18 +270,18 @@ def unstake_multiple_extrinsic(
     """Removes stake from each ``hotkey_ss58`` in the list, using each amount, to a common coldkey.
 
     Args:
-        subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
-        wallet (bittensor_wallet.Wallet): The wallet with the coldkey to unstake to.
-        hotkey_ss58s (List[str]): List of hotkeys to unstake from.
-        netuids (List[int]): List of subnets unique IDs to unstake from.
-        amounts (List[Balance]): List of amounts to unstake. If ``None``, unstake all.
-        wait_for_inclusion (bool): If set, waits for the extrinsic to enter a block before returning ``True``, or
+        subtensor: Subtensor instance.
+        wallet: The wallet with the coldkey to unstake to.
+        hotkey_ss58s: List of hotkeys to unstake from.
+        netuids: List of subnets unique IDs to unstake from.
+        amounts: List of amounts to unstake. If ``None``, unstake all.
+        wait_for_inclusion: If set, waits for the extrinsic to enter a block before returning ``True``, or
             returns ``False`` if the extrinsic fails to enter the block within the timeout.
-        wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning
-            ``True``, or returns ``False`` if the extrinsic fails to be finalized within the timeout.
-        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted.
-            If the transaction is not included in a block within that number of blocks, it will expire and be rejected.
-            You can think of it as an expiration date for the transaction.
+        wait_for_finalization: If set, waits for the extrinsic to be finalized on the chain before returning ``True``,
+            or returns ``False`` if the extrinsic fails to be finalized within the timeout.
+        period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+            transaction is not included in a block within that number of blocks, it will expire and be rejected. You can
+            think of it as an expiration date for the transaction.
         unstake_all: If true, unstakes all tokens. Default is ``False``.
 
     Returns:

From 341310647be9e15ed979cc1cdfac33dd03f2b8c1 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Tue, 27 May 2025 18:38:39 -0700
Subject: [PATCH 02/20] add extrinsic calls in Subtensor classes

---
 bittensor/core/async_subtensor.py | 125 +++++++++++++++++++++++-------
 bittensor/core/subtensor.py       | 120 ++++++++++++++++++++++------
 2 files changed, 192 insertions(+), 53 deletions(-)

diff --git a/bittensor/core/async_subtensor.py b/bittensor/core/async_subtensor.py
index 5525a1eb37..11922277a7 100644
--- a/bittensor/core/async_subtensor.py
+++ b/bittensor/core/async_subtensor.py
@@ -70,6 +70,7 @@
 )
 from bittensor.core.extrinsics.asyncex.transfer import transfer_extrinsic
 from bittensor.core.extrinsics.asyncex.unstaking import (
+    unstake_all_extrinsic,
     unstake_extrinsic,
     unstake_multiple_extrinsic,
 )
@@ -4474,23 +4475,22 @@ async def unstake(
             individual neuron stakes within the Bittensor network.
 
         Args:
-            wallet (bittensor_wallet.wallet): The wallet associated with the neuron from which the stake is being
-                removed.
-            hotkey_ss58 (Optional[str]): The ``SS58`` address of the hotkey account to unstake from.
-            netuid (Optional[int]): The unique identifier of the subnet.
-            amount (Balance): The amount of alpha to unstake. If not specified, unstakes all.
-            wait_for_inclusion (bool): Waits for the transaction to be included in a block.
-            wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain.
-            safe_staking (bool): If true, enables price safety checks to protect against fluctuating prices. The unstake
-                will only execute if the price change doesn't exceed the rate tolerance. Default is False.
-            allow_partial_stake (bool): If true and safe_staking is enabled, allows partial unstaking when
-                the full amount would exceed the price threshold. If false, the entire unstake fails if it would
-                exceed the threshold. Default is False.
-            rate_tolerance (float): The maximum allowed price change ratio when unstaking. For example,
-                0.005 = 0.5% maximum price decrease. Only used when safe_staking is True. Default is 0.005.
-            period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted. If
-                the transaction is not included in a block within that number of blocks, it will expire and be rejected.
-                You can think of it as an expiration date for the transaction.
+            wallet: The wallet associated with the neuron from which the stake is being removed.
+            hotkey_ss58: The ``SS58`` address of the hotkey account to unstake from.
+            netuid: The unique identifier of the subnet.
+            amount: The amount of alpha to unstake. If not specified, unstakes all.
+            wait_for_inclusion: Waits for the transaction to be included in a block.
+            wait_for_finalization: Waits for the transaction to be finalized on the blockchain.
+            safe_staking: If true, enables price safety checks to protect against fluctuating prices. The unstake will
+                only execute if the price change doesn't exceed the rate tolerance. Default is False.
+            allow_partial_stake: If true and safe_staking is enabled, allows partial unstaking when the full amount
+                would exceed the price threshold. If false, the entire unstake fails if it would exceed the threshold.
+                Default is False.
+            rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
+                price decrease. Only used when safe_staking is True. Default is 0.005.
+            period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+                transaction is not included in a block within that number of blocks, it will expire and be rejected. You
+                can think of it as an expiration date for the transaction.
             unstake_all: If true, unstakes all tokens. Default is ``False``. If `True` amount is ignored.
 
         Returns:
@@ -4515,6 +4515,77 @@ async def unstake(
             unstake_all=unstake_all,
         )
 
+    async def unstake_all(
+        self,
+        wallet: "Wallet",
+        hotkey_ss58: str,
+        netuid: int,
+        safe_unstaking: bool = False,
+        allow_partial_unstaking: bool = False,
+        rate_tolerance: float = 0.005,
+        wait_for_inclusion: bool = True,
+        wait_for_finalization: bool = False,
+        period: Optional[int] = None,
+    ) -> tuple[bool, str]:
+        """Unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
+
+        Arguments:
+            wallet: The wallet of the stake owner.
+            hotkey_ss58: The SS58 address of the hotkey to unstake from.
+            netuid: The unique identifier of the subnet.
+            safe_unstaking: If true, enables price safety checks to protect against fluctuating prices. The unstake
+                will only execute if the price change doesn't exceed the rate tolerance. Default is False.
+            allow_partial_unstaking: If true and safe_staking is enabled, allows partial unstaking when the full amount
+                would exceed the price tolerance. If false, the entire unstake fails if it would exceed the tolerance.
+                Default is False.
+            rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
+                price decrease. Only used when safe_staking is True. Default is 0.005.
+            wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
+            wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
+            period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+                transaction is not included in a block within that number of blocks, it will expire and be rejected. You
+                can think of it as an expiration date for the transaction. Default is `None`.
+
+        Returns:
+            tuple[bool, str]:
+                A tuple containing:
+                - `True` and a success message if the unstake operation succeeded;
+                - `False` and an error message otherwise.
+
+        Example:
+            # If you would like to unstake all stakes in all subnets:
+            import bittensor as bt
+
+            subtensor = bt.Subtensor()
+            wallet = bt.Wallet("my_wallet")
+            netuid = 14
+            hotkey = "5%SOME_HOTKEY%"
+
+            wallet_stakes = subtensor.get_stake_info_for_coldkey(coldkey_ss58=wallet.coldkey.ss58_address)
+
+            for stake in wallet_stakes:
+                result = subtensor.unstake_all(
+                    wallet=wallet,
+                    hotkey_ss58=stake.hotkey_ss58,
+                    netuid=stake.netuid,
+                )
+                print(result)
+        """
+        if safe_unstaking:
+            raise NotImplementedError(
+                "Safe unstaking is not yet implemented for `unstale_all`."
+            )
+
+        return await unstake_all_extrinsic(
+            subtensor=self,
+            wallet=wallet,
+            hotkey_ss58=hotkey_ss58,
+            netuid=netuid,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+            period=period,
+        )
+
     async def unstake_multiple(
         self,
         wallet: "Wallet",
@@ -4531,17 +4602,15 @@ async def unstake_multiple(
             efficiently. This function is useful for managing the distribution of stakes across multiple neurons.
 
         Args:
-            wallet (bittensor_wallet.Wallet): The wallet linked to the coldkey from which the stakes are being
-                withdrawn.
-            hotkey_ss58s (List[str]): A list of hotkey ``SS58`` addresses to unstake from.
-            netuids (list[int]): Subnets unique IDs.
-            amounts (List[Union[Balance, float]]): The amounts of TAO to unstake from each hotkey. If not provided,
-                unstakes all available stakes.
-            wait_for_inclusion (bool): Waits for the transaction to be included in a block.
-            wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain.
-            period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted. If
-                the transaction is not included in a block within that number of blocks, it will expire and be rejected.
-                You can think of it as an expiration date for the transaction.
+            wallet: The wallet linked to the coldkey from which the stakes are being withdrawn.
+            hotkey_ss58s: A list of hotkey ``SS58`` addresses to unstake from.
+            netuids: Subnets unique IDs.
+            amounts: The amounts of TAO to unstake from each hotkey. If not provided, unstakes all available stakes.
+            wait_for_inclusion: Waits for the transaction to be included in a block.
+            wait_for_finalization: Waits for the transaction to be finalized on the blockchain.
+            period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+                transaction is not included in a block within that number of blocks, it will expire and be rejected. You
+                can think of it as an expiration date for the transaction.
             unstake_all: If true, unstakes all tokens. Default is ``False``. If `True` amounts are ignored.
 
         Returns:
diff --git a/bittensor/core/subtensor.py b/bittensor/core/subtensor.py
index 5c7241d4dc..848fc98223 100644
--- a/bittensor/core/subtensor.py
+++ b/bittensor/core/subtensor.py
@@ -73,6 +73,7 @@
 )
 from bittensor.core.extrinsics.transfer import transfer_extrinsic
 from bittensor.core.extrinsics.unstaking import (
+    unstake_all_extrinsic,
     unstake_extrinsic,
     unstake_multiple_extrinsic,
 )
@@ -2639,7 +2640,7 @@ def sign_and_send_extrinsic(
                 return True, ""
 
             if raise_error:
-                raise ChainError.from_error(response.error_message)
+                raise ChainError(format_error_message(response.error_message))
 
             return False, format_error_message(response.error_message)
 
@@ -3708,22 +3709,21 @@ def unstake(
             individual neuron stakes within the Bittensor network.
 
         Args:
-            wallet (bittensor_wallet.wallet): The wallet associated with the neuron from which the stake is being
-                removed.
-            hotkey_ss58 (Optional[str]): The ``SS58`` address of the hotkey account to unstake from.
-            netuid (Optional[int]): The unique identifier of the subnet.
-            amount (Balance): The amount of alpha to unstake. If not specified, unstakes all. Alpha amount.
-            wait_for_inclusion (bool): Waits for the transaction to be included in a block.
-            wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain.
-            safe_staking (bool): If true, enables price safety checks to protect against fluctuating prices. The unstake
+            wallet: The wallet associated with the neuron from which the stake is being removed.
+            hotkey_ss58: The ``SS58`` address of the hotkey account to unstake from.
+            netuid: The unique identifier of the subnet.
+            amount: The amount of alpha to unstake. If not specified, unstakes all. Alpha amount.
+            wait_for_inclusion: Waits for the transaction to be included in a block.
+            wait_for_finalization: Waits for the transaction to be finalized on the blockchain.
+            safe_staking: If true, enables price safety checks to protect against fluctuating prices. The unstake
                 will only execute if the price change doesn't exceed the rate tolerance. Default is False.
-            allow_partial_stake (bool): If true and safe_staking is enabled, allows partial unstaking when
-                the full amount would exceed the price tolerance. If false, the entire unstake fails if it would
-                exceed the tolerance. Default is False.
-            rate_tolerance (float): The maximum allowed price change ratio when unstaking. For example,
-                0.005 = 0.5% maximum price decrease. Only used when safe_staking is True. Default is 0.005.
-            period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted. If
-                the transaction is not included in a block within that number of blocks, it will expire and be rejected.
+            allow_partial_stake: If true and safe_staking is enabled, allows partial unstaking when the full amount
+                would exceed the price tolerance. If false, the entire unstake fails if it would exceed the tolerance.
+                Default is False.
+            rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
+                price decrease. Only used when safe_staking is True. Default is 0.005.
+            period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+                transaction is not included in a block within that number of blocks, it will expire and be rejected.
                 You can think of it as an expiration date for the transaction.
             unstake_all: If true, unstakes all tokens. Default is ``False``. If `True` amount is ignored.
 
@@ -3750,6 +3750,77 @@ def unstake(
             unstake_all=unstake_all,
         )
 
+    def unstake_all(
+        self,
+        wallet: "Wallet",
+        hotkey_ss58: str,
+        netuid: int,
+        safe_unstaking: bool = False,
+        allow_partial_unstaking: bool = False,
+        rate_tolerance: float = 0.005,
+        wait_for_inclusion: bool = True,
+        wait_for_finalization: bool = False,
+        period: Optional[int] = None,
+    ) -> tuple[bool, str]:
+        """Unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
+
+        Arguments:
+            wallet: The wallet of the stake owner.
+            hotkey_ss58: The SS58 address of the hotkey to unstake from.
+            netuid: The unique identifier of the subnet.
+            safe_unstaking: If true, enables price safety checks to protect against fluctuating prices. The unstake
+                will only execute if the price change doesn't exceed the rate tolerance. Default is False.
+            allow_partial_unstaking: If true and safe_staking is enabled, allows partial unstaking when the full amount
+                would exceed the price tolerance. If false, the entire unstake fails if it would exceed the tolerance.
+                Default is False.
+            rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
+                price decrease. Only used when safe_staking is True. Default is 0.005.
+            wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
+            wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
+            period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+                transaction is not included in a block within that number of blocks, it will expire and be rejected. You
+                can think of it as an expiration date for the transaction. Default is `None`.
+
+        Returns:
+            tuple[bool, str]:
+                A tuple containing:
+                - `True` and a success message if the unstake operation succeeded;
+                - `False` and an error message otherwise.
+
+        Example:
+            # If you would like to unstake all stakes in all subnets:
+            import bittensor as bt
+
+            subtensor = bt.Subtensor()
+            wallet = bt.Wallet("my_wallet")
+            netuid = 14
+            hotkey = "5%SOME_HOTKEY%"
+
+            wallet_stakes = subtensor.get_stake_info_for_coldkey(coldkey_ss58=wallet.coldkey.ss58_address)
+
+            for stake in wallet_stakes:
+                result = subtensor.unstake_all(
+                    wallet=wallet,
+                    hotkey_ss58=stake.hotkey_ss58,
+                    netuid=stake.netuid,
+                )
+                print(result)
+        """
+        if safe_unstaking:
+            raise NotImplementedError(
+                "Safe unstaking is not yet implemented for `unstale_all`."
+            )
+
+        return unstake_all_extrinsic(
+            subtensor=self,
+            wallet=wallet,
+            hotkey_ss58=hotkey_ss58,
+            netuid=netuid,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+            period=period,
+        )
+
     def unstake_multiple(
         self,
         wallet: "Wallet",
@@ -3766,16 +3837,15 @@ def unstake_multiple(
             efficiently. This function is useful for managing the distribution of stakes across multiple neurons.
 
         Args:
-            wallet (bittensor_wallet.Wallet): The wallet linked to the coldkey from which the stakes are being
+            wallet: The wallet linked to the coldkey from which the stakes are being
                 withdrawn.
-            hotkey_ss58s (List[str]): A list of hotkey ``SS58`` addresses to unstake from.
-            netuids (List[int]): The list of subnet uids.
-            amounts (List[Balance]): The amounts of TAO to unstake from each hotkey. If not provided,
-                unstakes all available stakes.
-            wait_for_inclusion (bool): Waits for the transaction to be included in a block.
-            wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain.
-            period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted. If
-                the transaction is not included in a block within that number of blocks, it will expire and be rejected.
+            hotkey_ss58s: A list of hotkey ``SS58`` addresses to unstake from.
+            netuids: The list of subnet uids.
+            amounts: The amounts of TAO to unstake from each hotkey. If not provided, unstakes all available stakes.
+            wait_for_inclusion: Waits for the transaction to be included in a block.
+            wait_for_finalization: Waits for the transaction to be finalized on the blockchain.
+            period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+                transaction is not included in a block within that number of blocks, it will expire and be rejected.
                 You can think of it as an expiration date for the transaction.
             unstake_all: If true, unstakes all tokens. Default is ``False``. If `True` amounts are ignored.
 

From eaf30730f8ee6b7ea5fabffcfb961fe1f5866ecb Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Wed, 28 May 2025 11:55:53 -0700
Subject: [PATCH 03/20] remove `allow_partial_unstaking` from `unstake_all`

---
 bittensor/core/async_subtensor.py | 4 ----
 bittensor/core/subtensor.py       | 4 ----
 2 files changed, 8 deletions(-)

diff --git a/bittensor/core/async_subtensor.py b/bittensor/core/async_subtensor.py
index 11922277a7..4dc9f48fdd 100644
--- a/bittensor/core/async_subtensor.py
+++ b/bittensor/core/async_subtensor.py
@@ -4521,7 +4521,6 @@ async def unstake_all(
         hotkey_ss58: str,
         netuid: int,
         safe_unstaking: bool = False,
-        allow_partial_unstaking: bool = False,
         rate_tolerance: float = 0.005,
         wait_for_inclusion: bool = True,
         wait_for_finalization: bool = False,
@@ -4535,9 +4534,6 @@ async def unstake_all(
             netuid: The unique identifier of the subnet.
             safe_unstaking: If true, enables price safety checks to protect against fluctuating prices. The unstake
                 will only execute if the price change doesn't exceed the rate tolerance. Default is False.
-            allow_partial_unstaking: If true and safe_staking is enabled, allows partial unstaking when the full amount
-                would exceed the price tolerance. If false, the entire unstake fails if it would exceed the tolerance.
-                Default is False.
             rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
                 price decrease. Only used when safe_staking is True. Default is 0.005.
             wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
diff --git a/bittensor/core/subtensor.py b/bittensor/core/subtensor.py
index 848fc98223..31bd888ac4 100644
--- a/bittensor/core/subtensor.py
+++ b/bittensor/core/subtensor.py
@@ -3756,7 +3756,6 @@ def unstake_all(
         hotkey_ss58: str,
         netuid: int,
         safe_unstaking: bool = False,
-        allow_partial_unstaking: bool = False,
         rate_tolerance: float = 0.005,
         wait_for_inclusion: bool = True,
         wait_for_finalization: bool = False,
@@ -3770,9 +3769,6 @@ def unstake_all(
             netuid: The unique identifier of the subnet.
             safe_unstaking: If true, enables price safety checks to protect against fluctuating prices. The unstake
                 will only execute if the price change doesn't exceed the rate tolerance. Default is False.
-            allow_partial_unstaking: If true and safe_staking is enabled, allows partial unstaking when the full amount
-                would exceed the price tolerance. If false, the entire unstake fails if it would exceed the tolerance.
-                Default is False.
             rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
                 price decrease. Only used when safe_staking is True. Default is 0.005.
             wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.

From 648bf17db418f5cb65b7328df80c0971b1b33691 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Tue, 17 Jun 2025 15:50:29 -0700
Subject: [PATCH 04/20] fix loging message format

---
 bittensor/core/extrinsics/transfer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bittensor/core/extrinsics/transfer.py b/bittensor/core/extrinsics/transfer.py
index a2ac8df11d..370efaed36 100644
--- a/bittensor/core/extrinsics/transfer.py
+++ b/bittensor/core/extrinsics/transfer.py
@@ -143,7 +143,7 @@ def transfer_extrinsic(
         logging.error(f"\t\tFor fee:\t[blue]{fee}[/blue]")
         return False
 
-    logging.info(":satellite: [magenta]Transferring...</magenta")
+    logging.info(":satellite: [magenta]Transferring...[/magenta]")
     success, block_hash, err_msg = _do_transfer(
         subtensor=subtensor,
         wallet=wallet,

From 9e143b836b5cbc0343ed81f456e2d5ecd7b15f48 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Tue, 17 Jun 2025 16:19:48 -0700
Subject: [PATCH 05/20] add unstake_all to SubtensorApi

---
 bittensor/core/subtensor_api/staking.py | 1 +
 bittensor/core/subtensor_api/utils.py   | 1 +
 2 files changed, 2 insertions(+)

diff --git a/bittensor/core/subtensor_api/staking.py b/bittensor/core/subtensor_api/staking.py
index 6ccce7fd4d..b0e8d3d472 100644
--- a/bittensor/core/subtensor_api/staking.py
+++ b/bittensor/core/subtensor_api/staking.py
@@ -21,4 +21,5 @@ def __init__(self, subtensor: Union["_Subtensor", "_AsyncSubtensor"]):
         self.get_stake_movement_fee = subtensor.get_stake_movement_fee
         self.get_unstake_fee = subtensor.get_unstake_fee
         self.unstake = subtensor.unstake
+        self.unstake_all = subtensor.unstake_all
         self.unstake_multiple = subtensor.unstake_multiple
diff --git a/bittensor/core/subtensor_api/utils.py b/bittensor/core/subtensor_api/utils.py
index f0f2ded013..8b45ab0d95 100644
--- a/bittensor/core/subtensor_api/utils.py
+++ b/bittensor/core/subtensor_api/utils.py
@@ -158,6 +158,7 @@ def add_legacy_methods(subtensor: "SubtensorApi"):
     subtensor.transfer_stake = subtensor._subtensor.transfer_stake
     subtensor.tx_rate_limit = subtensor._subtensor.tx_rate_limit
     subtensor.unstake = subtensor._subtensor.unstake
+    subtensor.unstake_all = subtensor._subtensor.unstake_all
     subtensor.unstake_multiple = subtensor._subtensor.unstake_multiple
     subtensor.wait_for_block = subtensor._subtensor.wait_for_block
     subtensor.weights = subtensor._subtensor.weights

From 054b4fa18e206fd115814e7841bedadab7e73944 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Tue, 17 Jun 2025 16:21:12 -0700
Subject: [PATCH 06/20] add `unstaking_all_limit_extrinsic` to extrinsic
 sub-package

---
 .../core/extrinsics/asyncex/unstaking.py      | 99 +++++++++++++++----
 bittensor/core/extrinsics/unstaking.py        | 69 ++++++++++++-
 2 files changed, 147 insertions(+), 21 deletions(-)

diff --git a/bittensor/core/extrinsics/asyncex/unstaking.py b/bittensor/core/extrinsics/asyncex/unstaking.py
index 90b3e93ddf..7e61dc96f1 100644
--- a/bittensor/core/extrinsics/asyncex/unstaking.py
+++ b/bittensor/core/extrinsics/asyncex/unstaking.py
@@ -236,27 +236,88 @@ async def unstake_all_extrinsic(
         "netuids": [netuid],
     }
 
-    call = await subtensor.substrate.compose_call(
-        call_module="SubtensorModule",
-        call_function="unstake_all",
-        call_params=call_params,
-    )
+    async with subtensor.substrate as substrate:
+        call = await substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function="unstake_all",
+            call_params=call_params,
+        )
 
-    success, message = await subtensor.sign_and_send_extrinsic(
-        call=call,
-        wallet=wallet,
-        wait_for_inclusion=wait_for_inclusion,
-        wait_for_finalization=wait_for_finalization,
-        nonce_key="coldkeypub",
-        sign_with="coldkey",
-        use_nonce=True,
-        period=period,
-        raise_error=True,
-    )
-    if not wait_for_finalization and not wait_for_inclusion:
-        return True, "Not waiting for finalization or inclusion."
+        return await subtensor.sign_and_send_extrinsic(
+            call=call,
+            wallet=wallet,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+            nonce_key="coldkeypub",
+            sign_with="coldkey",
+            use_nonce=True,
+            period=period,
+            raise_error=True,
+        )
+
+
+async def unstaking_all_limit_extrinsic(
+    subtensor: "AsyncSubtensor",
+    wallet: "Wallet",
+    hotkey_ss58: str,
+    netuid: int,
+    rate_tolerance: float = 0.005,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+    period: Optional[int] = None,
+) -> tuple[bool, str]:
+    """Safely unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
 
-    return success, message
+    Arguments:
+        subtensor: Subtensor instance.
+        wallet: The wallet of the stake owner.
+        hotkey_ss58: The SS58 address of the hotkey to unstake from.
+        netuid: The unique identifier of the subnet.
+        rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
+                price decrease. Only used when safe_staking is True. Default is 0.005.
+        wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
+        wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
+        period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+            transaction is not included in a block within that number of blocks, it will expire and be rejected. You can
+            think of it as an expiration date for the transaction. Default is `None`.
+
+    Returns:
+        tuple[bool, str]:
+            A tuple containing:
+            - `True` and a success message if the unstake operation succeeded;
+            - `False` and an error message otherwise.
+    """
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False, unlock.message
+
+    current_price = (await subtensor.subnet(netuid=netuid)).price
+    limit_price = current_price * (1 - rate_tolerance)
+
+    call_params = {
+        "hotkey": hotkey_ss58,
+        "netuid": netuid,
+        "limit_price": limit_price,
+    }
+
+    async with subtensor.substrate as substrate:
+        call = await substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function="remove_stake_full_limit",
+            call_params=call_params,
+        )
+
+        return await subtensor.sign_and_send_extrinsic(
+            call=call,
+            wallet=wallet,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+            nonce_key="coldkeypub",
+            sign_with="coldkey",
+            use_nonce=True,
+            period=period,
+            raise_error=True,
+        )
 
 
 async def unstake_multiple_extrinsic(
diff --git a/bittensor/core/extrinsics/unstaking.py b/bittensor/core/extrinsics/unstaking.py
index e81a509bb3..6286283a6c 100644
--- a/bittensor/core/extrinsics/unstaking.py
+++ b/bittensor/core/extrinsics/unstaking.py
@@ -152,7 +152,7 @@ def unstake_extrinsic(
             period=period,
         )
 
-        if success is True:  # If we successfully unstaked.
+        if success:  # If we successfully unstaked.
             # We only wait here if we expect finalization.
             if not wait_for_finalization and not wait_for_inclusion:
                 return True
@@ -205,7 +205,7 @@ def unstake_all_extrinsic(
     wait_for_finalization: bool = False,
     period: Optional[int] = None,
 ) -> tuple[bool, str]:
-    """Unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
+    """Unsafely unstakes all TAO/Alpha associated with the hotkey from the specified subnets on the Bittensor network.
 
     Arguments:
         subtensor: Subtensor instance.
@@ -256,6 +256,71 @@ def unstake_all_extrinsic(
     return success, message
 
 
+def unstaking_all_limit_extrinsic(
+    subtensor: "Subtensor",
+    wallet: "Wallet",
+    hotkey_ss58: str,
+    netuid: int,
+    rate_tolerance: float = 0.005,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+    period: Optional[int] = None,
+) -> tuple[bool, str]:
+    """Safely unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
+
+    Arguments:
+        subtensor: Subtensor instance.
+        wallet: The wallet of the stake owner.
+        hotkey_ss58: The SS58 address of the hotkey to unstake from.
+        netuid: The unique identifier of the subnet.
+        rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
+                price decrease. Only used when safe_staking is True. Default is 0.005.
+        wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
+        wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
+        period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+            transaction is not included in a block within that number of blocks, it will expire and be rejected. You can
+            think of it as an expiration date for the transaction. Default is `None`.
+
+    Returns:
+        tuple[bool, str]:
+            A tuple containing:
+            - `True` and a success message if the unstake operation succeeded;
+            - `False` and an error message otherwise.
+    """
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False, unlock.message
+
+    current_price = subtensor.subnet(netuid=netuid).price
+    limit_price = current_price * (1 - rate_tolerance)
+
+    call_params = {
+        "hotkey": hotkey_ss58,
+        "netuid": netuid,
+        "limit_price": limit_price,
+    }
+
+    call = subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="remove_stake_full_limit",
+        call_params=call_params,
+    )
+
+    success, message = subtensor.sign_and_send_extrinsic(
+        call=call,
+        wallet=wallet,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+        nonce_key="coldkeypub",
+        sign_with="coldkey",
+        use_nonce=True,
+        period=period,
+        raise_error=True,
+    )
+
+    return success, message
+
+
 def unstake_multiple_extrinsic(
     subtensor: "Subtensor",
     wallet: "Wallet",

From 9860c868ac7ac832d8f967a5ff795c4e9ce7d317 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Tue, 17 Jun 2025 16:21:45 -0700
Subject: [PATCH 07/20] update subtensor.unstake_all logic (safety/unsafety)

---
 bittensor/core/async_subtensor.py | 27 +++++++++++++++++++--------
 bittensor/core/subtensor.py       | 24 ++++++++++++++++++------
 2 files changed, 37 insertions(+), 14 deletions(-)

diff --git a/bittensor/core/async_subtensor.py b/bittensor/core/async_subtensor.py
index f25be7495e..0e3fd35541 100644
--- a/bittensor/core/async_subtensor.py
+++ b/bittensor/core/async_subtensor.py
@@ -75,6 +75,7 @@
 from bittensor.core.extrinsics.asyncex.transfer import transfer_extrinsic
 from bittensor.core.extrinsics.asyncex.unstaking import (
     unstake_all_extrinsic,
+    unstaking_all_limit_extrinsic,
     unstake_extrinsic,
     unstake_multiple_extrinsic,
 )
@@ -4620,18 +4621,18 @@ async def unstake_all(
                 - `False` and an error message otherwise.
 
         Example:
-            # If you would like to unstake all stakes in all subnets:
+            # If you would like to unstake all stakes in all subnets safely:
             import bittensor as bt
 
-            subtensor = bt.Subtensor()
+            subtensor = bt.AsyncSubtensor()
             wallet = bt.Wallet("my_wallet")
             netuid = 14
-            hotkey = "5%SOME_HOTKEY%"
+            hotkey = "5%SOME_HOTKEY_WHERE_IS_YOUR_STAKE_NOW%"
 
-            wallet_stakes = subtensor.get_stake_info_for_coldkey(coldkey_ss58=wallet.coldkey.ss58_address)
+            wallet_stakes = await subtensor.get_stake_info_for_coldkey(coldkey_ss58=wallet.coldkey.ss58_address)
 
             for stake in wallet_stakes:
-                result = subtensor.unstake_all(
+                result = await subtensor.unstake_all(
                     wallet=wallet,
                     hotkey_ss58=stake.hotkey_ss58,
                     netuid=stake.netuid,
@@ -4639,10 +4640,20 @@ async def unstake_all(
                 print(result)
         """
         if safe_unstaking:
-            raise NotImplementedError(
-                "Safe unstaking is not yet implemented for `unstale_all`."
+            return await unstaking_all_limit_extrinsic(
+                subtensor=self,
+                wallet=wallet,
+                hotkey_ss58=hotkey_ss58,
+                netuid=netuid,
+                rate_tolerance=rate_tolerance,
+                wait_for_inclusion=wait_for_inclusion,
+                wait_for_finalization=wait_for_finalization,
+                period=period,
+            )
+        if netuid != 0:
+            logging.debug(
+                f"Unstaking without Alpha price control from subnet [blue]#{netuid}[/blue]."
             )
-
         return await unstake_all_extrinsic(
             subtensor=self,
             wallet=wallet,
diff --git a/bittensor/core/subtensor.py b/bittensor/core/subtensor.py
index bca69bf231..6d532cf800 100644
--- a/bittensor/core/subtensor.py
+++ b/bittensor/core/subtensor.py
@@ -78,6 +78,7 @@
 from bittensor.core.extrinsics.transfer import transfer_extrinsic
 from bittensor.core.extrinsics.unstaking import (
     unstake_all_extrinsic,
+    unstaking_all_limit_extrinsic,
     unstake_extrinsic,
     unstake_multiple_extrinsic,
 )
@@ -2677,7 +2678,7 @@ def sign_and_send_extrinsic(
                 return True, ""
 
             if raise_error:
-                raise ChainError(format_error_message(response.error_message))
+                raise ChainError.from_error(response.error_message)
 
             return False, format_error_message(response.error_message)
 
@@ -3804,7 +3805,7 @@ def unstake_all(
         wallet: "Wallet",
         hotkey_ss58: str,
         netuid: int,
-        safe_unstaking: bool = False,
+        safe_unstaking: bool = True,
         rate_tolerance: float = 0.005,
         wait_for_inclusion: bool = True,
         wait_for_finalization: bool = False,
@@ -3817,7 +3818,7 @@ def unstake_all(
             hotkey_ss58: The SS58 address of the hotkey to unstake from.
             netuid: The unique identifier of the subnet.
             safe_unstaking: If true, enables price safety checks to protect against fluctuating prices. The unstake
-                will only execute if the price change doesn't exceed the rate tolerance. Default is False.
+                will only execute if the price change doesn't exceed the rate tolerance. Default is `True`.
             rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
                 price decrease. Only used when safe_staking is True. Default is 0.005.
             wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
@@ -3833,7 +3834,7 @@ def unstake_all(
                 - `False` and an error message otherwise.
 
         Example:
-            # If you would like to unstake all stakes in all subnets:
+            # If you would like to unstake all stakes in all subnets safely:
             import bittensor as bt
 
             subtensor = bt.Subtensor()
@@ -3852,10 +3853,21 @@ def unstake_all(
                 print(result)
         """
         if safe_unstaking:
-            raise NotImplementedError(
-                "Safe unstaking is not yet implemented for `unstale_all`."
+            return unstaking_all_limit_extrinsic(
+                subtensor=self,
+                wallet=wallet,
+                hotkey_ss58=hotkey_ss58,
+                netuid=netuid,
+                rate_tolerance=rate_tolerance,
+                wait_for_inclusion=wait_for_inclusion,
+                wait_for_finalization=wait_for_finalization,
+                period=period,
             )
 
+        if netuid != 0:
+            logging.debug(
+                f"Unstaking without Alpha price control from subnet [blue]#{netuid}[/blue]."
+            )
         return unstake_all_extrinsic(
             subtensor=self,
             wallet=wallet,

From fdc9f5812cac7868bef81e2ddfaa8c1c5c9a9d96 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Wed, 18 Jun 2025 00:33:22 -0700
Subject: [PATCH 08/20] docstrings + TODOs

---
 bittensor/core/async_subtensor.py              |  2 ++
 bittensor/core/extrinsics/asyncex/unstaking.py | 12 ++++++++----
 bittensor/core/extrinsics/unstaking.py         | 18 +++++++++++-------
 bittensor/core/subtensor.py                    |  2 ++
 4 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/bittensor/core/async_subtensor.py b/bittensor/core/async_subtensor.py
index 0e3fd35541..0c941c9dac 100644
--- a/bittensor/core/async_subtensor.py
+++ b/bittensor/core/async_subtensor.py
@@ -4638,6 +4638,8 @@ async def unstake_all(
                     netuid=stake.netuid,
                 )
                 print(result)
+
+            # TODO: add additional example with explanation
         """
         if safe_unstaking:
             return await unstaking_all_limit_extrinsic(
diff --git a/bittensor/core/extrinsics/asyncex/unstaking.py b/bittensor/core/extrinsics/asyncex/unstaking.py
index 7e61dc96f1..65c14a5cb3 100644
--- a/bittensor/core/extrinsics/asyncex/unstaking.py
+++ b/bittensor/core/extrinsics/asyncex/unstaking.py
@@ -48,8 +48,10 @@ async def unstake_extrinsic(
         unstake_all: If true, unstakes all tokens. Default is ``False``.
 
     Returns:
-        success (bool): Flag is ``True`` if extrinsic was finalized or included in the block. If we did not wait for
-            finalization / inclusion, the response is ``True``.
+        tuple[bool, str]:
+            A tuple containing:
+            - `True` and a success message if the unstake operation succeeded;
+            - `False` and an error message otherwise.
     """
     if amount and unstake_all:
         raise ValueError("Cannot specify both `amount` and `unstake_all`.")
@@ -349,8 +351,10 @@ async def unstake_multiple_extrinsic(
         unstake_all: If true, unstakes all tokens. Default is ``False``.
 
     Returns:
-        success (bool): Flag is ``True`` if extrinsic was finalized or included in the block. Flag is ``True`` if any
-            wallet was unstaked. If we did not wait for finalization / inclusion, the response is ``True``.
+        tuple[bool, str]:
+            A tuple containing:
+            - `True` and a success message if the unstake operation succeeded;
+            - `False` and an error message otherwise.
     """
     if amounts and unstake_all:
         raise ValueError("Cannot specify both `amounts` and `unstake_all`.")
diff --git a/bittensor/core/extrinsics/unstaking.py b/bittensor/core/extrinsics/unstaking.py
index 6286283a6c..bb706e5343 100644
--- a/bittensor/core/extrinsics/unstaking.py
+++ b/bittensor/core/extrinsics/unstaking.py
@@ -47,8 +47,10 @@ def unstake_extrinsic(
         unstake_all: If true, unstakes all tokens. Default is ``False``.
 
     Returns:
-        success (bool): Flag is ``True`` if extrinsic was finalized or included in the block. If we did not wait for
-            finalization / inclusion, the response is ``True``.
+        tuple[bool, str]:
+            A tuple containing:
+            - `True` and a success message if the unstake operation succeeded;
+            - `False` and an error message otherwise.
     """
     if amount and unstake_all:
         raise ValueError("Cannot specify both `amount` and `unstake_all`.")
@@ -214,9 +216,9 @@ def unstake_all_extrinsic(
         netuid: The unique identifier of the subnet.
         wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
         wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
-        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's
-            submitted. If the transaction is not included in a block within that number of blocks, it will expire
-            and be rejected. You can think of it as an expiration date for the transaction. Default is `None`.
+        period: The number of blocks during which the transaction will remain valid after it's submitted. If the
+            transaction is not included in a block within that number of blocks, it will expire and be rejected. You can
+            think of it as an expiration date for the transaction. Default is `None`.
 
     Returns:
         tuple[bool, str]:
@@ -350,8 +352,10 @@ def unstake_multiple_extrinsic(
         unstake_all: If true, unstakes all tokens. Default is ``False``.
 
     Returns:
-        success (bool): Flag is ``True`` if extrinsic was finalized or included in the block. Flag is ``True`` if any
-            wallet was unstaked. If we did not wait for finalization / inclusion, the response is ``True``.
+        tuple[bool, str]:
+            A tuple containing:
+            - `True` and a success message if the unstake operation succeeded;
+            - `False` and an error message otherwise.
     """
     if amounts and unstake_all:
         raise ValueError("Cannot specify both `amounts` and `unstake_all`.")
diff --git a/bittensor/core/subtensor.py b/bittensor/core/subtensor.py
index 6d532cf800..6838abab74 100644
--- a/bittensor/core/subtensor.py
+++ b/bittensor/core/subtensor.py
@@ -3851,6 +3851,8 @@ def unstake_all(
                     netuid=stake.netuid,
                 )
                 print(result)
+
+            # TODO: add additional example with explanation
         """
         if safe_unstaking:
             return unstaking_all_limit_extrinsic(

From 2be2ae67b266248a7471e24bd902aca6fb8639f0 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 07:59:31 -0700
Subject: [PATCH 09/20] update unstake_all_extrinsic regarding chain's changes.

---
 .../core/extrinsics/asyncex/unstaking.py      | 73 +++--------------
 bittensor/core/extrinsics/unstaking.py        | 78 +++----------------
 2 files changed, 19 insertions(+), 132 deletions(-)

diff --git a/bittensor/core/extrinsics/asyncex/unstaking.py b/bittensor/core/extrinsics/asyncex/unstaking.py
index 65c14a5cb3..11478f9fe0 100644
--- a/bittensor/core/extrinsics/asyncex/unstaking.py
+++ b/bittensor/core/extrinsics/asyncex/unstaking.py
@@ -204,64 +204,7 @@ async def unstake_extrinsic(
 async def unstake_all_extrinsic(
     subtensor: "AsyncSubtensor",
     wallet: "Wallet",
-    hotkey_ss58: str,
-    netuid: int,
-    wait_for_inclusion: bool = True,
-    wait_for_finalization: bool = False,
-    period: Optional[int] = None,
-) -> tuple[bool, str]:
-    """Unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
-
-    Arguments:
-        subtensor: Subtensor instance.
-        wallet: The wallet of the stake owner.
-        hotkey_ss58: The SS58 address of the hotkey to unstake from.
-        netuid: The unique identifier of the subnet.
-        wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
-        wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
-        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's
-            submitted. If the transaction is not included in a block within that number of blocks, it will expire
-            and be rejected. You can think of it as an expiration date for the transaction. Default is `None`.
-
-    Returns:
-        tuple[bool, str]:
-            A tuple containing:
-            - `True` and a success message if the unstake operation succeeded;
-            - `False` and an error message otherwise.
-    """
-    if not (unlock := unlock_key(wallet)).success:
-        logging.error(unlock.message)
-        return False, unlock.message
-
-    call_params = {
-        "hotkey": hotkey_ss58,
-        "netuids": [netuid],
-    }
-
-    async with subtensor.substrate as substrate:
-        call = await substrate.compose_call(
-            call_module="SubtensorModule",
-            call_function="unstake_all",
-            call_params=call_params,
-        )
-
-        return await subtensor.sign_and_send_extrinsic(
-            call=call,
-            wallet=wallet,
-            wait_for_inclusion=wait_for_inclusion,
-            wait_for_finalization=wait_for_finalization,
-            nonce_key="coldkeypub",
-            sign_with="coldkey",
-            use_nonce=True,
-            period=period,
-            raise_error=True,
-        )
-
-
-async def unstaking_all_limit_extrinsic(
-    subtensor: "AsyncSubtensor",
-    wallet: "Wallet",
-    hotkey_ss58: str,
+    hotkey: str,
     netuid: int,
     rate_tolerance: float = 0.005,
     wait_for_inclusion: bool = True,
@@ -273,7 +216,7 @@ async def unstaking_all_limit_extrinsic(
     Arguments:
         subtensor: Subtensor instance.
         wallet: The wallet of the stake owner.
-        hotkey_ss58: The SS58 address of the hotkey to unstake from.
+        hotkey: The SS58 address of the hotkey to unstake from.
         netuid: The unique identifier of the subnet.
         rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
                 price decrease. Only used when safe_staking is True. Default is 0.005.
@@ -293,15 +236,17 @@ async def unstaking_all_limit_extrinsic(
         logging.error(unlock.message)
         return False, unlock.message
 
-    current_price = (await subtensor.subnet(netuid=netuid)).price
-    limit_price = current_price * (1 - rate_tolerance)
-
     call_params = {
-        "hotkey": hotkey_ss58,
+        "hotkey": hotkey,
         "netuid": netuid,
-        "limit_price": limit_price,
+        "limit_price": None,
     }
 
+    if rate_tolerance:
+        current_price = (await subtensor.subnet(netuid=netuid)).price
+        limit_price = current_price * (1 - rate_tolerance)
+        call_params.update({"limit_price": limit_price})
+
     async with subtensor.substrate as substrate:
         call = await substrate.compose_call(
             call_module="SubtensorModule",
diff --git a/bittensor/core/extrinsics/unstaking.py b/bittensor/core/extrinsics/unstaking.py
index bb706e5343..17398a066b 100644
--- a/bittensor/core/extrinsics/unstaking.py
+++ b/bittensor/core/extrinsics/unstaking.py
@@ -201,69 +201,9 @@ def unstake_extrinsic(
 def unstake_all_extrinsic(
     subtensor: "Subtensor",
     wallet: "Wallet",
-    hotkey_ss58: str,
+    hotkey: str,
     netuid: int,
-    wait_for_inclusion: bool = True,
-    wait_for_finalization: bool = False,
-    period: Optional[int] = None,
-) -> tuple[bool, str]:
-    """Unsafely unstakes all TAO/Alpha associated with the hotkey from the specified subnets on the Bittensor network.
-
-    Arguments:
-        subtensor: Subtensor instance.
-        wallet: The wallet of the stake owner.
-        hotkey_ss58: The SS58 address of the hotkey to unstake from.
-        netuid: The unique identifier of the subnet.
-        wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
-        wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
-        period: The number of blocks during which the transaction will remain valid after it's submitted. If the
-            transaction is not included in a block within that number of blocks, it will expire and be rejected. You can
-            think of it as an expiration date for the transaction. Default is `None`.
-
-    Returns:
-        tuple[bool, str]:
-            A tuple containing:
-            - `True` and a success message if the unstake operation succeeded;
-            - `False` and an error message otherwise.
-    """
-    if not (unlock := unlock_key(wallet)).success:
-        logging.error(unlock.message)
-        return False, unlock.message
-
-    call_params = {
-        "hotkey": hotkey_ss58,
-        "netuids": [netuid],
-    }
-
-    call = subtensor.substrate.compose_call(
-        call_module="SubtensorModule",
-        call_function="unstake_all",
-        call_params=call_params,
-    )
-
-    success, message = subtensor.sign_and_send_extrinsic(
-        call=call,
-        wallet=wallet,
-        wait_for_inclusion=wait_for_inclusion,
-        wait_for_finalization=wait_for_finalization,
-        nonce_key="coldkeypub",
-        sign_with="coldkey",
-        use_nonce=True,
-        period=period,
-        raise_error=True,
-    )
-    if not wait_for_finalization and not wait_for_inclusion:
-        return True, "Not waiting for finalization or inclusion."
-
-    return success, message
-
-
-def unstaking_all_limit_extrinsic(
-    subtensor: "Subtensor",
-    wallet: "Wallet",
-    hotkey_ss58: str,
-    netuid: int,
-    rate_tolerance: float = 0.005,
+    rate_tolerance: Optional[float] = 0.005,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = False,
     period: Optional[int] = None,
@@ -273,7 +213,7 @@ def unstaking_all_limit_extrinsic(
     Arguments:
         subtensor: Subtensor instance.
         wallet: The wallet of the stake owner.
-        hotkey_ss58: The SS58 address of the hotkey to unstake from.
+        hotkey: The SS58 address of the hotkey to unstake from.
         netuid: The unique identifier of the subnet.
         rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
                 price decrease. Only used when safe_staking is True. Default is 0.005.
@@ -293,15 +233,17 @@ def unstaking_all_limit_extrinsic(
         logging.error(unlock.message)
         return False, unlock.message
 
-    current_price = subtensor.subnet(netuid=netuid).price
-    limit_price = current_price * (1 - rate_tolerance)
-
     call_params = {
-        "hotkey": hotkey_ss58,
+        "hotkey": hotkey,
         "netuid": netuid,
-        "limit_price": limit_price,
+        "limit_price": None,
     }
 
+    if rate_tolerance:
+        current_price = subtensor.subnet(netuid=netuid).price
+        limit_price = current_price * (1 - rate_tolerance)
+        call_params.update({"limit_price": limit_price})
+
     call = subtensor.substrate.compose_call(
         call_module="SubtensorModule",
         call_function="remove_stake_full_limit",

From b78d4420ebcf5d9c032ceb04a7bf4e2174f4f54f Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 07:59:53 -0700
Subject: [PATCH 10/20] update unstake_all calls.

---
 bittensor/core/async_subtensor.py | 24 +++++-------------------
 bittensor/core/subtensor.py       | 25 +++++--------------------
 2 files changed, 10 insertions(+), 39 deletions(-)

diff --git a/bittensor/core/async_subtensor.py b/bittensor/core/async_subtensor.py
index c11e248616..93e56ebb40 100644
--- a/bittensor/core/async_subtensor.py
+++ b/bittensor/core/async_subtensor.py
@@ -75,7 +75,6 @@
 from bittensor.core.extrinsics.asyncex.transfer import transfer_extrinsic
 from bittensor.core.extrinsics.asyncex.unstaking import (
     unstake_all_extrinsic,
-    unstaking_all_limit_extrinsic,
     unstake_extrinsic,
     unstake_multiple_extrinsic,
 )
@@ -4607,10 +4606,9 @@ async def unstake(
     async def unstake_all(
         self,
         wallet: "Wallet",
-        hotkey_ss58: str,
+        hotkey: str,
         netuid: int,
-        safe_unstaking: bool = False,
-        rate_tolerance: float = 0.005,
+        rate_tolerance: Optional[float] = 0.005,
         wait_for_inclusion: bool = True,
         wait_for_finalization: bool = False,
         period: Optional[int] = None,
@@ -4619,10 +4617,8 @@ async def unstake_all(
 
         Arguments:
             wallet: The wallet of the stake owner.
-            hotkey_ss58: The SS58 address of the hotkey to unstake from.
+            hotkey: The SS58 address of the hotkey to unstake from.
             netuid: The unique identifier of the subnet.
-            safe_unstaking: If true, enables price safety checks to protect against fluctuating prices. The unstake
-                will only execute if the price change doesn't exceed the rate tolerance. Default is False.
             rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
                 price decrease. Only used when safe_staking is True. Default is 0.005.
             wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
@@ -4658,17 +4654,6 @@ async def unstake_all(
 
             # TODO: add additional example with explanation
         """
-        if safe_unstaking:
-            return await unstaking_all_limit_extrinsic(
-                subtensor=self,
-                wallet=wallet,
-                hotkey_ss58=hotkey_ss58,
-                netuid=netuid,
-                rate_tolerance=rate_tolerance,
-                wait_for_inclusion=wait_for_inclusion,
-                wait_for_finalization=wait_for_finalization,
-                period=period,
-            )
         if netuid != 0:
             logging.debug(
                 f"Unstaking without Alpha price control from subnet [blue]#{netuid}[/blue]."
@@ -4676,8 +4661,9 @@ async def unstake_all(
         return await unstake_all_extrinsic(
             subtensor=self,
             wallet=wallet,
-            hotkey_ss58=hotkey_ss58,
+            hotkey=hotkey,
             netuid=netuid,
+            rate_tolerance=rate_tolerance,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
             period=period,
diff --git a/bittensor/core/subtensor.py b/bittensor/core/subtensor.py
index a5199f3be6..3cd4311934 100644
--- a/bittensor/core/subtensor.py
+++ b/bittensor/core/subtensor.py
@@ -78,7 +78,6 @@
 from bittensor.core.extrinsics.transfer import transfer_extrinsic
 from bittensor.core.extrinsics.unstaking import (
     unstake_all_extrinsic,
-    unstaking_all_limit_extrinsic,
     unstake_extrinsic,
     unstake_multiple_extrinsic,
 )
@@ -3813,10 +3812,9 @@ def unstake(
     def unstake_all(
         self,
         wallet: "Wallet",
-        hotkey_ss58: str,
+        hotkey: str,
         netuid: int,
-        safe_unstaking: bool = True,
-        rate_tolerance: float = 0.005,
+        rate_tolerance: Optional[float] = 0.005,
         wait_for_inclusion: bool = True,
         wait_for_finalization: bool = False,
         period: Optional[int] = None,
@@ -3825,10 +3823,8 @@ def unstake_all(
 
         Arguments:
             wallet: The wallet of the stake owner.
-            hotkey_ss58: The SS58 address of the hotkey to unstake from.
+            hotkey: The SS58 address of the hotkey to unstake from.
             netuid: The unique identifier of the subnet.
-            safe_unstaking: If true, enables price safety checks to protect against fluctuating prices. The unstake
-                will only execute if the price change doesn't exceed the rate tolerance. Default is `True`.
             rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
                 price decrease. Only used when safe_staking is True. Default is 0.005.
             wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
@@ -3864,18 +3860,6 @@ def unstake_all(
 
             # TODO: add additional example with explanation
         """
-        if safe_unstaking:
-            return unstaking_all_limit_extrinsic(
-                subtensor=self,
-                wallet=wallet,
-                hotkey_ss58=hotkey_ss58,
-                netuid=netuid,
-                rate_tolerance=rate_tolerance,
-                wait_for_inclusion=wait_for_inclusion,
-                wait_for_finalization=wait_for_finalization,
-                period=period,
-            )
-
         if netuid != 0:
             logging.debug(
                 f"Unstaking without Alpha price control from subnet [blue]#{netuid}[/blue]."
@@ -3883,8 +3867,9 @@ def unstake_all(
         return unstake_all_extrinsic(
             subtensor=self,
             wallet=wallet,
-            hotkey_ss58=hotkey_ss58,
+            hotkey=hotkey,
             netuid=netuid,
+            rate_tolerance=rate_tolerance,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
             period=period,

From 234d4671a88931ebdabebc9f5d000149b88989d6 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 08:56:57 -0700
Subject: [PATCH 11/20] Optional

---
 bittensor/core/extrinsics/asyncex/unstaking.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bittensor/core/extrinsics/asyncex/unstaking.py b/bittensor/core/extrinsics/asyncex/unstaking.py
index 11478f9fe0..0e356de218 100644
--- a/bittensor/core/extrinsics/asyncex/unstaking.py
+++ b/bittensor/core/extrinsics/asyncex/unstaking.py
@@ -206,7 +206,7 @@ async def unstake_all_extrinsic(
     wallet: "Wallet",
     hotkey: str,
     netuid: int,
-    rate_tolerance: float = 0.005,
+    rate_tolerance: Optional[float] = 0.005,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = False,
     period: Optional[int] = None,

From 43a8719044bd02d8f645cb87212c37cd78acfaae Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 09:15:12 -0700
Subject: [PATCH 12/20] update docstrings

---
 bittensor/core/async_subtensor.py              | 2 +-
 bittensor/core/extrinsics/asyncex/unstaking.py | 4 ++--
 bittensor/core/extrinsics/unstaking.py         | 4 ++--
 bittensor/core/subtensor.py                    | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/bittensor/core/async_subtensor.py b/bittensor/core/async_subtensor.py
index 93e56ebb40..935319e48c 100644
--- a/bittensor/core/async_subtensor.py
+++ b/bittensor/core/async_subtensor.py
@@ -4620,7 +4620,7 @@ async def unstake_all(
             hotkey: The SS58 address of the hotkey to unstake from.
             netuid: The unique identifier of the subnet.
             rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
-                price decrease. Only used when safe_staking is True. Default is 0.005.
+                price decrease. If not passed (None), then unstaking goes without price limit. Default is 0.005.
             wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
             wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
             period: The number of blocks during which the transaction will remain valid after it's submitted. If the
diff --git a/bittensor/core/extrinsics/asyncex/unstaking.py b/bittensor/core/extrinsics/asyncex/unstaking.py
index 0e356de218..84e7ff7f7b 100644
--- a/bittensor/core/extrinsics/asyncex/unstaking.py
+++ b/bittensor/core/extrinsics/asyncex/unstaking.py
@@ -211,7 +211,7 @@ async def unstake_all_extrinsic(
     wait_for_finalization: bool = False,
     period: Optional[int] = None,
 ) -> tuple[bool, str]:
-    """Safely unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
+    """Unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
 
     Arguments:
         subtensor: Subtensor instance.
@@ -219,7 +219,7 @@ async def unstake_all_extrinsic(
         hotkey: The SS58 address of the hotkey to unstake from.
         netuid: The unique identifier of the subnet.
         rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
-                price decrease. Only used when safe_staking is True. Default is 0.005.
+            price decrease. If not passed (None), then unstaking goes without price limit. Default is `0.005`.
         wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
         wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
         period: The number of blocks during which the transaction will remain valid after it's submitted. If the
diff --git a/bittensor/core/extrinsics/unstaking.py b/bittensor/core/extrinsics/unstaking.py
index 17398a066b..e77a85a956 100644
--- a/bittensor/core/extrinsics/unstaking.py
+++ b/bittensor/core/extrinsics/unstaking.py
@@ -208,7 +208,7 @@ def unstake_all_extrinsic(
     wait_for_finalization: bool = False,
     period: Optional[int] = None,
 ) -> tuple[bool, str]:
-    """Safely unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
+    """Unstakes all TAO/Alpha associated with a hotkey from the specified subnets on the Bittensor network.
 
     Arguments:
         subtensor: Subtensor instance.
@@ -216,7 +216,7 @@ def unstake_all_extrinsic(
         hotkey: The SS58 address of the hotkey to unstake from.
         netuid: The unique identifier of the subnet.
         rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
-                price decrease. Only used when safe_staking is True. Default is 0.005.
+            price decrease. If not passed (None), then unstaking goes without price limit. Default is `0.005`.
         wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
         wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
         period: The number of blocks during which the transaction will remain valid after it's submitted. If the
diff --git a/bittensor/core/subtensor.py b/bittensor/core/subtensor.py
index 3cd4311934..fdd8139210 100644
--- a/bittensor/core/subtensor.py
+++ b/bittensor/core/subtensor.py
@@ -3826,7 +3826,7 @@ def unstake_all(
             hotkey: The SS58 address of the hotkey to unstake from.
             netuid: The unique identifier of the subnet.
             rate_tolerance: The maximum allowed price change ratio when unstaking. For example, 0.005 = 0.5% maximum
-                price decrease. Only used when safe_staking is True. Default is 0.005.
+                price decrease. If not passed (None), then unstaking goes without price limit. Default is 0.005.
             wait_for_inclusion: Waits for the transaction to be included in a block. Default is `True`.
             wait_for_finalization: Waits for the transaction to be finalized on the blockchain. Default is `False`.
             period: The number of blocks during which the transaction will remain valid after it's submitted. If the

From 1b00d57abb94272b2cb39fd052d714d8b36fcb49 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 10:12:54 -0700
Subject: [PATCH 13/20] add e2e tests (3 scenarios)

---
 tests/e2e_tests/test_staking.py | 138 +++++++++++++++++++++++++++++++-
 1 file changed, 137 insertions(+), 1 deletion(-)

diff --git a/tests/e2e_tests/test_staking.py b/tests/e2e_tests/test_staking.py
index f95348a6a4..4d778df8ba 100644
--- a/tests/e2e_tests/test_staking.py
+++ b/tests/e2e_tests/test_staking.py
@@ -1,8 +1,10 @@
+import pytest
+
+from bittensor.core.errors import ChainError
 from bittensor import logging
 from bittensor.core.chain_data.stake_info import StakeInfo
 from bittensor.utils.balance import Balance
 from tests.e2e_tests.utils.chain_interactions import get_dynamic_balance
-from tests.helpers.helpers import ApproxBalance
 from tests.e2e_tests.utils.e2e_test_utils import wait_to_start_call
 
 
@@ -825,3 +827,137 @@ def test_transfer_stake(subtensor, alice_wallet, bob_wallet, dave_wallet):
     ]
     assert bob_stakes == expected_bob_stake
     logging.console.success(f"✅ Test [green]test_transfer_stake[/green] passed")
+
+
+# For test we set rate_tolerance=0.7 (70%) because of price is highly dynamic for fast-blocks and 2 SN to avoid `
+# Slippage is too high for the transaction`. This logic controls by the chain.
+@pytest.mark.parametrize(
+    "rate_tolerance",
+    [None, 1.0, 0.001],
+    ids=[
+        "Without price limit",
+        "With price limit",
+        "Rise `Slippage is too high for the transaction`"
+    ]
+)
+def test_unstaking_with_limit(
+    subtensor, alice_wallet, bob_wallet, dave_wallet, rate_tolerance
+):
+    """Test unstaking with limits goes well for all subnets with and without price limit."""
+
+    # Register first SN
+    alice_subnet_netuid_2 = subtensor.get_total_subnets()  # 2
+    assert subtensor.register_subnet(alice_wallet, True, True)
+    assert subtensor.subnet_exists(alice_subnet_netuid_2), (
+        "Subnet wasn't created successfully"
+    )
+
+    wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid_2)
+
+    assert subtensor.start_call(
+        alice_wallet,
+        netuid=alice_subnet_netuid_2,
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+    )
+
+    # Register Bob and Dave in SN2
+    assert subtensor.burned_register(
+        wallet=bob_wallet,
+        netuid=alice_subnet_netuid_2,
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+    )
+
+    assert subtensor.burned_register(
+        wallet=dave_wallet,
+        netuid=alice_subnet_netuid_2,
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+    )
+
+    # Register second SN
+    alice_subnet_netuid_3 = subtensor.get_total_subnets()  # 3
+    assert subtensor.register_subnet(alice_wallet, True, True)
+    assert subtensor.subnet_exists(alice_subnet_netuid_3), (
+        "Subnet wasn't created successfully"
+    )
+
+    wait_to_start_call(subtensor, alice_wallet, alice_subnet_netuid_3)
+
+    assert subtensor.start_call(
+        alice_wallet,
+        netuid=alice_subnet_netuid_3,
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+    )
+
+    # Register Bob and Dave in SN3
+    assert subtensor.burned_register(
+        wallet=bob_wallet,
+        netuid=alice_subnet_netuid_3,
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+    )
+
+    assert subtensor.burned_register(
+        wallet=dave_wallet,
+        netuid=alice_subnet_netuid_3,
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+    )
+
+    # Check Bob's stakes are empty.
+    assert subtensor.get_stake_info_for_coldkey(bob_wallet.coldkey.ss58_address) == []
+
+    # Bob stakes to Dave in both SNs
+
+    assert subtensor.add_stake(
+        wallet=bob_wallet,
+        hotkey_ss58=dave_wallet.hotkey.ss58_address,
+        netuid=alice_subnet_netuid_2,
+        amount=Balance.from_tao(1000),
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+        period=16,
+    ), f"Cant add stake to dave in SN {alice_subnet_netuid_2}"
+    assert subtensor.add_stake(
+        wallet=bob_wallet,
+        hotkey_ss58=alice_wallet.hotkey.ss58_address,
+        netuid=alice_subnet_netuid_3,
+        amount=Balance.from_tao(1500),
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+        period=16,
+    ), f"Cant add stake to dave in SN {alice_subnet_netuid_3}"
+
+    # Check that both stakes are presented in result
+    bob_stakes = subtensor.get_stake_info_for_coldkey(bob_wallet.coldkey.ss58_address)
+    assert len(bob_stakes) == 2
+
+    if rate_tolerance == 0.001:
+        # Raise the error
+        with pytest.raises(ChainError, match="Slippage is too high for the transaction"):
+            subtensor.unstake_all(
+                wallet=bob_wallet,
+                hotkey=bob_stakes[0].hotkey_ss58,
+                netuid=bob_stakes[0].netuid,
+                rate_tolerance=rate_tolerance,
+                wait_for_inclusion=True,
+                wait_for_finalization=True,
+            )
+    else:
+        # Successful cases
+        for si in bob_stakes:
+            assert subtensor.unstake_all(
+                wallet=bob_wallet,
+                hotkey=si.hotkey_ss58,
+                netuid=si.netuid,
+                rate_tolerance=rate_tolerance,
+                wait_for_inclusion=True,
+                wait_for_finalization=True,
+            )[0]
+
+        # Make sure both unstake were successful.
+        bob_stakes = subtensor.get_stake_info_for_coldkey(bob_wallet.coldkey.ss58_address)
+        assert len(bob_stakes) == 0

From d710dd90e3b2255f8fdaa4cc2ff1a83fb32d69ce Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 10:37:35 -0700
Subject: [PATCH 14/20] add unit tests for subtensor calls

---
 tests/e2e_tests/test_staking.py          | 12 ++++++----
 tests/unit_tests/test_async_subtensor.py | 28 ++++++++++++++++++++++++
 tests/unit_tests/test_subtensor.py       | 27 +++++++++++++++++++++++
 3 files changed, 63 insertions(+), 4 deletions(-)

diff --git a/tests/e2e_tests/test_staking.py b/tests/e2e_tests/test_staking.py
index 4d778df8ba..1d1ca48624 100644
--- a/tests/e2e_tests/test_staking.py
+++ b/tests/e2e_tests/test_staking.py
@@ -837,8 +837,8 @@ def test_transfer_stake(subtensor, alice_wallet, bob_wallet, dave_wallet):
     ids=[
         "Without price limit",
         "With price limit",
-        "Rise `Slippage is too high for the transaction`"
-    ]
+        "Rise `Slippage is too high for the transaction`",
+    ],
 )
 def test_unstaking_with_limit(
     subtensor, alice_wallet, bob_wallet, dave_wallet, rate_tolerance
@@ -937,7 +937,9 @@ def test_unstaking_with_limit(
 
     if rate_tolerance == 0.001:
         # Raise the error
-        with pytest.raises(ChainError, match="Slippage is too high for the transaction"):
+        with pytest.raises(
+            ChainError, match="Slippage is too high for the transaction"
+        ):
             subtensor.unstake_all(
                 wallet=bob_wallet,
                 hotkey=bob_stakes[0].hotkey_ss58,
@@ -959,5 +961,7 @@ def test_unstaking_with_limit(
             )[0]
 
         # Make sure both unstake were successful.
-        bob_stakes = subtensor.get_stake_info_for_coldkey(bob_wallet.coldkey.ss58_address)
+        bob_stakes = subtensor.get_stake_info_for_coldkey(
+            bob_wallet.coldkey.ss58_address
+        )
         assert len(bob_stakes) == 0
diff --git a/tests/unit_tests/test_async_subtensor.py b/tests/unit_tests/test_async_subtensor.py
index 97554b4468..b89fd70e57 100644
--- a/tests/unit_tests/test_async_subtensor.py
+++ b/tests/unit_tests/test_async_subtensor.py
@@ -3490,3 +3490,31 @@ async def test_get_next_epoch_start_block(mocker, subtensor, call_return, expect
         netuid=netuid, block=block, block_hash=fake_block_hash, reuse_block=False
     )
     assert result == expected
+
+
+@pytest.mark.asyncio
+async def test_unstake_all(subtensor, fake_wallet, mocker):
+    """Verifies unstake_all calls properly."""
+    # Preps
+    fake_unstake_all_extrinsic = mocker.AsyncMock()
+    mocker.patch.object(
+        async_subtensor, "unstake_all_extrinsic", fake_unstake_all_extrinsic
+    )
+    # Call
+    result = await subtensor.unstake_all(
+        wallet=fake_wallet,
+        hotkey=fake_wallet.hotkey.ss58_address,
+        netuid=1,
+    )
+    # Asserts
+    fake_unstake_all_extrinsic.assert_awaited_once_with(
+        subtensor=subtensor,
+        wallet=fake_wallet,
+        hotkey=fake_wallet.hotkey.ss58_address,
+        netuid=1,
+        rate_tolerance=0.005,
+        wait_for_inclusion=True,
+        wait_for_finalization=False,
+        period=None,
+    )
+    assert result == fake_unstake_all_extrinsic.return_value
diff --git a/tests/unit_tests/test_subtensor.py b/tests/unit_tests/test_subtensor.py
index 75e7a7950f..939b7c37b8 100644
--- a/tests/unit_tests/test_subtensor.py
+++ b/tests/unit_tests/test_subtensor.py
@@ -3848,3 +3848,30 @@ def test_set_children(subtensor, fake_wallet, mocker):
         period=None,
     )
     assert result == mocked_set_children_extrinsic.return_value
+
+
+def test_unstake_all(subtensor, fake_wallet, mocker):
+    """Verifies unstake_all calls properly."""
+    # Preps
+    fake_unstake_all_extrinsic = mocker.Mock()
+    mocker.patch.object(
+        subtensor_module, "unstake_all_extrinsic", fake_unstake_all_extrinsic
+    )
+    # Call
+    result = subtensor.unstake_all(
+        wallet=fake_wallet,
+        hotkey=fake_wallet.hotkey.ss58_address,
+        netuid=1,
+    )
+    # Asserts
+    fake_unstake_all_extrinsic.assert_called_once_with(
+        subtensor=subtensor,
+        wallet=fake_wallet,
+        hotkey=fake_wallet.hotkey.ss58_address,
+        netuid=1,
+        rate_tolerance=0.005,
+        wait_for_inclusion=True,
+        wait_for_finalization=False,
+        period=None,
+    )
+    assert result == fake_unstake_all_extrinsic.return_value

From ab3c9df8a26574de2e03c4f04693ff10519805af Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 10:46:17 -0700
Subject: [PATCH 15/20] remove raise error argument from call

---
 bittensor/core/extrinsics/asyncex/unstaking.py | 1 -
 bittensor/core/extrinsics/unstaking.py         | 1 -
 2 files changed, 2 deletions(-)

diff --git a/bittensor/core/extrinsics/asyncex/unstaking.py b/bittensor/core/extrinsics/asyncex/unstaking.py
index 84e7ff7f7b..a6f00633c0 100644
--- a/bittensor/core/extrinsics/asyncex/unstaking.py
+++ b/bittensor/core/extrinsics/asyncex/unstaking.py
@@ -263,7 +263,6 @@ async def unstake_all_extrinsic(
             sign_with="coldkey",
             use_nonce=True,
             period=period,
-            raise_error=True,
         )
 
 
diff --git a/bittensor/core/extrinsics/unstaking.py b/bittensor/core/extrinsics/unstaking.py
index e77a85a956..ef7c67a657 100644
--- a/bittensor/core/extrinsics/unstaking.py
+++ b/bittensor/core/extrinsics/unstaking.py
@@ -259,7 +259,6 @@ def unstake_all_extrinsic(
         sign_with="coldkey",
         use_nonce=True,
         period=period,
-        raise_error=True,
     )
 
     return success, message

From 558f545d49774f3a97272c8e032dabc4d92d9d1d Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 10:58:05 -0700
Subject: [PATCH 16/20] add extrinsics unit tests

---
 .../extrinsics/asyncex/test_unstaking.py      | 172 ++++++++++++++++++
 tests/unit_tests/extrinsics/test_unstaking.py |  45 +++++
 2 files changed, 217 insertions(+)
 create mode 100644 tests/unit_tests/extrinsics/asyncex/test_unstaking.py

diff --git a/tests/unit_tests/extrinsics/asyncex/test_unstaking.py b/tests/unit_tests/extrinsics/asyncex/test_unstaking.py
new file mode 100644
index 0000000000..ed74c76fe4
--- /dev/null
+++ b/tests/unit_tests/extrinsics/asyncex/test_unstaking.py
@@ -0,0 +1,172 @@
+import pytest
+
+from bittensor.core.extrinsics.asyncex import unstaking
+from bittensor.utils.balance import Balance
+
+
+@pytest.mark.asyncio
+async def test_unstake_extrinsic(fake_wallet, mocker):
+    # Preps
+    fake_subtensor = mocker.AsyncMock(
+        **{
+            "get_hotkey_owner.return_value": "hotkey_owner",
+            "get_stake_for_coldkey_and_hotkey.return_value": Balance(10.0),
+            "sign_and_send_extrinsic.return_value": (True, ""),
+            "get_stake.return_value": Balance(10.0),
+        }
+    )
+
+    fake_wallet.coldkeypub.ss58_address = "hotkey_owner"
+    hotkey_ss58 = "hotkey"
+    fake_netuid = 1
+    amount = Balance.from_tao(1.1)
+    wait_for_inclusion = True
+    wait_for_finalization = True
+
+    # Call
+    result = await unstaking.unstake_extrinsic(
+        subtensor=fake_subtensor,
+        wallet=fake_wallet,
+        hotkey_ss58=hotkey_ss58,
+        netuid=fake_netuid,
+        amount=amount,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+    )
+
+    # Asserts
+    assert result is True
+
+    fake_subtensor.substrate.compose_call.assert_awaited_once_with(
+        call_module="SubtensorModule",
+        call_function="remove_stake",
+        call_params={
+            "hotkey": "hotkey",
+            "amount_unstaked": 1100000000,
+            "netuid": 1,
+        },
+    )
+    fake_subtensor.sign_and_send_extrinsic.assert_awaited_once_with(
+        call=fake_subtensor.substrate.compose_call.return_value,
+        wallet=fake_wallet,
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+        sign_with="coldkey",
+        nonce_key="coldkeypub",
+        use_nonce=True,
+        period=None,
+    )
+
+
+@pytest.mark.asyncio
+async def test_unstake_all_extrinsic(fake_wallet, mocker):
+    # Preps
+    fake_subtensor = mocker.AsyncMock(
+        **{
+            "subnet.return_value": mocker.Mock(price=100),
+            "sign_and_send_extrinsic.return_value": (True, ""),
+        }
+    )
+    fake_substrate = fake_subtensor.substrate.__aenter__.return_value
+    hotkey = "hotkey"
+    fake_netuid = 1
+
+    # Call
+    result = await unstaking.unstake_all_extrinsic(
+        subtensor=fake_subtensor,
+        wallet=fake_wallet,
+        hotkey=hotkey,
+        netuid=fake_netuid,
+    )
+
+    # Asserts
+    assert result[0] is True
+    assert result[1] == ""
+
+    fake_substrate.compose_call.assert_awaited_once_with(
+        call_module="SubtensorModule",
+        call_function="remove_stake_full_limit",
+        call_params={
+            "hotkey": "hotkey",
+            "netuid": fake_netuid,
+            "limit_price": 100 * (1 - 0.005),
+        },
+    )
+    fake_subtensor.sign_and_send_extrinsic.assert_awaited_once_with(
+        call=fake_substrate.compose_call.return_value,
+        wallet=fake_wallet,
+        wait_for_inclusion=True,
+        wait_for_finalization=False,
+        sign_with="coldkey",
+        nonce_key="coldkeypub",
+        use_nonce=True,
+        period=None,
+    )
+
+
+@pytest.mark.asyncio
+async def test_unstake_multiple_extrinsic(fake_wallet, mocker):
+    """Verify that sync `unstake_multiple_extrinsic` method calls proper async method."""
+    # Preps
+    fake_subtensor = mocker.AsyncMock(
+        **{
+            "get_hotkey_owner.return_value": "hotkey_owner",
+            "get_stake_for_coldkey_and_hotkey.return_value": [Balance(10.0)],
+            "sign_and_send_extrinsic.return_value": (True, ""),
+            "tx_rate_limit.return_value": 0,
+        }
+    )
+    mocker.patch.object(
+        unstaking, "get_old_stakes", return_value=[Balance(1.1), Balance(0.3)]
+    )
+    fake_wallet.coldkeypub.ss58_address = "hotkey_owner"
+    hotkey_ss58s = ["hotkey1", "hotkey2"]
+    fake_netuids = [1, 2]
+    amounts = [Balance.from_tao(1.1), Balance.from_tao(1.2)]
+    wait_for_inclusion = True
+    wait_for_finalization = True
+
+    # Call
+    result = await unstaking.unstake_multiple_extrinsic(
+        subtensor=fake_subtensor,
+        wallet=fake_wallet,
+        hotkey_ss58s=hotkey_ss58s,
+        netuids=fake_netuids,
+        amounts=amounts,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+    )
+
+    # Asserts
+    assert result is True
+    assert fake_subtensor.substrate.compose_call.call_count == 1
+    assert fake_subtensor.sign_and_send_extrinsic.call_count == 1
+
+    fake_subtensor.substrate.compose_call.assert_any_call(
+        call_module="SubtensorModule",
+        call_function="remove_stake",
+        call_params={
+            "hotkey": "hotkey1",
+            "amount_unstaked": 1100000000,
+            "netuid": 1,
+        },
+    )
+    fake_subtensor.substrate.compose_call.assert_any_call(
+        call_module="SubtensorModule",
+        call_function="remove_stake",
+        call_params={
+            "hotkey": "hotkey1",
+            "amount_unstaked": 1100000000,
+            "netuid": 1,
+        },
+    )
+    fake_subtensor.sign_and_send_extrinsic.assert_awaited_with(
+        call=fake_subtensor.substrate.compose_call.return_value,
+        wallet=fake_wallet,
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+        sign_with="coldkey",
+        nonce_key="coldkeypub",
+        use_nonce=True,
+        period=None,
+    )
diff --git a/tests/unit_tests/extrinsics/test_unstaking.py b/tests/unit_tests/extrinsics/test_unstaking.py
index 2fdf0cbe47..04b93111d2 100644
--- a/tests/unit_tests/extrinsics/test_unstaking.py
+++ b/tests/unit_tests/extrinsics/test_unstaking.py
@@ -54,6 +54,51 @@ def test_unstake_extrinsic(fake_wallet, mocker):
     )
 
 
+def test_unstake_all_extrinsic(fake_wallet, mocker):
+    # Preps
+    fake_subtensor = mocker.Mock(
+        **{
+            "subnet.return_value": mocker.Mock(price=100),
+            "sign_and_send_extrinsic.return_value": (True, ""),
+        }
+    )
+
+    hotkey = "hotkey"
+    fake_netuid = 1
+
+    # Call
+    result = unstaking.unstake_all_extrinsic(
+        subtensor=fake_subtensor,
+        wallet=fake_wallet,
+        hotkey=hotkey,
+        netuid=fake_netuid,
+    )
+
+    # Asserts
+    assert result[0] is True
+    assert result[1] == ""
+
+    fake_subtensor.substrate.compose_call.assert_called_once_with(
+        call_module="SubtensorModule",
+        call_function="remove_stake_full_limit",
+        call_params={
+            "hotkey": "hotkey",
+            "netuid": fake_netuid,
+            "limit_price": 100 * (1 - 0.005),
+        },
+    )
+    fake_subtensor.sign_and_send_extrinsic.assert_called_once_with(
+        call=fake_subtensor.substrate.compose_call.return_value,
+        wallet=fake_wallet,
+        wait_for_inclusion=True,
+        wait_for_finalization=False,
+        sign_with="coldkey",
+        nonce_key="coldkeypub",
+        use_nonce=True,
+        period=None,
+    )
+
+
 def test_unstake_multiple_extrinsic(fake_wallet, mocker):
     """Verify that sync `unstake_multiple_extrinsic` method calls proper async method."""
     # Preps

From 1ca7ba0d8e49365847937256cd3406379e803008 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 11:02:52 -0700
Subject: [PATCH 17/20] improved docstrings examples

---
 bittensor/core/async_subtensor.py | 22 ++++++++++++++++++++--
 bittensor/core/subtensor.py       | 19 ++++++++++++++++++-
 2 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/bittensor/core/async_subtensor.py b/bittensor/core/async_subtensor.py
index 935319e48c..efe3f0f923 100644
--- a/bittensor/core/async_subtensor.py
+++ b/bittensor/core/async_subtensor.py
@@ -4634,7 +4634,8 @@ async def unstake_all(
                 - `False` and an error message otherwise.
 
         Example:
-            # If you would like to unstake all stakes in all subnets safely:
+            # If you would like to unstake all stakes in all subnets safely, use default `rate_tolerance` or pass your
+                value:
             import bittensor as bt
 
             subtensor = bt.AsyncSubtensor()
@@ -4652,7 +4653,24 @@ async def unstake_all(
                 )
                 print(result)
 
-            # TODO: add additional example with explanation
+            # If you would like to unstake all stakes in all subnets unsafely, use `rate_tolerance=None`:
+                        import bittensor as bt
+
+            subtensor = bt.AsyncSubtensor()
+            wallet = bt.Wallet("my_wallet")
+            netuid = 14
+            hotkey = "5%SOME_HOTKEY_WHERE_IS_YOUR_STAKE_NOW%"
+
+            wallet_stakes = await subtensor.get_stake_info_for_coldkey(coldkey_ss58=wallet.coldkey.ss58_address)
+
+            for stake in wallet_stakes:
+                result = await subtensor.unstake_all(
+                    wallet=wallet,
+                    hotkey_ss58=stake.hotkey_ss58,
+                    netuid=stake.netuid,
+                    rate_tolerance=None,
+                )
+                print(result)
         """
         if netuid != 0:
             logging.debug(
diff --git a/bittensor/core/subtensor.py b/bittensor/core/subtensor.py
index fdd8139210..5438a3fa15 100644
--- a/bittensor/core/subtensor.py
+++ b/bittensor/core/subtensor.py
@@ -3858,7 +3858,24 @@ def unstake_all(
                 )
                 print(result)
 
-            # TODO: add additional example with explanation
+            # If you would like to unstake all stakes in all subnets unsafely, use `rate_tolerance=None`:
+                        import bittensor as bt
+
+            subtensor = bt.AsyncSubtensor()
+            wallet = bt.Wallet("my_wallet")
+            netuid = 14
+            hotkey = "5%SOME_HOTKEY_WHERE_IS_YOUR_STAKE_NOW%"
+
+            wallet_stakes = await subtensor.get_stake_info_for_coldkey(coldkey_ss58=wallet.coldkey.ss58_address)
+
+            for stake in wallet_stakes:
+                result = await subtensor.unstake_all(
+                    wallet=wallet,
+                    hotkey_ss58=stake.hotkey_ss58,
+                    netuid=stake.netuid,
+                    rate_tolerance=None,
+                )
+                print(result)
         """
         if netuid != 0:
             logging.debug(

From 65295074d38237cd8fd7fedfd4dd64dab2b0e8f9 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 11:16:41 -0700
Subject: [PATCH 18/20] fix flaky behavior in test

---
 tests/e2e_tests/test_staking.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/tests/e2e_tests/test_staking.py b/tests/e2e_tests/test_staking.py
index 1d1ca48624..28635c40f0 100644
--- a/tests/e2e_tests/test_staking.py
+++ b/tests/e2e_tests/test_staking.py
@@ -833,11 +833,10 @@ def test_transfer_stake(subtensor, alice_wallet, bob_wallet, dave_wallet):
 # Slippage is too high for the transaction`. This logic controls by the chain.
 @pytest.mark.parametrize(
     "rate_tolerance",
-    [None, 1.0, 0.001],
+    [None, 1.0],
     ids=[
         "Without price limit",
         "With price limit",
-        "Rise `Slippage is too high for the transaction`",
     ],
 )
 def test_unstaking_with_limit(
@@ -916,7 +915,7 @@ def test_unstaking_with_limit(
         wallet=bob_wallet,
         hotkey_ss58=dave_wallet.hotkey.ss58_address,
         netuid=alice_subnet_netuid_2,
-        amount=Balance.from_tao(1000),
+        amount=Balance.from_tao(10000),
         wait_for_inclusion=True,
         wait_for_finalization=True,
         period=16,
@@ -925,7 +924,7 @@ def test_unstaking_with_limit(
         wallet=bob_wallet,
         hotkey_ss58=alice_wallet.hotkey.ss58_address,
         netuid=alice_subnet_netuid_3,
-        amount=Balance.from_tao(1500),
+        amount=Balance.from_tao(15000),
         wait_for_inclusion=True,
         wait_for_finalization=True,
         period=16,
@@ -935,7 +934,7 @@ def test_unstaking_with_limit(
     bob_stakes = subtensor.get_stake_info_for_coldkey(bob_wallet.coldkey.ss58_address)
     assert len(bob_stakes) == 2
 
-    if rate_tolerance == 0.001:
+    if rate_tolerance == 0.0001:
         # Raise the error
         with pytest.raises(
             ChainError, match="Slippage is too high for the transaction"

From c432f866e6d9db6c5e54e0de135a2b879bf2a946 Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Mon, 23 Jun 2025 11:32:52 -0700
Subject: [PATCH 19/20] fix flaky behavior in test

---
 tests/e2e_tests/test_staking.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/e2e_tests/test_staking.py b/tests/e2e_tests/test_staking.py
index 28635c40f0..a18605d827 100644
--- a/tests/e2e_tests/test_staking.py
+++ b/tests/e2e_tests/test_staking.py
@@ -831,6 +831,7 @@ def test_transfer_stake(subtensor, alice_wallet, bob_wallet, dave_wallet):
 
 # For test we set rate_tolerance=0.7 (70%) because of price is highly dynamic for fast-blocks and 2 SN to avoid `
 # Slippage is too high for the transaction`. This logic controls by the chain.
+# Also this test implementation works with non-fast-blocks run.
 @pytest.mark.parametrize(
     "rate_tolerance",
     [None, 1.0],

From b60c5adf6509ccb739e3f54006c00b3dc18535eb Mon Sep 17 00:00:00 2001
From: Roman <roman@opentensor.dev>
Date: Wed, 25 Jun 2025 16:59:56 -0700
Subject: [PATCH 20/20] weird, but ruff

---
 tests/e2e_tests/test_staking.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/e2e_tests/test_staking.py b/tests/e2e_tests/test_staking.py
index e11b47c972..086c570490 100644
--- a/tests/e2e_tests/test_staking.py
+++ b/tests/e2e_tests/test_staking.py
@@ -971,4 +971,3 @@ def test_unstaking_with_limit(
             bob_wallet.coldkey.ss58_address
         )
         assert len(bob_stakes) == 0
-