Merge branch 'staging' into tests/zyzniewski/async_e2e

Author: basfroman

.circleci/config.yml

@@ -290,6 +290,9 @@ workflows:
       - check_compatibility:
           python_version: "3.12"
           name: check-compatibility-3.12
+      - check_compatibility:
+          python_version: "3.13"
+          name: check-compatibility-3.13
 
 
   pr-requirements:
@@ -302,7 +305,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"]
           requires:
             - check-if-pr-is-draft
       - unit-tests-all-python-versions:
@@ -311,7 +314,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"]
           requires:
             - check-if-pr-is-draft
       #- coveralls:

bittensor/core/async_subtensor.py

@@ -27,9 +27,14 @@
     decode_account_id,
     DynamicInfo,
 )
+from bittensor_commit_reveal import get_encrypted_commitment
 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_metadata
+from bittensor.core.chain_data.utils import (
+    decode_metadata,
+    decode_revealed_commitment,
+    decode_revealed_commitment_with_hotkey,
+)
 from bittensor.core.config import Config
 from bittensor.core.errors import ChainError, SubstrateRequestException
 from bittensor.core.extrinsics.asyncex.commit_reveal import commit_reveal_v3_extrinsic
@@ -1059,6 +1064,68 @@ async def get_all_commitments(
             result[decode_account_id(id_[0])] = decode_metadata(value)
         return result
 
+    async def get_revealed_commitment(
+        self,
+        netuid: int,
+        hotkey_ss58_address: Optional[str] = None,
+        block: Optional[int] = None,
+        block_hash: Optional[str] = None,
+        reuse_block: bool = False,
+    ) -> Optional[tuple[int, str]]:
+        """Returns hotkey related revealed commitment for a given netuid.
+
+        Arguments:
+            netuid (int): The unique identifier of the subnetwork.
+            block (Optional[int]): The block number to retrieve the commitment from. Default is ``None``.
+            hotkey_ss58_address (str): The ss58 address of the committee member.
+            block_hash (Optional[str]): The hash of the block to retrieve the subnet unique identifiers from.
+            reuse_block (bool): Whether to reuse the last-used block hash.
+
+        Returns:
+            result (tuple[int, str): A tuple of reveal block and commitment message.
+        """
+        query = await self.query_module(
+            module="Commitments",
+            name="RevealedCommitments",
+            params=[netuid, hotkey_ss58_address],
+            block=block,
+            block_hash=block_hash,
+            reuse_block=reuse_block,
+        )
+        return decode_revealed_commitment(query)
+
+    async def get_all_revealed_commitments(
+        self,
+        netuid: int,
+        block: Optional[int] = None,
+        block_hash: Optional[str] = None,
+        reuse_block: bool = False,
+    ) -> dict[str, tuple[int, str]]:
+        """Returns all revealed commitments for a given netuid.
+
+        Arguments:
+            netuid (int): The unique identifier of the subnetwork.
+            block (Optional[int]): The block number to retrieve the commitment from. Default is ``None``.
+            block_hash (Optional[str]): The hash of the block to retrieve the subnet unique identifiers from.
+            reuse_block (bool): Whether to reuse the last-used block hash.
+
+        Returns:
+            result (dict): A dictionary of all revealed commitments in view {ss58_address: (reveal block, commitment message)}.
+        """
+        query = await self.query_map(
+            module="Commitments",
+            name="RevealedCommitments",
+            params=[netuid],
+            block=block,
+            block_hash=block_hash,
+            reuse_block=reuse_block,
+        )
+
+        result = {}
+        async for item in query:
+            result.update(decode_revealed_commitment_with_hotkey(item))
+        return result
+
     async def get_current_weight_commit_info(
         self,
         netuid: int,
@@ -1572,6 +1639,36 @@ async def get_neuron_for_pubkey_and_subnet(
                 reuse_block=reuse_block,
             )
 
+    async def get_owned_hotkeys(
+        self,
+        coldkey_ss58: str,
+        block: Optional[int] = None,
+        block_hash: Optional[str] = None,
+        reuse_block: bool = False,
+    ) -> list[str]:
+        """
+        Retrieves all hotkeys owned by a specific coldkey address.
+
+        Args:
+            coldkey_ss58 (str): The SS58 address of the coldkey to query.
+            block (int): The blockchain block number for the query.
+            block_hash (str): The hash of the blockchain block number for the query.
+            reuse_block (bool): Whether to reuse the last-used blockchain block hash.
+
+        Returns:
+            list[str]: A list of hotkey SS58 addresses owned by the coldkey.
+        """
+        block_hash = await self.determine_block_hash(block, block_hash, reuse_block)
+        owned_hotkeys = await self.substrate.query(
+            module="SubtensorModule",
+            storage_function="OwnedHotkeys",
+            params=[coldkey_ss58],
+            block_hash=block_hash,
+            reuse_block_hash=reuse_block,
+        )
+
+        return [decode_account_id(hotkey[0]) for hotkey in owned_hotkeys or []]
+
     async def get_stake(
         self,
         coldkey_ss58: str,
@@ -2620,6 +2717,46 @@ async def recycle(
         )
         return None if call is None else Balance.from_rao(int(call))
 
+    async def set_reveal_commitment(
+        self,
+        wallet,
+        netuid: int,
+        data: str,
+        blocks_until_reveal: int = 360,
+        block_time: Union[int, float] = 12,
+    ) -> tuple[bool, int]:
+        """
+        Commits arbitrary data to the Bittensor network by publishing metadata.
+
+        Arguments:
+            wallet (bittensor_wallet.Wallet): The wallet associated with the neuron committing the data.
+            netuid (int): The unique identifier of the subnetwork.
+            data (str): The data to be committed to the network.
+            blocks_until_reveal (int): The number of blocks from now after which the data will be revealed. Defaults to `360`.
+                Then amount of blocks in one epoch.
+            block_time (Union[int, float]): The number of seconds between each block. Defaults to `12`.
+
+        Returns:
+            bool: `True` if the commitment was successful, `False` otherwise.
+
+        Note: A commitment can be set once per subnet epoch and is reset at the next epoch in the chain automatically.
+        """
+
+        encrypted, reveal_round = get_encrypted_commitment(
+            data, blocks_until_reveal, block_time
+        )
+
+        # increase reveal_round in return + 1 because we want to fetch data from the chain after that round was revealed
+        # and stored.
+        data_ = {"encrypted": encrypted, "reveal_round": reveal_round}
+        return await publish_metadata(
+            subtensor=self,
+            wallet=wallet,
+            netuid=netuid,
+            data_type=f"TimelockEncrypted",
+            data=data_,
+        ), reveal_round
+
     async def subnet(
         self,
         netuid: int,

bittensor/core/axon.py

@@ -976,7 +976,9 @@ async def default_verify(self, synapse: "Synapse"):
                 ):
                     raise Exception("Nonce is too old, a newer one was last processed")
 
-            if not keypair.verify(message, synapse.dendrite.signature):
+            if synapse.dendrite.signature and not keypair.verify(
+                message, synapse.dendrite.signature
+            ):
                 raise Exception(
                     f"Signature mismatch with {message} and {synapse.dendrite.signature}"
                 )

bittensor/core/chain_data/utils.py

@@ -1,7 +1,7 @@
 """Chain data helper functions and data."""
 
 from enum import Enum
-from typing import Optional, Union
+from typing import Optional, Union, TYPE_CHECKING
 
 from scalecodec.base import RuntimeConfiguration, ScaleBytes
 from scalecodec.type_registry import load_type_registry_preset
@@ -10,6 +10,9 @@
 from bittensor.core.settings import SS58_FORMAT
 from bittensor.utils.balance import Balance
 
+if TYPE_CHECKING:
+    from async_substrate_interface.types import ScaleObj
+
 
 class ChainDataType(Enum):
     NeuronInfo = 1
@@ -135,3 +138,36 @@ def decode_metadata(metadata: dict) -> str:
     commitment = metadata["info"]["fields"][0][0]
     bytes_tuple = commitment[next(iter(commitment.keys()))][0]
     return bytes(bytes_tuple).decode()
+
+
+def decode_revealed_commitment(
+    value: Optional["ScaleObj"],
+) -> Optional[tuple[int, str]]:
+    """Decode the revealed commitment data from the given input if it is not None."""
+    if value is None:
+        return None
+
+    def scale_decode_offset(data: bytes) -> int:
+        """Decodes the scale offset from a given byte data sequence."""
+        first_byte = data[0]
+        mode = first_byte & 0b11
+        if mode == 0:
+            return 1
+        elif mode == 1:
+            return 2
+        else:
+            return 4
+
+    v = next(iter(value))
+    revealed_block = v[1]
+    cut = scale_decode_offset(v[0])
+
+    revealed_commitment = bytes(v[0][cut:]).decode("utf-8", errors="ignore")
+    return revealed_block, revealed_commitment
+
+
+def decode_revealed_commitment_with_hotkey(data: list) -> dict[str, tuple[int, str]]:
+    """Decode revealed commitment using a hotkey."""
+    key, value = data
+    ss58_address = decode_account_id(key[0])
+    return {ss58_address: decode_revealed_commitment(value)}

bittensor/core/extrinsics/asyncex/serving.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, Union, TYPE_CHECKING
 
 from bittensor.core.errors import MetadataError
 from bittensor.core.settings import version_as_int
@@ -226,7 +226,7 @@ async def publish_metadata(
     wallet: "Wallet",
     netuid: int,
     data_type: str,
-    data: bytes,
+    data: Union[bytes, dict],
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
 ) -> bool:
@@ -240,8 +240,8 @@ async def publish_metadata(
         data_type (str): The data type of the information being submitted. It should be one of the following:
             ``'Sha256'``, ``'Blake256'``, ``'Keccak256'``, or ``'Raw0-128'``. This specifies the format or hashing
             algorithm used for the data.
-        data (str): The actual metadata content to be published. This should be formatted or hashed according to the
-            ``type`` specified. (Note: max ``str`` length is 128 bytes)
+        data (Union[bytes, dict]): The actual metadata content to be published. This should be formatted or hashed
+            according to the ``type`` specified. (Note: max ``str`` length is 128 bytes for ``'Raw0-128'``.)
         wait_for_inclusion (bool, optional): If ``True``, the function will wait for the extrinsic to be included in a
             block before returning. Defaults to ``False``.
         wait_for_finalization (bool, optional): If ``True``, the function will wait for the extrinsic to be finalized

bittensor/core/extrinsics/asyncex/weights.py

@@ -319,7 +319,7 @@ async def set_weights_extrinsic(
     )
 
     logging.info(
-        ":satellite: [magenta]Setting weights on [/magenta][blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+        f":satellite: [magenta]Setting weights on [/magenta][blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
     )
     try:
         success, error_message = await _do_set_weights(

bittensor/core/extrinsics/serving.py

@@ -1,4 +1,4 @@
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, Union, TYPE_CHECKING
 
 from bittensor.core.errors import MetadataError
 from bittensor.core.settings import version_as_int
@@ -222,7 +222,7 @@ def publish_metadata(
     wallet: "Wallet",
     netuid: int,
     data_type: str,
-    data: bytes,
+    data: Union[bytes, dict],
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
 ) -> bool:
@@ -236,8 +236,8 @@ def publish_metadata(
         data_type (str): The data type of the information being submitted. It should be one of the following:
             ``'Sha256'``, ``'Blake256'``, ``'Keccak256'``, or ``'Raw0-128'``. This specifies the format or hashing
             algorithm used for the data.
-        data (str): The actual metadata content to be published. This should be formatted or hashed according to the
-            ``type`` specified. (Note: max ``str`` length is 128 bytes)
+        data (Union[bytes, dict]): The actual metadata content to be published. This should be formatted or hashed
+            according to the ``type`` specified. (Note: max ``str`` length is 128 bytes for ``'Raw0-128'``.)
         wait_for_inclusion (bool, optional): If ``True``, the function will wait for the extrinsic to be included in a
             block before returning. Defaults to ``False``.
         wait_for_finalization (bool, optional): If ``True``, the function will wait for the extrinsic to be finalized

bittensor/core/extrinsics/set_weights.py

@@ -123,7 +123,7 @@ def set_weights_extrinsic(
     )
 
     logging.info(
-        ":satellite: [magenta]Setting weights on [/magenta][blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+        f":satellite: [magenta]Setting weights on [/magenta][blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
     )
     try:
         success, error_message = _do_set_weights(