Merge branch 'staging' into fix/zyzniewski/unittests_warnings

Author: basfroman

.github/workflows/docker_release.yml

@@ -18,7 +18,7 @@ jobs:
 
     steps:
     - name: Check out code
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     - name: Install cosign
       uses: sigstore/cosign-installer@v3
@@ -48,4 +48,4 @@ jobs:
         DIGEST: ${{ steps.build.outputs.digest }}
         TAGS: ${{ steps.build.outputs.tags }}
       run: |
-        echo "${TAGS}" | xargs -I {} cosign sign --yes {}@${DIGEST}
+        echo "${TAGS}" | xargs -I {} cosign sign --yes {}@${DIGEST}

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

@@ -12,6 +12,9 @@ on:
     branches: [master, development, staging]
     types: [ opened, synchronize, reopened, ready_for_review ]
 
+  schedule:
+    - cron: '0 9 * * *'  # Run every night at 2:00 PST
+
   workflow_dispatch:
     inputs:
       verbose:

.github/workflows/release.yml

@@ -13,7 +13,7 @@ jobs:
     name: Build Python distribution
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Set up Python
       uses: actions/setup-python@v4
@@ -69,4 +69,4 @@ jobs:
       uses: pypa/gh-action-pypi-publish@release/v1
       with:
         verbose: true
-        print-hash: true
+        print-hash: true

bittensor/core/async_subtensor.py

@@ -3,12 +3,12 @@
 from typing import Optional, Union, TYPE_CHECKING
 
 import numpy as np
-from bittensor_commit_reveal import get_encrypted_commit
+from bittensor_drand import get_encrypted_commit
 from numpy.typing import NDArray
 
 from bittensor.core.settings import version_as_int
 from bittensor.utils.btlogging import logging
-from bittensor.utils.weight_utils import convert_weights_and_uids_for_emit
+from bittensor.utils.weight_utils import convert_and_normalize_weights_and_uids
 
 if TYPE_CHECKING:
     from bittensor_wallet import Wallet
@@ -24,23 +24,26 @@ async def _do_commit_reveal_v3(
     reveal_round: int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-) -> tuple[bool, Optional[str]]:
+    period: Optional[int] = None,
+) -> tuple[bool, str]:
     """
-    Executes the commit-reveal phase 3 for a given netuid and commit, and optionally waits for extrinsic inclusion or
-    finalization.
+    Executes commit-reveal phase 3 for a given netuid and commit, and optionally waits for extrinsic inclusion or finalization.
 
     Arguments:
         subtensor: An instance of the AsyncSubtensor class.
         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.
+        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.
+        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.
 
     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.
+        A tuple where the first element is a boolean indicating success or failure, and the second element is a
+            string containing an error message if any.
     """
     logging.info(
         f"Committing weights hash [blue]{commit.hex()}[/blue] for subnet #[blue]{netuid}[/blue] with "
@@ -57,7 +60,12 @@ async def _do_commit_reveal_v3(
         },
     )
     return await subtensor.sign_and_send_extrinsic(
-        call, wallet, wait_for_inclusion, wait_for_finalization, sign_with="hotkey"
+        call=call,
+        wallet=wallet,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+        sign_with="hotkey",
+        period=period,
     )
 
 
@@ -70,10 +78,11 @@ async def commit_reveal_v3_extrinsic(
     version_key: int = version_as_int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-    block_time: float = 12.0,
+    block_time: Union[int, float] = 12.0,
+    period: Optional[int] = None,
 ) -> tuple[bool, str]:
     """
-    Commits and reveals weights for given subtensor and wallet with provided uids and weights.
+    Commits and reveals weights for a given subtensor and wallet with provided uids and weights.
 
     Arguments:
         subtensor: The AsyncSubtensor instance.
@@ -84,21 +93,17 @@ async def commit_reveal_v3_extrinsic(
         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.
-        block_time (float): The amount of seconds for block duration. Default is 12.0 seconds.
+        block_time (float): The number of seconds for block duration. Default is 12.0 seconds.
+        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.
 
     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 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)
+        uids, weights = convert_and_normalize_weights_and_uids(uids, weights)
 
         current_block = await subtensor.substrate.get_block(None)
         subnet_hyperparameters = await subtensor.get_subnet_hyperparameters(
@@ -127,6 +132,7 @@ async def commit_reveal_v3_extrinsic(
             reveal_round=reveal_round,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
+            period=period,
         )
 
         if success is not True:

bittensor/core/extrinsics/asyncex/commit_reveal.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from bittensor.utils.balance import Balance
 from bittensor.utils.btlogging import logging
@@ -18,6 +18,7 @@ async def _get_stake_in_origin_and_dest(
     origin_netuid: int,
     destination_netuid: int,
 ) -> tuple[Balance, Balance]:
+    """Gets the current stake balances for both origin and destination addresses in their respective subnets."""
     block_hash = await subtensor.substrate.get_chain_head()
     stake_in_origin, stake_in_destination = await asyncio.gather(
         subtensor.get_stake(
@@ -46,6 +47,7 @@ async def transfer_stake_extrinsic(
     amount: Balance,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = False,
+    period: Optional[int] = None,
 ) -> bool:
     """
     Transfers stake from one coldkey to another in the Bittensor network.
@@ -60,6 +62,9 @@ async def transfer_stake_extrinsic(
         amount (Balance): The amount of stake to transfer as a `Balance` object.
         wait_for_inclusion (bool): If True, waits for transaction inclusion in a block. Defaults to `True`.
         wait_for_finalization (bool): If True, waits for transaction finalization. Defaults to `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.
 
     Returns:
         bool: True if the transfer was successful, False otherwise.
@@ -77,7 +82,7 @@ async def transfer_stake_extrinsic(
 
     # Check sufficient stake
     stake_in_origin, stake_in_destination = await _get_stake_in_origin_and_dest(
-        subtensor,
+        subtensor=subtensor,
         origin_hotkey_ss58=hotkey_ss58,
         destination_hotkey_ss58=hotkey_ss58,
         origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
@@ -116,6 +121,7 @@ async def transfer_stake_extrinsic(
             wallet=wallet,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
+            period=period,
         )
 
         if success:
@@ -126,7 +132,7 @@ async def transfer_stake_extrinsic(
 
             # Get updated stakes
             origin_stake, dest_stake = await _get_stake_in_origin_and_dest(
-                subtensor,
+                subtensor=subtensor,
                 origin_hotkey_ss58=hotkey_ss58,
                 destination_hotkey_ss58=hotkey_ss58,
                 origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
@@ -163,6 +169,7 @@ async def swap_stake_extrinsic(
     safe_staking: bool = False,
     allow_partial_stake: bool = False,
     rate_tolerance: float = 0.005,
+    period: Optional[int] = None,
 ) -> bool:
     """
     Swaps stake from one subnet to another for a given hotkey in the Bittensor network.
@@ -178,7 +185,10 @@ async def swap_stake_extrinsic(
         wait_for_finalization (bool): If True, waits for transaction finalization. Defaults to False.
         safe_staking (bool): If true, enables price safety checks to protect against price impact.
         allow_partial_stake (bool): If true, allows partial stake swaps when the full amount would exceed the price tolerance.
-        rate_tolerance (float): Maximum allowed increase in price ratio (0.005 = 0.5%).
+        rate_tolerance (float): Maximum allowed increase in a price ratio (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.
 
     Returns:
         bool: True if the swap was successful, False otherwise.
@@ -195,7 +205,7 @@ async def swap_stake_extrinsic(
 
     # Check sufficient stake
     stake_in_origin, stake_in_destination = await _get_stake_in_origin_and_dest(
-        subtensor,
+        subtensor=subtensor,
         origin_hotkey_ss58=hotkey_ss58,
         destination_hotkey_ss58=hotkey_ss58,
         origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
@@ -259,6 +269,7 @@ async def swap_stake_extrinsic(
             wallet=wallet,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
+            period=period,
         )
 
         if success:
@@ -309,6 +320,7 @@ async def move_stake_extrinsic(
     amount: Balance,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = False,
+    period: Optional[int] = None,
 ) -> bool:
     """
     Moves stake from one hotkey to another within subnets in the Bittensor network.
@@ -323,6 +335,9 @@ async def move_stake_extrinsic(
         amount (Balance): The amount of stake to move as a `Balance` object.
         wait_for_inclusion (bool): If True, waits for transaction inclusion in a block. Defaults to True.
         wait_for_finalization (bool): If True, waits for transaction finalization. Defaults to 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.
 
     Returns:
         bool: True if the move was successful, False otherwise.
@@ -331,7 +346,7 @@ async def move_stake_extrinsic(
 
     # Check sufficient stake
     stake_in_origin, stake_in_destination = await _get_stake_in_origin_and_dest(
-        subtensor,
+        subtensor=subtensor,
         origin_hotkey_ss58=origin_hotkey,
         destination_hotkey_ss58=destination_hotkey,
         origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
@@ -369,6 +384,7 @@ async def move_stake_extrinsic(
             wallet=wallet,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
+            period=period,
         )
 
         if success:
@@ -379,7 +395,7 @@ async def move_stake_extrinsic(
 
             # Get updated stakes
             origin_stake, dest_stake = await _get_stake_in_origin_and_dest(
-                subtensor,
+                subtensor=subtensor,
                 origin_hotkey_ss58=origin_hotkey,
                 destination_hotkey_ss58=destination_hotkey,
                 origin_coldkey_ss58=wallet.coldkeypub.ss58_address,