Merge pull request #2624 from opentensor/feat/roman/add-metagraph-info-subnet_volume

Add `subnet_volume` field to `MetagraphInfo` and `DynamicInfo`

Author: basfroman

bittensor/core/async_subtensor.py

@@ -1305,7 +1305,7 @@ async def get_metagraph_info(
         block: Optional[int] = None,
         block_hash: Optional[str] = None,
         reuse_block: bool = False,
-    ) -> MetagraphInfo:
+    ) -> Optional[MetagraphInfo]:
         """
         Retrieves the MetagraphInfo dataclass from the node for a single subnet (netuid)
 
@@ -1330,7 +1330,10 @@ async def get_metagraph_info(
             params=[netuid],
             block_hash=block_hash,
         )
-        return MetagraphInfo.from_dict(query.decode())
+        if query.value is None:
+            logging.error(f"Subnet {netuid} does not exist.")
+            return None
+        return MetagraphInfo.from_dict(query.value)
 
     async def get_all_metagraphs_info(
         self,

bittensor/core/chain_data/dynamic_info.py

@@ -36,6 +36,7 @@ class DynamicInfo(InfoBase):
     pending_alpha_emission: Balance
     pending_root_emission: Balance
     network_registered_at: int
+    subnet_volume: Balance
     subnet_identity: Optional[SubnetIdentity]
 
     @classmethod
@@ -71,6 +72,7 @@ def _from_dict(cls, decoded: dict) -> "DynamicInfo":
             decoded["pending_root_emission"]
         ).set_unit(0)
 
+        subnet_volume = Balance.from_rao(decoded["subnet_volume"]).set_unit(netuid)
         price = (
             Balance.from_tao(1.0)
             if netuid == 0
@@ -113,6 +115,7 @@ def _from_dict(cls, decoded: dict) -> "DynamicInfo":
             pending_root_emission=pending_root_emission,
             network_registered_at=int(decoded["network_registered_at"]),
             subnet_identity=subnet_identity,
+            subnet_volume=subnet_volume,
         )
 
     def tao_to_alpha(self, tao: Union[Balance, float, int]) -> Balance:

bittensor/core/chain_data/metagraph_info.py

@@ -62,6 +62,7 @@ class MetagraphInfo(InfoBase):
     tao_in_emission: Balance  # amount of tao injected per block
     pending_alpha_emission: Balance  # pending alpha to be distributed
     pending_root_emission: Balance  # pending tao for root divs to be distributed
+    subnet_volume: Balance  # volume of the subnet in TAO
 
     # Hparams for epoch
     rho: int  # subnet rho param
@@ -161,6 +162,7 @@ def _from_dict(cls, decoded: dict) -> "MetagraphInfo":
             decoded["pending_alpha_emission"], _netuid
         )
         decoded["pending_root_emission"] = _tbwu(decoded["pending_root_emission"])
+        decoded["subnet_volume"] = _tbwu(decoded["subnet_volume"], _netuid)
 
         # Hparams for epoch
         decoded["kappa"] = u16tf(decoded["kappa"])
@@ -231,6 +233,7 @@ class MetagraphInfoPool:
     alpha_out: Balance
     alpha_in: Balance
     tao_in: Balance
+    subnet_volume: Balance
 
 
 @dataclass

bittensor/core/metagraph.py

@@ -931,7 +931,7 @@ def __copy__(self):
                 setattr(new_instance, key, value)
         return new_instance
 
-    def _apply_metagraph_ingo_mixin(self, metagraph_info: "MetagraphInfo"):
+    def _apply_metagraph_info_mixin(self, metagraph_info: "MetagraphInfo"):
         """
         Updates the attributes of the current object with data from a provided MetagraphInfo instance.
 
@@ -985,6 +985,7 @@ def _apply_metagraph_ingo_mixin(self, metagraph_info: "MetagraphInfo"):
             alpha_out=metagraph_info.alpha_out,
             alpha_in=metagraph_info.alpha_in,
             tao_in=metagraph_info.tao_in,
+            subnet_volume=metagraph_info.subnet_volume,
         )
         self.emissions = MetagraphInfoEmissions(
             alpha_out_emission=metagraph_info.alpha_out_emission,
@@ -1612,7 +1613,8 @@ async def _get_all_stakes_from_chain(self):
     async def _apply_metagraph_info(self):
         """Retrieves metagraph information for a specific subnet and applies it using a mixin."""
         metagraph_info = await self.subtensor.get_metagraph_info(self.netuid)
-        self._apply_metagraph_ingo_mixin(metagraph_info=metagraph_info)
+        if metagraph_info:
+            self._apply_metagraph_info_mixin(metagraph_info=metagraph_info)
 
 
 class Metagraph(NumpyOrTorch):
@@ -1900,7 +1902,8 @@ def _get_all_stakes_from_chain(self):
     def _apply_metagraph_info(self):
         """Retrieves metagraph information for a specific subnet and applies it using a mixin."""
         metagraph_info = self.subtensor.get_metagraph_info(self.netuid)
-        self._apply_metagraph_ingo_mixin(metagraph_info=metagraph_info)
+        if metagraph_info:
+            self._apply_metagraph_info_mixin(metagraph_info=metagraph_info)
 
 
 async def async_metagraph(

bittensor/core/subtensor.py

@@ -1002,18 +1002,42 @@ def get_minimum_required_stake(self) -> Balance:
     def get_metagraph_info(
         self, netuid: int, block: Optional[int] = None
     ) -> Optional[MetagraphInfo]:
+        """
+        Retrieves the MetagraphInfo dataclass from the node for a single subnet (netuid)
+
+        Arguments:
+            netuid: The NetUID of the subnet.
+            block: the block number at which to retrieve the hyperparameter. Do not specify if using block_hash or
+                reuse_block
+
+        Returns:
+            MetagraphInfo dataclass
+        """
         block_hash = self.determine_block_hash(block)
         query = self.substrate.runtime_call(
             "SubnetInfoRuntimeApi",
             "get_metagraph",
             params=[netuid],
             block_hash=block_hash,
         )
+        if query.value is None:
+            logging.error(f"Subnet {netuid} does not exist.")
+            return None
         return MetagraphInfo.from_dict(query.value)
 
     def get_all_metagraphs_info(
         self, block: Optional[int] = None
     ) -> list[MetagraphInfo]:
+        """
+        Retrieves a list of MetagraphInfo objects for all subnets
+
+        Arguments:
+            block: the block number at which to retrieve the hyperparameter. Do not specify if using block_hash or
+                reuse_block
+
+        Returns:
+            MetagraphInfo dataclass
+        """
         block_hash = self.determine_block_hash(block)
         query = self.substrate.runtime_call(
             "SubnetInfoRuntimeApi",

requirements/prod.txt

@@ -23,4 +23,4 @@ uvicorn
 websockets>=14.1
 bittensor-commit-reveal>=0.2.0
 bittensor-wallet>=3.0.0
-async-substrate-interface==1.0.0rc9
+async-substrate-interface==1.0.0rc10

tests/e2e_tests/conftest.py

@@ -7,7 +7,7 @@
 import threading
 
 import pytest
-from substrateinterface import SubstrateInterface
+from async_substrate_interface import SubstrateInterface
 
 from bittensor.utils.btlogging import logging
 from tests.e2e_tests.utils.e2e_test_utils import (

tests/helpers/integration_websocket_data.py

@@ -6457,7 +6457,7 @@
             },
             '["SubnetInfoRuntimeApi_get_metagraph", "0100", null]': {
                 "jsonrpc": "2.0",
-                "result": "0x01000cd1018501d5010839039102000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000dec302009101fac20200e400000000000000000028feff010000feff0300009101214e010100010102286bee025a620201000140025a620213ffffffffffffff3f02286bee0700e87648170091010404c80004009a990300cecc020082ee36000000000000000000000000000000000000000000",
+                "result": "0x00",
             },
         },
         "state_getRuntimeVersion": {

tests/unit_tests/test_async_subtensor.py

@@ -1583,9 +1583,6 @@ async def test_does_hotkey_exist_true(subtensor, mocker):
     mocked_query = mocker.AsyncMock(value=fake_query_result)
     subtensor.substrate.query = mocked_query
 
-    mocked_decode_account_id = mocker.Mock(return_value="another_account_id")
-    mocker.patch.object(async_subtensor, "decode_account_id", mocked_decode_account_id)
-
     # Call
     result = await subtensor.does_hotkey_exist(
         hotkey_ss58=fake_hotkey_ss58, block_hash=fake_block_hash
@@ -1599,25 +1596,19 @@ async def test_does_hotkey_exist_true(subtensor, mocker):
         block_hash=fake_block_hash,
         reuse_block_hash=False,
     )
-    mocked_decode_account_id.assert_called_once()
     assert result is True
 
 
 @pytest.mark.asyncio
 async def test_does_hotkey_exist_false_for_specific_account(subtensor, mocker):
     """Tests does_hotkey_exist method when the hotkey exists but matches the specific account ID to ignore."""
     # Preps
-    fake_hotkey_ss58 = "ignored_hotkey"
-    fake_query_result = ["ignored_account_id"]
+    fake_hotkey_ss58 = "fake_hotkey"
+    fake_query_result = "5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM"
 
-    mocked_query = mocker.AsyncMock(value=fake_query_result)
-    subtensor.substrate.query = mocked_query
-
-    # Mock the decode_account_id function to return the specific account ID that should be ignored
-    mocked_decode_account_id = mocker.Mock(
-        return_value="5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM"
+    mocked_query = mocker.patch.object(
+        subtensor.substrate, "query", return_value=fake_query_result
     )
-    mocker.patch.object(async_subtensor, "decode_account_id", mocked_decode_account_id)
 
     # Call
     result = await subtensor.does_hotkey_exist(hotkey_ss58=fake_hotkey_ss58)
@@ -1630,7 +1621,6 @@ async def test_does_hotkey_exist_false_for_specific_account(subtensor, mocker):
         block_hash=None,
         reuse_block_hash=False,
     )
-    mocked_decode_account_id.assert_called_once()
     assert result is False