Merge branch 'staging' into fix/zyzniewski/burned_register_supports_root_subnet

Author: zyzniewski-reef

bittensor/core/metagraph.py

@@ -1,3 +1,4 @@
+import asyncio
 import copy
 import os
 import pickle
@@ -1397,13 +1398,13 @@ async def sync(
 
         # If not a 'lite' version, compute and set weights and bonds for each neuron
         if not lite:
-            await self._set_weights_and_bonds(subtensor=subtensor)
+            await self._set_weights_and_bonds(subtensor=subtensor, block=block)
 
         # Fills in the stake associated attributes of a class instance from a chain response.
         await self._get_all_stakes_from_chain(block=block)
 
         # apply MetagraphInfo data to instance
-        await self._apply_metagraph_info()
+        await self._apply_metagraph_info(block=block)
 
     async def _initialize_subtensor(
         self, subtensor: "AsyncSubtensor"
@@ -1476,9 +1477,7 @@ async def _assign_neurons(
             self.neurons = await subtensor.neurons(block=block, netuid=self.netuid)
         self.lite = lite
 
-    async def _set_weights_and_bonds(
-        self, subtensor: Optional["AsyncSubtensor"] = None
-    ):
+    async def _set_weights_and_bonds(self, subtensor: "AsyncSubtensor", block: int):
         """
         Computes and sets the weights and bonds for each neuron in the metagraph. This method is responsible for
         processing the raw weight and bond data obtained from the network and converting it into a structured format
@@ -1499,6 +1498,7 @@ async def _set_weights_and_bonds(
                 [neuron.weights for neuron in self.neurons],
                 "weights",
                 subtensor,
+                block=block,
             )
         else:
             self.weights = self._process_weights_or_bonds(
@@ -1509,7 +1509,7 @@ async def _set_weights_and_bonds(
             )
 
     async def _process_root_weights(
-        self, data: list, attribute: str, subtensor: "AsyncSubtensor"
+        self, data: list, attribute: str, subtensor: "AsyncSubtensor", block: int
     ) -> Union[NDArray, "torch.nn.Parameter"]:
         """
         Specifically processes the root weights data for the metagraph. This method is similar to :func:`_process_weights_or_bonds`
@@ -1530,8 +1530,10 @@ async def _process_root_weights(
                 self.root_weights = self._process_root_weights(raw_root_weights_data, "weights", subtensor)
         """
         data_array = []
-        n_subnets = await subtensor.get_total_subnets() or 0
-        subnets = await subtensor.get_subnets()
+        n_subnets_, subnets = await asyncio.gather(
+            subtensor.get_total_subnets(block=block), subtensor.get_subnets(block=block)
+        )
+        n_subnets = n_subnets_ or 0
         for item in data:
             if len(item) == 0:
                 if use_torch():
@@ -1612,9 +1614,11 @@ async def _get_all_stakes_from_chain(self, block: int):
         except (SubstrateRequestException, AttributeError) as e:
             logging.debug(e)
 
-    async def _apply_metagraph_info(self):
+    async def _apply_metagraph_info(self, block: int):
         """Retrieves metagraph information for a specific subnet and applies it using a mixin."""
-        metagraph_info = await self.subtensor.get_metagraph_info(self.netuid)
+        metagraph_info = await self.subtensor.get_metagraph_info(
+            self.netuid, block=block
+        )
         if metagraph_info:
             self._apply_metagraph_info_mixin(metagraph_info=metagraph_info)
 
@@ -1711,13 +1715,13 @@ def sync(
 
         # If not a 'lite' version, compute and set weights and bonds for each neuron
         if not lite:
-            self._set_weights_and_bonds(subtensor=subtensor)
+            self._set_weights_and_bonds(subtensor=subtensor, block=block)
 
         # Fills in the stake associated attributes of a class instance from a chain response.
         self._get_all_stakes_from_chain(block=block)
 
         # apply MetagraphInfo data to instance
-        self._apply_metagraph_info()
+        self._apply_metagraph_info(block=block)
 
     def _initialize_subtensor(self, subtensor: "Subtensor") -> "Subtensor":
         """
@@ -1787,7 +1791,7 @@ def _assign_neurons(self, block: int, lite: bool, subtensor: "Subtensor"):
             self.neurons = subtensor.neurons(block=block, netuid=self.netuid)
         self.lite = lite
 
-    def _set_weights_and_bonds(self, subtensor: Optional["Subtensor"] = None):
+    def _set_weights_and_bonds(self, block: int, subtensor: "Subtensor"):
         """
         Computes and sets the weights and bonds for each neuron in the metagraph. This method is responsible for
         processing the raw weight and bond data obtained from the network and converting it into a structured format
@@ -1804,9 +1808,7 @@ def _set_weights_and_bonds(self, subtensor: Optional["Subtensor"] = None):
         """
         if self.netuid == 0:
             self.weights = self._process_root_weights(
-                [neuron.weights for neuron in self.neurons],
-                "weights",
-                subtensor,
+                [neuron.weights for neuron in self.neurons], "weights", subtensor, block
             )
         else:
             self.weights = self._process_weights_or_bonds(
@@ -1817,7 +1819,7 @@ def _set_weights_and_bonds(self, subtensor: Optional["Subtensor"] = None):
             )
 
     def _process_root_weights(
-        self, data: list, attribute: str, subtensor: "Subtensor"
+        self, data: list, attribute: str, subtensor: "Subtensor", block: int
     ) -> Union[NDArray, "torch.nn.Parameter"]:
         """
         Specifically processes the root weights data for the metagraph. This method is similar to :func:`_process_weights_or_bonds`
@@ -1838,8 +1840,8 @@ def _process_root_weights(
                 self.root_weights = self._process_root_weights(raw_root_weights_data, "weights", subtensor)
         """
         data_array = []
-        n_subnets = subtensor.get_total_subnets() or 0
-        subnets = subtensor.get_subnets()
+        n_subnets = subtensor.get_total_subnets(block=block) or 0
+        subnets = subtensor.get_subnets(block=block)
         for item in data:
             if len(item) == 0:
                 if use_torch():
@@ -1920,9 +1922,9 @@ def _get_all_stakes_from_chain(self, block: int):
         except (SubstrateRequestException, AttributeError) as e:
             logging.debug(e)
 
-    def _apply_metagraph_info(self):
+    def _apply_metagraph_info(self, block: int):
         """Retrieves metagraph information for a specific subnet and applies it using a mixin."""
-        metagraph_info = self.subtensor.get_metagraph_info(self.netuid)
+        metagraph_info = self.subtensor.get_metagraph_info(self.netuid, block=block)
         if metagraph_info:
             self._apply_metagraph_info_mixin(metagraph_info=metagraph_info)
 

tests/e2e_tests/test_incentive.py

@@ -2,17 +2,13 @@
 
 import pytest
 
-from bittensor import Balance
-
 from tests.e2e_tests.utils.chain_interactions import (
     sudo_set_hyperparameter_values,
     wait_epoch,
-    sudo_set_admin_utils,
 )
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("local_chain", [False], indirect=True)
 async def test_incentive(local_chain, subtensor, templates, alice_wallet, bob_wallet):
     """
     Test the incentive mechanism and interaction of miners/validators
@@ -35,21 +31,6 @@ async def test_incentive(local_chain, subtensor, templates, alice_wallet, bob_wa
     # Verify subnet <netuid> created successfully
     assert subtensor.subnet_exists(netuid), "Subnet wasn't created successfully"
 
-    # Change tempo to 10
-    tempo_set = 10
-    assert (
-        sudo_set_admin_utils(
-            local_chain,
-            alice_wallet,
-            call_function="sudo_set_tempo",
-            call_params={"netuid": netuid, "tempo": tempo_set},
-            return_error_message=True,
-        )[0]
-        is True
-    )
-    tempo = subtensor.get_subnet_hyperparameters(netuid=netuid).tempo
-    assert tempo_set == tempo
-
     # Register Bob as a neuron on the subnet
     assert subtensor.burned_register(
         bob_wallet, netuid
@@ -60,27 +41,9 @@ async def test_incentive(local_chain, subtensor, templates, alice_wallet, bob_wa
         len(subtensor.neurons(netuid=netuid)) == 2
     ), "Alice & Bob not registered in the subnet"
 
-    # Add stake for Alice
-    assert subtensor.add_stake(
-        alice_wallet,
-        netuid=netuid,
-        amount=Balance.from_tao(1_000),
-        wait_for_inclusion=True,
-        wait_for_finalization=True,
-    ), "Failed to add stake for Alice"
-
     # Wait for the first epoch to pass
     await wait_epoch(subtensor, netuid)
 
-    # Add further stake so validator permit is activated
-    assert subtensor.add_stake(
-        alice_wallet,
-        netuid=netuid,
-        amount=Balance.from_tao(1_000),
-        wait_for_inclusion=True,
-        wait_for_finalization=True,
-    ), "Failed to add stake for Alice"
-
     # Get latest metagraph
     metagraph = subtensor.metagraph(netuid)
 
@@ -91,6 +54,9 @@ async def test_incentive(local_chain, subtensor, templates, alice_wallet, bob_wa
     assert alice_neuron.dividends == 0
     assert alice_neuron.stake.tao > 0
     assert alice_neuron.validator_trust == 0
+    assert alice_neuron.incentive == 0
+    assert alice_neuron.consensus == 0
+    assert alice_neuron.rank == 0
 
     bob_neuron = metagraph.neurons[1]
 
@@ -109,12 +75,13 @@ async def test_incentive(local_chain, subtensor, templates, alice_wallet, bob_wa
     )
 
     async with templates.miner(bob_wallet, netuid):
-        async with templates.validator(alice_wallet, netuid):
-            # Wait for the Validator to process and set_weights
-            await asyncio.sleep(5)
+        async with templates.validator(alice_wallet, netuid) as validator:
+            # wait for the Validator to process and set_weights
+            async with asyncio.timeout(15):
+                await validator.set_weights.wait()
 
             # Wait few epochs
-            await wait_epoch(subtensor, netuid, times=2)
+            await wait_epoch(subtensor, netuid, times=4)
 
             # Refresh metagraph
             metagraph = subtensor.metagraph(netuid)
@@ -125,12 +92,15 @@ async def test_incentive(local_chain, subtensor, templates, alice_wallet, bob_wa
     assert alice_neuron.validator_permit is True
     assert alice_neuron.dividends == 1.0
     assert alice_neuron.stake.tao > 0
-    assert alice_neuron.validator_trust == 1
+    assert alice_neuron.validator_trust > 0.99
+    assert alice_neuron.incentive < 0.5
+    assert alice_neuron.consensus < 0.5
+    assert alice_neuron.rank < 0.5
 
     bob_neuron = metagraph.neurons[1]
-    assert bob_neuron.incentive == 1
-    assert bob_neuron.consensus == 1
-    assert bob_neuron.rank == 1
+    assert bob_neuron.incentive > 0.5
+    assert bob_neuron.consensus > 0.5
+    assert bob_neuron.rank > 0.5
     assert bob_neuron.trust == 1
 
     print("✅ Passed test_incentive")