Merge branch 'staging' into feat/roman/test-run-tests-without-building

Author: Roman

.github/workflows/e2e-subtensor-tests.yaml

@@ -6,10 +6,10 @@ concurrency:
 
 on:
   push:
-    branches: [main, development, staging]
+    branches: [master, development, staging]
 
   pull_request:
-    branches: [main, development, staging]
+    branches: [master, development, staging]
     types: [ opened, synchronize, reopened, ready_for_review ]
 
   workflow_dispatch:

CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 9.0.5 /2025-03-12
+## 9.1.0 /2025-03-12
 
 ## What's Changed
 * Refactor duplicated unittests code by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2724
@@ -12,8 +12,13 @@
 * All metagraph subtensor methods now use block by @thewhaleking in https://github.com/opentensor/bittensor/pull/2738
 * Tests: increse test_incentive timeout + fix sudo_set_weights_set_rate_limit by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2739
 * Feat/safe staking by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2736
+* 9.0.5: Bumps version and changelog by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2741
+* Tests: enable E2E test_batch_operations by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2744
+* Fix: burned_register supports root subnet (netuid=0 param) by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2732
+* Feat: set_delegate_take by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2731
+* Renames rate_threshold -> rate_tolerance by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2745
 
-**Full Changelog**: https://github.com/opentensor/bittensor/compare/v9.0.4...v9.0.5
+**Full Changelog**: https://github.com/opentensor/bittensor/compare/v9.0.4...v9.1.0
 
 ## 9.0.4 /2025-03-06
 

VERSION

@@ -1 +1 @@
-9.0.5
+9.1.0

bittensor/core/async_subtensor.py

@@ -31,7 +31,7 @@
 from bittensor.core.chain_data.delegate_info import DelegatedInfo
 from bittensor.core.chain_data.utils import decode_metadata
 from bittensor.core.config import Config
-from bittensor.core.errors import SubstrateRequestException
+from bittensor.core.errors import ChainError, SubstrateRequestException
 from bittensor.core.extrinsics.asyncex.commit_reveal import commit_reveal_v3_extrinsic
 from bittensor.core.extrinsics.asyncex.registration import (
     burned_register_extrinsic,
@@ -57,6 +57,10 @@
     add_stake_extrinsic,
     add_stake_multiple_extrinsic,
 )
+from bittensor.core.extrinsics.asyncex.take import (
+    decrease_take_extrinsic,
+    increase_take_extrinsic,
+)
 from bittensor.core.extrinsics.asyncex.transfer import transfer_extrinsic
 from bittensor.core.extrinsics.asyncex.unstaking import (
     unstake_extrinsic,
@@ -1111,7 +1115,7 @@ async def get_delegate_take(
         block: Optional[int] = None,
         block_hash: Optional[str] = None,
         reuse_block: bool = False,
-    ) -> Optional[float]:
+    ) -> float:
         """
         Retrieves the delegate 'take' percentage for a neuron identified by its hotkey. The 'take' represents the
             percentage of rewards that the delegate claims from its nominators' stakes.
@@ -1123,7 +1127,7 @@ async def get_delegate_take(
             reuse_block (bool): Whether to reuse the last-used block hash.
 
         Returns:
-            Optional[float]: The delegate take percentage, None if not available.
+            float: The delegate take percentage.
 
         The delegate take is a critical parameter in the network's incentive structure, influencing the distribution of
             rewards among neurons and their nominators.
@@ -1135,11 +1139,8 @@ async def get_delegate_take(
             reuse_block=reuse_block,
             params=[hotkey_ss58],
         )
-        return (
-            None
-            if result is None
-            else u16_normalized_float(getattr(result, "value", 0))
-        )
+
+        return u16_normalized_float(result.value)  # type: ignore
 
     async def get_delegated(
         self,
@@ -2748,6 +2749,7 @@ async def sign_and_send_extrinsic(
         use_nonce: bool = False,
         period: Optional[int] = None,
         nonce_key: str = "hotkey",
+        raise_error: bool = False,
     ) -> tuple[bool, str]:
         """
         Helper method to sign and submit an extrinsic call to chain.
@@ -2758,6 +2760,7 @@ async def sign_and_send_extrinsic(
             wait_for_inclusion (bool): whether to wait until the extrinsic call is included on the chain
             wait_for_finalization (bool): whether to wait until the extrinsic call is finalized on the chain
             sign_with: the wallet's keypair to use for the signing. Options are "coldkey", "hotkey", "coldkeypub"
+            raise_error: raises relevant exception rather than returning `False` if unsuccessful.
 
         Returns:
             (success, error message)
@@ -2795,9 +2798,15 @@ async def sign_and_send_extrinsic(
             if await response.is_success:
                 return True, ""
 
+            if raise_error:
+                raise ChainError.from_error(response.error_message)
+
             return False, format_error_message(await response.error_message)
 
         except SubstrateRequestException as e:
+            if raise_error:
+                raise
+
             return False, format_error_message(e)
 
     # Extrinsics =======================================================================================================
@@ -2812,7 +2821,7 @@ async def add_stake(
         wait_for_finalization: bool = False,
         safe_staking: bool = False,
         allow_partial_stake: bool = False,
-        rate_threshold: float = 0.005,
+        rate_tolerance: float = 0.005,
     ) -> bool:
         """
         Adds the specified amount of stake to a neuron identified by the hotkey ``SS58`` address.
@@ -2827,11 +2836,11 @@ async def add_stake(
             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 stake
-                will only execute if the price change doesn't exceed the rate threshold. Default is False.
+                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 staking when
                 the full amount would exceed the price threshold. If false, the entire stake fails if it would
                 exceed the threshold. Default is False.
-            rate_threshold (float): The maximum allowed price change ratio when staking. For example,
+            rate_tolerance (float): The maximum allowed price change ratio when staking. For example,
                 0.005 = 0.5% maximum price increase. Only used when safe_staking is True. Default is 0.005.
 
         Returns:
@@ -2852,7 +2861,7 @@ async def add_stake(
             wait_for_finalization=wait_for_finalization,
             safe_staking=safe_staking,
             allow_partial_stake=allow_partial_stake,
-            rate_threshold=rate_threshold,
+            rate_tolerance=rate_tolerance,
         )
 
     async def add_stake_multiple(
@@ -2915,6 +2924,14 @@ async def burned_register(
             bool: ``True`` if the registration is successful, False otherwise.
         """
         async with self:
+            if netuid == 0:
+                return await root_register_extrinsic(
+                    subtensor=self,
+                    wallet=wallet,
+                    wait_for_inclusion=wait_for_inclusion,
+                    wait_for_finalization=wait_for_finalization,
+                )
+
             return await burned_register_extrinsic(
                 subtensor=self,
                 wallet=wallet,
@@ -3205,35 +3222,6 @@ async def root_register(
         Returns:
             `True` if registration was successful, otherwise `False`.
         """
-        netuid = 0
-        logging.info(
-            f"Registering on netuid [blue]0[/blue] on network: [blue]{self.network}[/blue]"
-        )
-
-        # Check current recycle amount
-        logging.info("Fetching recycle amount & balance.")
-        block_hash = block_hash if block_hash else await self.get_block_hash()
-
-        try:
-            recycle_call, balance = await asyncio.gather(
-                self.get_hyperparameter(
-                    param_name="Burn", netuid=netuid, block_hash=block_hash
-                ),
-                self.get_balance(wallet.coldkeypub.ss58_address, block_hash=block_hash),
-            )
-        except TypeError as e:
-            logging.error(f"Unable to retrieve current recycle. {e}")
-            return False
-
-        current_recycle = Balance.from_rao(int(recycle_call))
-
-        # Check balance is sufficient
-        if balance < current_recycle:
-            logging.error(
-                f"[red]Insufficient balance {balance} to register neuron. "
-                f"Current recycle is {current_recycle} TAO[/red]."
-            )
-            return False
 
         return await root_register_extrinsic(
             subtensor=self,
@@ -3281,6 +3269,82 @@ async def root_set_weights(
             wait_for_inclusion=wait_for_inclusion,
         )
 
+    async def set_delegate_take(
+        self,
+        wallet: "Wallet",
+        hotkey_ss58: str,
+        take: float,
+        wait_for_inclusion: bool = True,
+        wait_for_finalization: bool = True,
+        raise_error: bool = False,
+    ) -> tuple[bool, str]:
+        """
+        Sets the delegate 'take' percentage for a neuron identified by its hotkey.
+        The 'take' represents the percentage of rewards that the delegate claims from its nominators' stakes.
+
+        Arguments:
+            wallet (bittensor_wallet.Wallet): bittensor wallet instance.
+            hotkey_ss58 (str): The ``SS58`` address of the neuron's hotkey.
+            take (float): Percentage reward for the delegate.
+            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.
+            raise_error: Raises relevant exception rather than returning `False` if unsuccessful.
+
+        Returns:
+            tuple[bool, str]: A tuple where the first element is a boolean indicating success or failure of the
+             operation, and the second element is a message providing additional information.
+
+        Raises:
+            DelegateTakeTooHigh: Delegate take is too high.
+            DelegateTakeTooLow: Delegate take is too low.
+            DelegateTxRateLimitExceeded: A transactor exceeded the rate limit for delegate transaction.
+            HotKeyAccountNotExists: The hotkey does not exists.
+            NonAssociatedColdKey: Request to stake, unstake or subscribe is made by a coldkey that is not associated with the hotkey account.
+            bittensor_wallet.errors.PasswordError: Decryption failed or wrong password for decryption provided.
+            bittensor_wallet.errors.KeyFileError: Failed to decode keyfile data.
+
+        The delegate take is a critical parameter in the network's incentive structure, influencing the distribution of
+            rewards among neurons and their nominators.
+        """
+
+        # u16 representation of the take
+        take_u16 = int(take * 0xFFFF)
+
+        current_take = await self.get_delegate_take(hotkey_ss58)
+        current_take_u16 = int(current_take * 0xFFFF)
+
+        if current_take_u16 == take_u16:
+            logging.info(":white_heavy_check_mark: [green]Already Set[/green]")
+            return True, ""
+
+        logging.info(f"Updating {hotkey_ss58} take: current={current_take} new={take}")
+
+        if current_take_u16 < take_u16:
+            success, error = await increase_take_extrinsic(
+                self,
+                wallet,
+                hotkey_ss58,
+                take_u16,
+                wait_for_finalization=wait_for_finalization,
+                wait_for_inclusion=wait_for_inclusion,
+                raise_error=raise_error,
+            )
+        else:
+            success, error = await decrease_take_extrinsic(
+                self,
+                wallet,
+                hotkey_ss58,
+                take_u16,
+                wait_for_finalization=wait_for_finalization,
+                wait_for_inclusion=wait_for_inclusion,
+                raise_error=raise_error,
+            )
+
+        if success:
+            logging.info(":white_heavy_check_mark: [green]Take Updated[/green]")
+
+        return success, error
+
     async def set_subnet_identity(
         self,
         wallet: "Wallet",
@@ -3476,7 +3540,7 @@ async def swap_stake(
         wait_for_finalization: bool = False,
         safe_staking: bool = False,
         allow_partial_stake: bool = False,
-        rate_threshold: float = 0.005,
+        rate_tolerance: float = 0.005,
     ) -> bool:
         """
         Moves stake between subnets while keeping the same coldkey-hotkey pair ownership.
@@ -3491,12 +3555,12 @@ async def swap_stake(
             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 swap
-                will only execute if the price ratio between subnets doesn't exceed the rate threshold.
+                will only execute if the price ratio between subnets doesn't exceed the rate tolerance.
                 Default is False.
             allow_partial_stake (bool): If true and safe_staking is enabled, allows partial stake swaps when
                 the full amount would exceed the price threshold. If false, the entire swap fails if it would
                 exceed the threshold. Default is False.
-            rate_threshold (float): The maximum allowed increase in the price ratio between subnets
+            rate_tolerance (float): The maximum allowed increase in the price ratio between subnets
                 (origin_price/destination_price). For example, 0.005 = 0.5% maximum increase. Only used
                 when safe_staking is True. Default is 0.005.
 
@@ -3506,9 +3570,9 @@ async def swap_stake(
         The price ratio for swap_stake in safe mode is calculated as: origin_subnet_price / destination_subnet_price
         When safe_staking is enabled, the swap will only execute if:
             - With allow_partial_stake=False: The entire swap amount can be executed without the price ratio
-            increasing more than rate_threshold
+            increasing more than rate_tolerance
             - With allow_partial_stake=True: A partial amount will be swapped up to the point where the
-            price ratio would increase by rate_threshold
+            price ratio would increase by rate_tolerance
         """
         amount = check_and_convert_to_balance(amount)
         return await swap_stake_extrinsic(
@@ -3522,7 +3586,7 @@ async def swap_stake(
             wait_for_finalization=wait_for_finalization,
             safe_staking=safe_staking,
             allow_partial_stake=allow_partial_stake,
-            rate_threshold=rate_threshold,
+            rate_tolerance=rate_tolerance,
         )
 
     async def transfer_stake(
@@ -3613,7 +3677,7 @@ async def unstake(
         wait_for_finalization: bool = False,
         safe_staking: bool = False,
         allow_partial_stake: bool = False,
-        rate_threshold: float = 0.005,
+        rate_tolerance: float = 0.005,
     ) -> bool:
         """
         Removes a specified amount of stake from a single hotkey account. This function is critical for adjusting
@@ -3628,11 +3692,11 @@ async def unstake(
             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 threshold. Default is False.
+                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_threshold (float): The maximum allowed price change ratio when unstaking. For example,
+            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.
 
         Returns:
@@ -3652,7 +3716,7 @@ async def unstake(
             wait_for_finalization=wait_for_finalization,
             safe_staking=safe_staking,
             allow_partial_stake=allow_partial_stake,
-            rate_threshold=rate_threshold,
+            rate_tolerance=rate_tolerance,
         )
 
     async def unstake_multiple(