Merge branch 'staging' into feat/roman/add-get_next_epoch_start_block

Author: basfroman

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

@@ -39,6 +39,8 @@ jobs:
         id: get-tests
         run: |
           test_files=$(find tests/e2e_tests -name "test*.py" | jq -R -s -c 'split("\n") | map(select(. != ""))')
+          # keep it here for future debug
+          # test_files=$(find tests/e2e_tests -type f -name "test*.py" | grep -E 'test_(incentive|commit_weights|set_weights)\.py$' | jq -R -s -c 'split("\n") | map(select(. != ""))')
           echo "::set-output name=test-files::$test_files"
         shell: bash
 
@@ -61,7 +63,7 @@ jobs:
           path: subtensor-localnet.tar
 
   # Job to run tests in parallel
-  run:
+  run-e2e-test:
     name: ${{ matrix.test-file }} / Python ${{ matrix.python-version }}
     needs:
       - find-tests
@@ -70,7 +72,7 @@ jobs:
     timeout-minutes: 45
     strategy:
       fail-fast: false  # Allow other matrix jobs to run even if this job fails
-      max-parallel: 32  # Set the maximum number of parallel jobs (same as we have cores in SubtensorCI runner)
+      max-parallel: 32  # Set the maximum number of parallel jobs (same as we have cores in ubuntu-latest runner)
       matrix:
         os:
           - ubuntu-latest

bittensor/core/async_subtensor.py

@@ -3845,6 +3845,7 @@ async def set_weights(
         wait_for_finalization: bool = False,
         max_retries: int = 5,
         block_time: float = 12.0,
+        period: int = 5,
     ):
         """
         Sets the inter-neuronal weights for the specified neuron. This process involves specifying the influence or
@@ -3865,6 +3866,7 @@ async def set_weights(
                 ``False``.
             max_retries (int): The number of maximum attempts to set weights. Default is ``5``.
             block_time (float): The amount of seconds for block duration. Default is 12.0 seconds.
+            period (int, optional): The period in seconds to wait for extrinsic inclusion or finalization. Defaults to 5.
 
         Returns:
             tuple[bool, str]: ``True`` if the setting of weights is successful, False otherwise. And `msg`, a string
@@ -3939,6 +3941,7 @@ async def _blocks_weight_limit() -> bool:
                         version_key=version_key,
                         wait_for_inclusion=wait_for_inclusion,
                         wait_for_finalization=wait_for_finalization,
+                        period=period,
                     )
                 except Exception as e:
                     logging.error(f"Error setting weights: {e}")

bittensor/core/extrinsics/asyncex/weights.py

@@ -287,6 +287,7 @@ async def set_weights_extrinsic(
     version_key: int = 0,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    period: int = 5,
 ) -> tuple[bool, str]:
     """Sets the given weights and values on chain for wallet hotkey account.
 
@@ -302,6 +303,7 @@ async def set_weights_extrinsic(
             returns ``False`` if the extrinsic fails to enter the block within the timeout.
         wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning
             ``True``, or returns ``False`` if the extrinsic fails to be finalized within the timeout.
+        period (int, optional): The period in seconds to wait for extrinsic inclusion or finalization. Defaults to 5.
 
     Returns:
         success (bool): Flag is ``True`` if extrinsic was finalized or included in the block. If we did not wait for
@@ -331,6 +333,7 @@ async def set_weights_extrinsic(
             version_key=version_key,
             wait_for_finalization=wait_for_finalization,
             wait_for_inclusion=wait_for_inclusion,
+            period=period,
         )
 
         if not wait_for_finalization and not wait_for_inclusion:

bittensor/core/extrinsics/set_weights.py

@@ -91,6 +91,7 @@ def set_weights_extrinsic(
     version_key: int = 0,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    period: int = 5,
 ) -> tuple[bool, str]:
     """Sets the given weights and values on chain for wallet hotkey account.
 
@@ -106,6 +107,7 @@ def set_weights_extrinsic(
             returns ``False`` if the extrinsic fails to enter the block within the timeout.
         wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning
             ``True``, or returns ``False`` if the extrinsic fails to be finalized within the timeout.
+        period (int, optional): The period in seconds to wait for extrinsic inclusion or finalization. Defaults to 5.
 
     Returns:
         success (bool): Flag is ``True`` if extrinsic was finalized or included in the block. If we did not wait for
@@ -135,6 +137,7 @@ def set_weights_extrinsic(
             version_key=version_key,
             wait_for_finalization=wait_for_finalization,
             wait_for_inclusion=wait_for_inclusion,
+            period=period,
         )
 
         if not wait_for_finalization and not wait_for_inclusion:

bittensor/core/subtensor.py

@@ -3122,6 +3122,7 @@ def set_weights(
         wait_for_finalization: bool = False,
         max_retries: int = 5,
         block_time: float = 12.0,
+        period: int = 5,
     ) -> tuple[bool, str]:
         """
         Sets the inter-neuronal weights for the specified neuron. This process involves specifying the influence or
@@ -3142,6 +3143,7 @@ def set_weights(
                 ``False``.
             max_retries (int): The number of maximum attempts to set weights. Default is ``5``.
             block_time (float): The amount of seconds for block duration. Default is 12.0 seconds.
+            period (int, optional): The period in seconds to wait for extrinsic inclusion or finalization. Defaults to 5.
 
         Returns:
             tuple[bool, str]: ``True`` if the setting of weights is successful, False otherwise. And `msg`, a string
@@ -3205,6 +3207,7 @@ def _blocks_weight_limit() -> bool:
                         version_key=version_key,
                         wait_for_inclusion=wait_for_inclusion,
                         wait_for_finalization=wait_for_finalization,
+                        period=period,
                     )
                 except Exception as e:
                     logging.error(f"Error setting weights: {e}")

bittensor/utils/__init__.py

@@ -250,6 +250,16 @@ def format_error_message(error_message: Union[dict, Exception]) -> str:
             err_docs = error_message.get("docs", [err_description])
             err_description = err_docs[0] if err_docs else err_description
 
+        elif error_message.get("code") and error_message.get("message"):
+            err_type = error_message.get("code", err_name)
+            err_name = "Custom type"
+            err_description = error_message.get("message", err_description)
+
+        else:
+            logging.error(
+                f"String representation of real error_message: {str(error_message)}"
+            )
+
     return f"Subtensor returned `{err_name}({err_type})` error. This means: `{err_description}`."
 
 

pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools~=70.0.0", "wheel"]
+requires = ["setuptools>=70.0.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -40,11 +40,11 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
-    "pytest==7.2.0",
-    "pytest-asyncio==0.23.7",
-    "pytest-mock==3.12.0",
-    "pytest-split==0.8.0",
-    "pytest-xdist==3.0.2",
+    "pytest==8.3.5",
+    "pytest-asyncio==0.26.0",
+    "pytest-mock==3.14.0",
+    "pytest-split==0.10.0",
+    "pytest-xdist==3.6.1",
     "pytest-rerunfailures==10.2",
     "coveralls==3.3.1",
     "pytest-cov==4.0.0",

tests/e2e_tests/test_commit_reveal_v3.py

@@ -96,7 +96,7 @@ async def test_commit_and_reveal_weights_cr3(local_chain, subtensor, alice_walle
 
     # Fetch current block and calculate next tempo for the subnet
     current_block = subtensor.get_current_block()
-    upcoming_tempo = next_tempo(current_block, tempo, netuid)
+    upcoming_tempo = next_tempo(current_block, tempo)
     logging.console.info(
         f"Checking if window is too low with Current block: {current_block}, next tempo: {upcoming_tempo}"
     )
@@ -114,7 +114,7 @@ async def test_commit_and_reveal_weights_cr3(local_chain, subtensor, alice_walle
         )
     current_block = subtensor.get_current_block()
     latest_drand_round = subtensor.last_drand_round()
-    upcoming_tempo = next_tempo(current_block, tempo, netuid)
+    upcoming_tempo = next_tempo(current_block, tempo)
     logging.console.info(
         f"Post first wait_interval (to ensure window isnt too low): {current_block}, next tempo: {upcoming_tempo}, drand: {latest_drand_round}"
     )
@@ -142,7 +142,7 @@ async def test_commit_and_reveal_weights_cr3(local_chain, subtensor, alice_walle
 
     current_block = subtensor.get_current_block()
     latest_drand_round = subtensor.last_drand_round()
-    upcoming_tempo = next_tempo(current_block, tempo, netuid)
+    upcoming_tempo = next_tempo(current_block, tempo)
     logging.console.info(
         f"After setting weights: Current block: {current_block}, next tempo: {upcoming_tempo}, drand: {latest_drand_round}"
     )
@@ -177,6 +177,9 @@ async def test_commit_and_reveal_weights_cr3(local_chain, subtensor, alice_walle
         f"Latest drand round after waiting for tempo: {latest_drand_round}"
     )
 
+    # for fast-block 3 seconds (drand round period) is 12 fast blocks. Let's make sure this round passed.
+    subtensor.wait_for_block(subtensor.block + 12)
+
     # Fetch weights on the chain as they should be revealed now
     revealed_weights_ = subtensor.weights(netuid=netuid)
 

tests/e2e_tests/test_commit_weights.py

@@ -1,13 +1,13 @@
-import asyncio
-
 import numpy as np
 import pytest
+import retry
 
+from bittensor.utils.btlogging import logging
 from bittensor.utils.weight_utils import convert_weights_and_uids_for_emit
 from tests.e2e_tests.utils.chain_interactions import (
     sudo_set_admin_utils,
     sudo_set_hyperparameter_bool,
-    use_and_wait_for_next_nonce,
+    execute_and_wait_for_next_nonce,
     wait_epoch,
 )
 
@@ -165,17 +165,30 @@ async def test_commit_weights_uses_next_nonce(local_chain, subtensor, alice_wall
     Raises:
         AssertionError: If any of the checks or verifications fail
     """
+    subnet_tempo = 50
+    netuid = 2
+
     # Wait for 2 tempos to pass as CR3 only reveals weights after 2 tempos
-    subtensor.wait_for_block(20)
+    subtensor.wait_for_block(subnet_tempo * 2 + 1)
 
-    netuid = 2
     print("Testing test_commit_and_reveal_weights")
     # Register root as Alice
     assert subtensor.register_subnet(alice_wallet), "Unable to register the subnet"
 
     # Verify subnet 1 created successfully
     assert subtensor.subnet_exists(netuid), "Subnet wasn't created successfully"
 
+    # weights sensitive to epoch changes
+    assert sudo_set_admin_utils(
+        local_chain,
+        alice_wallet,
+        call_function="sudo_set_tempo",
+        call_params={
+            "netuid": netuid,
+            "tempo": subnet_tempo,
+        },
+    )
+
     # Enable commit_reveal on the subnet
     assert sudo_set_hyperparameter_bool(
         local_chain,
@@ -203,72 +216,67 @@ async def test_commit_weights_uses_next_nonce(local_chain, subtensor, alice_wall
         call_params={"netuid": netuid, "weights_set_rate_limit": "0"},
     )
 
-    assert error is None
-    assert status is True
+    assert error is None and status is True, f"Failed to set rate limit: {error}"
 
     assert (
         subtensor.get_subnet_hyperparameters(netuid=netuid).weights_rate_limit == 0
     ), "Failed to set weights_rate_limit"
     assert subtensor.weights_rate_limit(netuid=netuid) == 0
 
-    # Commit-reveal values
-    uids = np.array([0], dtype=np.int64)
-    weights = np.array([0.1], dtype=np.float32)
-    salt = [18, 179, 107, 0, 165, 211, 141, 197]
-    weight_uids, weight_vals = convert_weights_and_uids_for_emit(
-        uids=uids, weights=weights
-    )
-
-    # Make a second salt
-    salt2 = salt.copy()
-    salt2[0] += 1  # Increment the first byte to produce a different commit hash
-
-    # Make a third salt
-    salt3 = salt.copy()
-    salt3[0] += 2  # Increment the first byte to produce a different commit hash
-
-    # Commit all three salts
-    async with use_and_wait_for_next_nonce(subtensor, alice_wallet):
-        success, message = subtensor.commit_weights(
-            alice_wallet,
-            netuid,
-            salt=salt,
-            uids=weight_uids,
-            weights=weight_vals,
-            wait_for_inclusion=False,  # Don't wait for inclusion, we are testing the nonce when there is a tx in the pool
-            wait_for_finalization=False,
+    # wait while weights_rate_limit changes applied.
+    subtensor.wait_for_block(subnet_tempo + 1)
+
+    # create different commited data to avoid coming into pool black list with the error
+    #   Failed to commit weights: Subtensor returned `Custom type(1012)` error. This means: `Transaction is temporarily
+    #   banned`.Failed to commit weights: Subtensor returned `Custom type(1012)` error. This means: `Transaction is
+    #   temporarily banned`.`
+    def get_weights_and_salt(counter: int):
+        # Commit-reveal values
+        salt_ = [18, 179, 107, counter, 165, 211, 141, 197]
+        uids_ = np.array([0], dtype=np.int64)
+        weights_ = np.array([counter / 10], dtype=np.float32)
+        weight_uids_, weight_vals_ = convert_weights_and_uids_for_emit(
+            uids=uids_, weights=weights_
         )
+        return salt_, weight_uids_, weight_vals_
 
-        assert success is True
+    logging.console.info(
+        f"[orange]Nonce before first commit_weights: "
+        f"{subtensor.substrate.get_account_next_index(alice_wallet.hotkey.ss58_address)}[/orange]"
+    )
 
-    async with use_and_wait_for_next_nonce(subtensor, alice_wallet):
+    # 3 time doing call if nonce wasn't updated, then raise error
+    @retry.retry(exceptions=Exception, tries=3, delay=1)
+    @execute_and_wait_for_next_nonce(subtensor=subtensor, wallet=alice_wallet)
+    def send_commit(salt_, weight_uids_, weight_vals_):
         success, message = subtensor.commit_weights(
-            alice_wallet,
-            netuid,
-            salt=salt2,
-            uids=weight_uids,
-            weights=weight_vals,
-            wait_for_inclusion=False,
-            wait_for_finalization=False,
+            wallet=alice_wallet,
+            netuid=netuid,
+            salt=salt_,
+            uids=weight_uids_,
+            weights=weight_vals_,
+            wait_for_inclusion=True,
+            wait_for_finalization=True,
         )
+        assert success is True, message
 
-        assert success is True
+    # send some amount of commit weights
+    AMOUNT_OF_COMMIT_WEIGHTS = 3
+    for call in range(AMOUNT_OF_COMMIT_WEIGHTS):
+        weight_uids, weight_vals, salt = get_weights_and_salt(call)
 
-    async with use_and_wait_for_next_nonce(subtensor, alice_wallet):
-        success, message = subtensor.commit_weights(
-            alice_wallet,
-            netuid,
-            salt=salt3,
-            uids=weight_uids,
-            weights=weight_vals,
-            wait_for_inclusion=False,
-            wait_for_finalization=False,
-        )
+        send_commit(salt, weight_uids, weight_vals)
 
-        assert success is True
+        # let's wait for 3 (12 fast blocks) seconds between transactions
+        subtensor.wait_for_block(subtensor.block + 12)
+
+    logging.console.info(
+        f"[orange]Nonce after third commit_weights: "
+        f"{subtensor.substrate.get_account_next_index(alice_wallet.hotkey.ss58_address)}[/orange]"
+    )
 
     # Wait a few blocks
-    await asyncio.sleep(10)  # Wait for the txs to be included in the chain
+    subtensor.wait_for_block(subtensor.block + subtensor.tempo(netuid) * 2)
 
     # Query the WeightCommits storage map for all three salts
     weight_commits = subtensor.query_module(
@@ -282,4 +290,6 @@ async def test_commit_weights_uses_next_nonce(local_chain, subtensor, alice_wall
     assert commit_block > 0, f"Invalid block number: {commit_block}"
 
     # Check for three commits in the WeightCommits storage map
-    assert len(weight_commits.value) == 3, "Expected 3 weight commits"
+    assert (
+        len(weight_commits.value) == AMOUNT_OF_COMMIT_WEIGHTS
+    ), "Expected exact list of weight commits"