Merge branch 'staging' into feat/roman/selective_metagraph_back

Author: basfroman

.circleci/config.yml

@@ -267,7 +267,7 @@ workflows:
       - build-and-test:
           matrix:
             parameters:
-              python-version: [ "3.9.13", "3.10.6", "3.11.4", "3.12.7"]
+              python-version: [ "3.9.13", "3.10.6", "3.11.4", "3.12.7", "3.13.1" ]
           requires:
             - check-if-pr-is-draft
       - unit-tests-all-python-versions:
@@ -276,7 +276,7 @@ workflows:
       - lint-and-type-check:
           matrix:
             parameters:
-              python-version: [ "3.9.13", "3.10.6", "3.11.4", "3.12.7"]
+              python-version: [ "3.9.13", "3.10.6", "3.11.4", "3.12.7", "3.13.1" ]
           requires:
             - check-if-pr-is-draft
       #- coveralls:

bittensor/core/async_subtensor.py

@@ -33,6 +33,7 @@
 from bittensor.core.chain_data.chain_identity import ChainIdentity
 from bittensor.core.chain_data.delegate_info import DelegatedInfo
 from bittensor.core.chain_data.utils import (
+    decode_block,
     decode_metadata,
     decode_revealed_commitment,
     decode_revealed_commitment_with_hotkey,
@@ -60,6 +61,7 @@
     root_register_extrinsic,
 )
 from bittensor.core.extrinsics.asyncex.serving import (
+    get_last_bonds_reset,
     publish_metadata,
     get_metadata,
 )
@@ -75,6 +77,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,
 )
@@ -1172,6 +1175,34 @@ async def get_commitment(
         except TypeError:
             return ""
 
+    async def get_last_commitment_bonds_reset_block(
+        self, netuid: int, uid: int
+    ) -> Optional[int]:
+        """
+        Retrieves the last block number when the bonds reset were triggered by publish_metadata for a specific neuron.
+
+        Arguments:
+            netuid (int): The unique identifier of the subnetwork.
+            uid (int): The unique identifier of the neuron.
+
+        Returns:
+            Optional[int]: The block number when the bonds were last reset, or None if not found.
+        """
+
+        metagraph = await self.metagraph(netuid)
+        try:
+            hotkey = metagraph.hotkeys[uid]
+        except IndexError:
+            logging.error(
+                "Your uid is not in the hotkeys. Please double-check your UID."
+            )
+            return None
+        block = await get_last_bonds_reset(self, netuid, hotkey)
+        try:
+            return decode_block(block)
+        except TypeError:
+            return ""
+
     async def get_all_commitments(
         self,
         netuid: int,
@@ -1202,7 +1233,7 @@ async def get_all_commitments(
         )
         result = {}
         async for id_, value in query:
-            result[decode_account_id(id_[0])] = decode_metadata(value)
+            result[decode_account_id(id_[0])] = decode_metadata(value.value)
         return result
 
     async def get_revealed_commitment_by_hotkey(
@@ -2309,7 +2340,7 @@ async def get_subnet_hyperparameters(
         """
         result = await self.query_runtime_api(
             runtime_api="SubnetInfoRuntimeApi",
-            method="get_subnet_hyperparams",
+            method="get_subnet_hyperparams_v2",
             params=[netuid],
             block=block,
             block_hash=block_hash,
@@ -3125,6 +3156,7 @@ async def subnet(
 
         if isinstance(decoded := query.decode(), dict):
             return DynamicInfo.from_dict(decoded)
+        return None
 
     async def subnet_exists(
         self,
@@ -4639,6 +4671,90 @@ async def unstake(
             unstake_all=unstake_all,
         )
 
+    async def unstake_all(
+        self,
+        wallet: "Wallet",
+        hotkey: str,
+        netuid: int,
+        rate_tolerance: Optional[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: 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. 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
+                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 safely, use default `rate_tolerance` or pass your
+                value:
+            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,
+                )
+                print(result)
+
+            # 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(
+                f"Unstaking without Alpha price control from subnet [blue]#{netuid}[/blue]."
+            )
+        return await unstake_all_extrinsic(
+            subtensor=self,
+            wallet=wallet,
+            hotkey=hotkey,
+            netuid=netuid,
+            rate_tolerance=rate_tolerance,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+            period=period,
+        )
+
     async def unstake_multiple(
         self,
         wallet: "Wallet",

bittensor/core/chain_data/subnet_hyperparameters.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-
+from bittensor.utils.balance import fixed_to_float
 from bittensor.core.chain_data.info_base import InfoBase
 
 
@@ -36,6 +36,12 @@ class SubnetHyperparameters(InfoBase):
         alpha_high (int): High value of alpha.
         alpha_low (int): Low value of alpha.
         liquid_alpha_enabled (bool): Flag indicating if liquid alpha is enabled.
+        alpha_sigmoid_steepness (float):
+        yuma_version (int): Version of yuma.
+        subnet_is_active (bool): Indicates if subnet is active after START CALL.
+        transfers_enabled (bool): Flag indicating if transfers are enabled.
+        bonds_reset_enabled (bool): Flag indicating if bonds are reset enabled.
+        user_liquidity_enabled (bool): Flag indicating if user liquidity is enabled.
     """
 
     rho: int
@@ -65,6 +71,12 @@ class SubnetHyperparameters(InfoBase):
     alpha_high: int
     alpha_low: int
     liquid_alpha_enabled: bool
+    alpha_sigmoid_steepness: float
+    yuma_version: int
+    subnet_is_active: bool
+    transfers_enabled: bool
+    bonds_reset_enabled: bool
+    user_liquidity_enabled: bool
 
     @classmethod
     def _from_dict(cls, decoded: dict) -> "SubnetHyperparameters":
@@ -75,7 +87,11 @@ def _from_dict(cls, decoded: dict) -> "SubnetHyperparameters":
             adjustment_interval=decoded["adjustment_interval"],
             alpha_high=decoded["alpha_high"],
             alpha_low=decoded["alpha_low"],
+            alpha_sigmoid_steepness=fixed_to_float(
+                decoded["alpha_sigmoid_steepness"], frac_bits=32
+            ),
             bonds_moving_avg=decoded["bonds_moving_avg"],
+            bonds_reset_enabled=decoded["bonds_reset_enabled"],
             commit_reveal_weights_enabled=decoded["commit_reveal_weights_enabled"],
             commit_reveal_period=decoded["commit_reveal_period"],
             difficulty=decoded["difficulty"],
@@ -93,8 +109,12 @@ def _from_dict(cls, decoded: dict) -> "SubnetHyperparameters":
             registration_allowed=decoded["registration_allowed"],
             rho=decoded["rho"],
             serving_rate_limit=decoded["serving_rate_limit"],
+            subnet_is_active=decoded["subnet_is_active"],
             target_regs_per_interval=decoded["target_regs_per_interval"],
             tempo=decoded["tempo"],
+            transfers_enabled=decoded["transfers_enabled"],
+            user_liquidity_enabled=decoded["user_liquidity_enabled"],
             weights_rate_limit=decoded["weights_rate_limit"],
             weights_version=decoded["weights_version"],
+            yuma_version=decoded["yuma_version"],
         )

bittensor/core/chain_data/utils.py

@@ -4,6 +4,7 @@
 from typing import Optional, Union, TYPE_CHECKING
 
 from scalecodec.base import RuntimeConfiguration, ScaleBytes
+from async_substrate_interface.types import ScaleObj
 from scalecodec.type_registry import load_type_registry_preset
 from scalecodec.utils.ss58 import ss58_encode
 
@@ -136,10 +137,24 @@ def process_stake_data(stake_data: list) -> dict:
 
 def decode_metadata(metadata: dict) -> str:
     commitment = metadata["info"]["fields"][0][0]
-    bytes_tuple = commitment[next(iter(commitment.keys()))][0]
+    bytes_tuple_ = commitment[next(iter(commitment.keys()))]
+    bytes_tuple = bytes_tuple_[0] if len(bytes_tuple_) > 0 else bytes_tuple_
     return bytes(bytes_tuple).decode()
 
 
+def decode_block(data: bytes) -> int:
+    """
+    Decode the block data from the given input if it is not None.
+
+    Arguments:
+        data (bytes): The block data to decode.
+
+    Returns:
+        int: The decoded block.
+    """
+    return int(data.value) if isinstance(data, ScaleObj) else data
+
+
 def decode_revealed_commitment(encoded_data) -> tuple[int, str]:
     """
     Decode the revealed commitment data from the given input if it is not None.

bittensor/core/extrinsics/asyncex/serving.py

@@ -236,6 +236,7 @@ async def publish_metadata(
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
     period: Optional[int] = None,
+    reset_bonds: bool = False,
 ) -> bool:
     """
     Publishes metadata on the Bittensor network using the specified wallet and network identifier.
@@ -256,6 +257,7 @@ async def publish_metadata(
         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.
+        reset_bonds (bool): If `True`, the function will reset the bonds for the neuron. Defaults to `False`.
 
     Returns:
         bool: ``True`` if the metadata was successfully published (and finalized if specified). ``False`` otherwise.
@@ -269,13 +271,17 @@ async def publish_metadata(
         logging.error(unlock.message)
         return False
 
+    fields = [{f"{data_type}": data}]
+    if reset_bonds:
+        fields.append({"ResetBondsFlag": b""})
+
     async with subtensor.substrate as substrate:
         call = await substrate.compose_call(
             call_module="Commitments",
             call_function="set_commitment",
             call_params={
                 "netuid": netuid,
-                "info": {"fields": [[{f"{data_type}": data}]]},
+                "info": {"fields": [fields]},
             },
         )
 
@@ -314,3 +320,22 @@ async def get_metadata(
             reuse_block_hash=reuse_block,
         )
     return commit_data
+
+
+async def get_last_bonds_reset(
+    subtensor: "AsyncSubtensor",
+    netuid: int,
+    hotkey: str,
+    block: Optional[int] = None,
+    block_hash: Optional[str] = None,
+    reuse_block: bool = False,
+) -> bytes:
+    """Fetches the last bonds reset triggered at commitment from the blockchain for a given hotkey and netuid."""
+    block_hash = await subtensor.determine_block_hash(block, block_hash, reuse_block)
+    block = await subtensor.substrate.query(
+        module="Commitments",
+        storage_function="LastBondsReset",
+        params=[netuid, hotkey],
+        block_hash=block_hash,
+    )
+    return block