Release/8.5.0

CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 8.5.0 /2024-12-12
+
+## What's Changed
+* add improved reveal-round params by @JohnReedV in https://github.com/opentensor/bittensor/pull/2509
+* fix: add default value to the get_block_number method in AsyncSubstrateInterface by @FLiotta in https://github.com/opentensor/bittensor/pull/2529
+* Mismatched "archive" index by @thewhaleking in https://github.com/opentensor/bittensor/pull/2530
+* Adds a factory function to create an initialised AsyncSubtensor object. by @thewhaleking in https://github.com/opentensor/bittensor/pull/2516
+* chore: fix some comments by @lvyaoting in https://github.com/opentensor/bittensor/pull/2515
+* Fixes E2E test chain buffer issues on devnet by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2531
+* Added e2e test for CRv3 + enhancements by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2532
+* Backmerge master to staging 850 by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2535
+* Enhancement/adds total stake functions by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2537
+* Fixes get_current_block by @thewhaleking in https://github.com/opentensor/bittensor/pull/2536
+* [SDK] Add `commit reveal v3` logic (python part only) by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2484
+
+## New Contributors
+* @JohnReedV made their first contribution in https://github.com/opentensor/bittensor/pull/2509
+* @FLiotta made their first contribution in https://github.com/opentensor/bittensor/pull/2529
+* @lvyaoting made their first contribution in https://github.com/opentensor/bittensor/pull/2515
+
+**Full Changelog**: https://github.com/opentensor/bittensor/compare/v8.4.5...v8.5.0
+
 ## 8.4.5 /2024-12-05
 
 ## What's Changed

VERSION

@@ -1 +1 @@
-8.4.5
+8.5.0

bittensor/__init__.py

@@ -17,11 +17,20 @@
 
 import warnings
 
-from .core.settings import __version__, version_split, DEFAULTS
+from .core.settings import __version__, version_split, DEFAULTS, DEFAULT_NETWORK
+from .core.async_subtensor import AsyncSubtensor
 from .utils.btlogging import logging
 from .utils.deprecated import *
 
 
+async def async_subtensor(network: str = DEFAULT_NETWORK) -> AsyncSubtensor:
+    """
+    Creates an initialised AsyncSubtensor object.
+    """
+    async with AsyncSubtensor(network=network) as subtensor_:
+        return subtensor_
+
+
 def __getattr__(name):
     if name == "version_split":
         warnings.warn(

bittensor/core/async_subtensor.py

@@ -236,7 +236,7 @@ async def get_current_block(self) -> int:
 
         Knowing the current block number is essential for querying real-time data and performing time-sensitive operations on the blockchain. It serves as a reference point for network activities and data synchronization.
         """
-        return await self.substrate.get_block_number()
+        return await self.substrate.get_block_number(None)
 
     async def get_block_hash(self, block_id: Optional[int] = None):
         """
@@ -1427,6 +1427,34 @@ async def blocks_since_last_update(self, netuid: int, uid: int) -> Optional[int]
         call = await self.get_hyperparameter(param_name="LastUpdate", netuid=netuid)
         return None if call is None else await self.get_current_block() - int(call[uid])
 
+    async def commit_reveal_enabled(
+        self, netuid: int, block_hash: Optional[str] = None
+    ) -> bool:
+        """
+        Check if commit-reveal mechanism is enabled for a given network at a specific block.
+
+        Arguments:
+            netuid (int): The network identifier for which to check the commit-reveal mechanism.
+            block_hash (Optional[str]): The block hash of block at which to check the parameter (default is None, which implies the current block).
+
+        Returns:
+            (bool): Returns the integer value of the hyperparameter if available; otherwise, returns None.
+        """
+        call = await self.get_hyperparameter(
+            param_name="CommitRevealWeightsEnabled",
+            block_hash=block_hash,
+            netuid=netuid,
+        )
+        return True if call is True else False
+
+    async def get_subnet_reveal_period_epochs(
+        self, netuid: int, block_hash: Optional[str] = None
+    ) -> int:
+        """Retrieve the SubnetRevealPeriodEpochs hyperparameter."""
+        return await self.get_hyperparameter(
+            param_name="RevealPeriodEpochs", block_hash=block_hash, netuid=netuid
+        )
+
     # Extrinsics =======================================================================================================
 
     async def transfer(
@@ -1568,35 +1596,43 @@ async def set_weights(
 
         This function is crucial in shaping the network's collective intelligence, where each neuron's learning and contribution are influenced by the weights it sets towards others【81†source】.
         """
-        uid = await self.get_uid_for_hotkey_on_subnet(
-            wallet.hotkey.ss58_address, netuid
-        )
-        retries = 0
-        success = False
-        message = "No attempt made. Perhaps it is too soon to set weights!"
-        while retries < max_retries and await self.blocks_since_last_update(
-            netuid, uid
-        ) > await self.weights_rate_limit(netuid):
-            try:
-                logging.info(
-                    f"Setting weights for subnet #[blue]{netuid}[/blue]. Attempt [blue]{retries + 1} of {max_retries}[/blue]."
-                )
-                success, message = await set_weights_extrinsic(
-                    subtensor=self,
-                    wallet=wallet,
-                    netuid=netuid,
-                    uids=uids,
-                    weights=weights,
-                    version_key=version_key,
-                    wait_for_inclusion=wait_for_inclusion,
-                    wait_for_finalization=wait_for_finalization,
-                )
-            except Exception as e:
-                logging.error(f"Error setting weights: {e}")
-            finally:
-                retries += 1
+        if self.commit_reveal_enabled(netuid=netuid) is True:
+            # go with `commit reveal v3` extrinsic
+            raise NotImplemented("Not implemented yet for AsyncSubtensor. Coming soon.")
+        else:
+            # go with classic `set weights extrinsic`
+            uid = await self.get_uid_for_hotkey_on_subnet(
+                wallet.hotkey.ss58_address, netuid
+            )
+            retries = 0
+            success = False
+            message = "No attempt made. Perhaps it is too soon to set weights!"
+            while (
+                retries < max_retries
+                and await self.blocks_since_last_update(netuid, uid)
+                > await self.weights_rate_limit(netuid)
+                and success is False
+            ):
+                try:
+                    logging.info(
+                        f"Setting weights for subnet #[blue]{netuid}[/blue]. Attempt [blue]{retries + 1} of {max_retries}[/blue]."
+                    )
+                    success, message = await set_weights_extrinsic(
+                        subtensor=self,
+                        wallet=wallet,
+                        netuid=netuid,
+                        uids=uids,
+                        weights=weights,
+                        version_key=version_key,
+                        wait_for_inclusion=wait_for_inclusion,
+                        wait_for_finalization=wait_for_finalization,
+                    )
+                except Exception as e:
+                    logging.error(f"Error setting weights: {e}")
+                finally:
+                    retries += 1
 
-        return success, message
+            return success, message
 
     async def root_set_weights(
         self,

bittensor/core/extrinsics/commit_reveal.py

@@ -0,0 +1,165 @@
+from typing import Optional, Union, TYPE_CHECKING
+
+import numpy as np
+from bittensor_commit_reveal import get_encrypted_commit
+from numpy.typing import NDArray
+
+from bittensor.core.extrinsics.utils import submit_extrinsic
+from bittensor.core.settings import version_as_int
+from bittensor.utils import format_error_message
+from bittensor.utils.btlogging import logging
+from bittensor.utils.networking import ensure_connected
+from bittensor.utils.registration import torch, use_torch
+from bittensor.utils.weight_utils import convert_weights_and_uids_for_emit
+
+if TYPE_CHECKING:
+    from bittensor_wallet import Wallet
+    from bittensor.core.subtensor import Subtensor
+
+
+@ensure_connected
+def _do_commit_reveal_v3(
+    self: "Subtensor",
+    wallet: "Wallet",
+    netuid: int,
+    commit: bytes,
+    reveal_round: int,
+    wait_for_inclusion: bool = False,
+    wait_for_finalization: bool = False,
+) -> tuple[bool, Optional[str]]:
+    """
+    Executes the commit-reveal phase 3 for a given netuid and commit, and optionally waits for extrinsic inclusion or finalization.
+
+    Arguments:
+        wallet: Wallet An instance of the Wallet class containing the user's keypair.
+        netuid: int The network unique identifier.
+        commit  bytes The commit data in bytes format.
+        reveal_round: int The round number for the reveal phase.
+        wait_for_inclusion: bool, optional Flag indicating whether to wait for the extrinsic to be included in a block.
+        wait_for_finalization: bool, optional Flag indicating whether to wait for the extrinsic to be finalized.
+
+    Returns:
+        A tuple where the first element is a boolean indicating success or failure, and the second element is an optional string containing error message if any.
+    """
+    logging.info(
+        f"Committing weights hash [blue]{commit.hex()}[/blue] for subnet #[blue]{netuid}[/blue] with "
+        f"reveal round [blue]{reveal_round}[/blue]..."
+    )
+
+    call = self.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="commit_crv3_weights",
+        call_params={
+            "netuid": netuid,
+            "commit": commit,
+            "reveal_round": reveal_round,
+        },
+    )
+    extrinsic = self.substrate.create_signed_extrinsic(
+        call=call,
+        keypair=wallet.hotkey,
+    )
+
+    response = submit_extrinsic(
+        subtensor=self,
+        extrinsic=extrinsic,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+    )
+
+    if not wait_for_finalization and not wait_for_inclusion:
+        return True, "Not waiting for finalization or inclusion."
+
+    response.process_events()
+    if response.is_success:
+        return True, None
+    else:
+        return False, format_error_message(
+            response.error_message, substrate=self.substrate
+        )
+
+
+def commit_reveal_v3_extrinsic(
+    subtensor: "Subtensor",
+    wallet: "Wallet",
+    netuid: int,
+    uids: Union[NDArray[np.int64], "torch.LongTensor", list],
+    weights: Union[NDArray[np.float32], "torch.FloatTensor", list],
+    version_key: int = version_as_int,
+    wait_for_inclusion: bool = False,
+    wait_for_finalization: bool = False,
+) -> tuple[bool, str]:
+    """
+    Commits and reveals weights for given subtensor and wallet with provided uids and weights.
+
+    Arguments:
+        subtensor: The Subtensor instance.
+        wallet: The wallet to use for committing and revealing.
+        netuid: The id of the network.
+        uids: The uids to commit.
+        weights: The weights associated with the uids.
+        version_key: The version key to use for committing and revealing. Default is version_as_int.
+        wait_for_inclusion: Whether to wait for the inclusion of the transaction. Default is False.
+        wait_for_finalization: Whether to wait for the finalization of the transaction. Default is False.
+
+    Returns:
+        tuple[bool, str]: A tuple where the first element is a boolean indicating success or failure, and the second element is a message associated with the result.
+    """
+    try:
+        # Convert uids and weights
+        if use_torch():
+            if isinstance(uids, list):
+                uids = torch.tensor(uids, dtype=torch.int64)
+            if isinstance(weights, list):
+                weights = torch.tensor(weights, dtype=torch.float32)
+        else:
+            if isinstance(uids, list):
+                uids = np.array(uids, dtype=np.int64)
+            if isinstance(weights, list):
+                weights = np.array(weights, dtype=np.float32)
+
+        # Reformat and normalize.
+        uids, weights = convert_weights_and_uids_for_emit(uids, weights)
+
+        current_block = subtensor.get_current_block()
+        subnet_hyperparameters = subtensor.get_subnet_hyperparameters(
+            netuid, block=current_block
+        )
+        tempo = subnet_hyperparameters.tempo
+        subnet_reveal_period_epochs = (
+            subnet_hyperparameters.commit_reveal_weights_interval
+        )
+
+        # Encrypt `commit_hash` with t-lock and `get reveal_round`
+        commit_for_reveal, reveal_round = get_encrypted_commit(
+            uids=uids,
+            weights=weights,
+            version_key=version_key,
+            tempo=tempo,
+            current_block=current_block,
+            netuid=netuid,
+            subnet_reveal_period_epochs=subnet_reveal_period_epochs,
+        )
+
+        success, message = _do_commit_reveal_v3(
+            self=subtensor,
+            wallet=wallet,
+            netuid=netuid,
+            commit=commit_for_reveal,
+            reveal_round=reveal_round,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+        )
+
+        if success is True:
+            logging.success(
+                f"[green]Finalized![/green] Weights commited with reveal round [blue]{reveal_round}[/blue]."
+            )
+            return True, f"reveal_round:{reveal_round}"
+        else:
+            logging.error(message)
+            return False, message
+
+    except Exception as e:
+        logging.error(f":cross_mark: [red]Failed. Error:[/red] {e}")
+        return False, str(e)

bittensor/core/extrinsics/set_weights.py

@@ -148,7 +148,7 @@ def set_weights_extrinsic(
     logging.debug(f"Weights: {[float(v / 65535) for v in weight_vals]}")
 
     try:
-        success, error_message = do_set_weights(
+        success, message = do_set_weights(
             self=subtensor,
             wallet=wallet,
             netuid=netuid,
@@ -166,8 +166,8 @@ def set_weights_extrinsic(
             logging.success(f"[green]Finalized![/green] Set weights: {str(success)}")
             return True, "Successfully set weights and Finalized."
         else:
-            logging.error(error_message)
-            return False, error_message
+            logging.error(message)
+            return False, message
 
     except Exception as e:
         logging.error(f":cross_mark: [red]Failed.[/red]: Error: {e}")

bittensor/core/metagraph.py

@@ -570,7 +570,7 @@ def sync(
 
         if (
             subtensor.chain_endpoint != settings.ARCHIVE_ENTRYPOINT
-            or subtensor.network != settings.NETWORKS[3]
+            or subtensor.network != "archive"
         ):
             cur_block = subtensor.get_current_block()
             if block and block < (cur_block - 300):

bittensor/core/settings.py

@@ -15,7 +15,7 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 # DEALINGS IN THE SOFTWARE.
 
-__version__ = "8.4.5"
+__version__ = "8.5.0"
 
 import os
 import re