Merge pull request #2686 from opentensor/release/9.0.1

ibraheem-abe · web-flow · commit fad97f6c5eba · 2025-02-20T12:51:59.000-08:00
Release/9.0.1
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,25 @@
 # Changelog
 
+## What's Changed
+* Release/9.0.0 by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2671
+* fix e2e test by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2673
+* fix e2e test incentive by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2674
+* Add compatibility for read-only systems by @Arthurdw in https://github.com/opentensor/bittensor/pull/2676
+* test: use asynccontextmanager for FastAPI lifespan by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2597
+* test(2472): offline unittests by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2596
+* Removes redundant assignments in Metagraph by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2680
+* Alpha str formatting by @thewhaleking in https://github.com/opentensor/bittensor/pull/2672
+* Add method for fetching all Neuron Certificates on a Netuid by @thewhaleking in https://github.com/opentensor/bittensor/pull/2677
+* Updates tao_stake in MetagraphInfo by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2682
+* fix(2188): configure uvicorn event loop by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2679
+* Refactor AsyncSubtensor aenter logic by @thewhaleking in https://github.com/opentensor/bittensor/pull/2684
+* Backmerge master to staging 900 by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2685
+
+## New Contributors
+* @Arthurdw made their first contribution in https://github.com/opentensor/bittensor/pull/2676
+
+**Full Changelog**: https://github.com/opentensor/bittensor/compare/v9.0.0...v9.0.1
+
 ## 9.0.0 /2025-02-13
 
 ## What's Changed
diff --git a/VERSION b/VERSION
@@ -1 +1 @@
-9.0.0
+9.0.1
diff --git a/bittensor/core/async_subtensor.py b/bittensor/core/async_subtensor.py
@@ -173,8 +173,8 @@ async def __aenter__(self):
             f"[magenta]Connecting to Substrate:[/magenta] [blue]{self}[/blue][magenta]...[/magenta]"
         )
         try:
-            async with self.substrate:
-                return self
+            await self.substrate.initialize()
+            return self
         except TimeoutError:
             logging.error(
                 f"[red]Error[/red]: Timeout occurred connecting to substrate."
@@ -1479,6 +1479,41 @@ async def get_neuron_certificate(
             return None
         return None
 
+    async def get_all_neuron_certificates(
+        self,
+        netuid: int,
+        block: Optional[int] = None,
+        block_hash: Optional[str] = None,
+        reuse_block: bool = False,
+    ) -> dict[str, Certificate]:
+        """
+        Retrieves the TLS certificates for neurons within a specified subnet (netuid) of the Bittensor network.
+
+        Arguments:
+            netuid: The unique identifier of the subnet.
+            block: The blockchain block number for the query.
+            block_hash: The hash of the block to retrieve the parameter from. Do not specify if using block or
+                reuse_block.
+            reuse_block: Whether to use the last-used block. Do not set if using block_hash or block.
+
+        Returns:
+            {ss58: Certificate} for the key/Certificate pairs on the subnet
+
+        This function is used for certificate discovery for setting up mutual tls communication between neurons.
+        """
+        query_certificates = await self.query_map(
+            module="SubtensorModule",
+            name="NeuronCertificates",
+            params=[netuid],
+            block=block,
+            block_hash=block_hash,
+            reuse_block=reuse_block,
+        )
+        output = {}
+        async for key, item in query_certificates:
+            output[decode_account_id(key)] = Certificate(item.value)
+        return output
+
     async def get_neuron_for_pubkey_and_subnet(
         self,
         hotkey_ss58: str,
diff --git a/bittensor/core/axon.py b/bittensor/core/axon.py
@@ -386,7 +386,11 @@ def __init__(
         self.app = FastAPI()
         log_level = "trace" if logging.__trace_on__ else "critical"
         self.fast_config = uvicorn.Config(
-            self.app, host="0.0.0.0", port=self._config.axon.port, log_level=log_level
+            self.app,
+            host="0.0.0.0",
+            log_level=log_level,
+            loop="none",
+            port=self._config.axon.port,
         )
         self.fast_server = FastAPIThreadedServer(config=self.fast_config)
         self.router = APIRouter()
diff --git a/bittensor/core/chain_data/metagraph_info.py b/bittensor/core/chain_data/metagraph_info.py
@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 from typing import Optional, Union
 
+from bittensor.core import settings
 from bittensor.core.chain_data.axon_info import AxonInfo
 from bittensor.core.chain_data.chain_identity import ChainIdentity
 from bittensor.core.chain_data.info_base import InfoBase
@@ -234,7 +235,10 @@ def _from_dict(cls, decoded: dict) -> "MetagraphInfo":
             rank=[u16tf(rk) for rk in decoded.get("rank", [])],
             block_at_registration=decoded["block_at_registration"],
             alpha_stake=[_tbwu(ast, _netuid) for ast in decoded["alpha_stake"]],
-            tao_stake=[_tbwu(ts) for ts in decoded["tao_stake"]],
+            tao_stake=[
+                _tbwu(ts) * settings.ROOT_TAO_STAKE_WEIGHT
+                for ts in decoded["tao_stake"]
+            ],
             total_stake=[_tbwu(ts, _netuid) for ts in decoded["total_stake"]],
             # Dividend break down
             tao_dividends_per_hotkey=[
diff --git a/bittensor/core/metagraph.py b/bittensor/core/metagraph.py
@@ -42,7 +42,6 @@
 
 
 Tensor = Union["torch.nn.Parameter", NDArray]
-ROOT_TAO_STAKES_WEIGHT = 0.18
 
 
 METAGRAPH_STATE_DICT_NDARRAY_KEYS = [
@@ -773,14 +772,6 @@ def _set_metagraph_attributes(self, block: int):
             [neuron.validator_trust for neuron in self.neurons],
             dtype=self._dtype_registry["float32"],
         )
-        self.total_stake = self._create_tensor(
-            [neuron.total_stake.tao for neuron in self.neurons],
-            dtype=self._dtype_registry["float32"],
-        )
-        self.stake = self._create_tensor(
-            [neuron.stake.tao for neuron in self.neurons],
-            dtype=self._dtype_registry["float32"],
-        )
         self.axons = [n.axon_info for n in self.neurons]
 
     def save(self, root_dir: Optional[list[str]] = None) -> "MetagraphMixin":
@@ -1606,7 +1597,10 @@ async def _get_all_stakes_from_chain(self):
                 dtype=self._dtype_registry["float32"],
             )
             self.tao_stake = self._create_tensor(
-                [b.tao * ROOT_TAO_STAKES_WEIGHT for b in subnet_state.tao_stake],
+                [
+                    b.tao * settings.ROOT_TAO_STAKE_WEIGHT
+                    for b in subnet_state.tao_stake
+                ],
                 dtype=self._dtype_registry["float32"],
             )
             self.total_stake = self.stake = self._create_tensor(
@@ -1634,7 +1628,7 @@ def __init__(
         subtensor: Optional["Subtensor"] = None,
     ):
         super().__init__(netuid, network, lite, sync, subtensor)
-        if sync:
+        if self.should_sync:
             self.sync()
 
     def sync(
@@ -1910,7 +1904,10 @@ def _get_all_stakes_from_chain(self):
                 dtype=self._dtype_registry["float32"],
             )
             self.tao_stake = self._create_tensor(
-                [b.tao * ROOT_TAO_STAKES_WEIGHT for b in subnet_state.tao_stake],
+                [
+                    b.tao * settings.ROOT_TAO_STAKE_WEIGHT
+                    for b in subnet_state.tao_stake
+                ],
                 dtype=self._dtype_registry["float32"],
             )
             self.total_stake = self.stake = self._create_tensor(
diff --git a/bittensor/core/settings.py b/bittensor/core/settings.py
@@ -1,21 +1,25 @@
-__version__ = "9.0.0"
+__version__ = "9.0.1"
 
 import os
 import re
 from pathlib import Path
 
 from munch import munchify
 
+ROOT_TAO_STAKE_WEIGHT = 0.18
+
+READ_ONLY = os.getenv("READ_ONLY") == "1"
 
 HOME_DIR = Path.home()
 USER_BITTENSOR_DIR = HOME_DIR / ".bittensor"
 WALLETS_DIR = USER_BITTENSOR_DIR / "wallets"
 MINERS_DIR = USER_BITTENSOR_DIR / "miners"
 
 
-# Create dirs if they don't exist
-WALLETS_DIR.mkdir(parents=True, exist_ok=True)
-MINERS_DIR.mkdir(parents=True, exist_ok=True)
+if not READ_ONLY:
+    # Create dirs if they don't exist
+    WALLETS_DIR.mkdir(parents=True, exist_ok=True)
+    MINERS_DIR.mkdir(parents=True, exist_ok=True)
 
 # Bittensor networks name
 NETWORKS = ["finney", "test", "archive", "local", "subvortex", "rao", "latent-lite"]
diff --git a/bittensor/core/subtensor.py b/bittensor/core/subtensor.py
@@ -1123,6 +1123,32 @@ def get_neuron_certificate(
             return None
         return None
 
+    def get_all_neuron_certificates(
+        self, netuid: int, block: Optional[int] = None
+    ) -> dict[str, Certificate]:
+        """
+        Retrieves the TLS certificates for neurons within a specified subnet (netuid) of the Bittensor network.
+
+        Arguments:
+            netuid: The unique identifier of the subnet.
+            block: The blockchain block number for the query.
+
+        Returns:
+            {ss58: Certificate} for the key/Certificate pairs on the subnet
+
+        This function is used for certificate discovery for setting up mutual tls communication between neurons.
+        """
+        query_certificates = self.query_map(
+            module="SubtensorModule",
+            name="NeuronCertificates",
+            params=[netuid],
+            block=block,
+        )
+        output = {}
+        for key, item in query_certificates:
+            output[decode_account_id(key)] = Certificate(item.value)
+        return output
+
     def get_neuron_for_pubkey_and_subnet(
         self, hotkey_ss58: str, netuid: int, block: Optional[int] = None
     ) -> Optional["NeuronInfo"]:
diff --git a/bittensor/utils/balance.py b/bittensor/utils/balance.py
@@ -53,8 +53,13 @@ def __float__(self):
         return self.tao
 
     def __str__(self):
-        """Returns the Balance object as a string in the format "symbolvalue", where the value is in tao."""
-        return f"{self.unit}{float(self.tao):,.9f}"
+        """
+        Returns the Balance object as a string in the format "symbolvalue", where the value is in tao.
+        """
+        if self.unit == units[0]:
+            return f"{self.unit}{float(self.tao):,.9f}"
+        else:
+            return f"\u200e{float(self.tao):,.9f}{self.unit}\u200e"
 
     def __rich__(self):
         int_tao, fract_tao = format(float(self.tao), "f").split(".")
diff --git a/bittensor/utils/btlogging/loggingmachine.py b/bittensor/utils/btlogging/loggingmachine.py
@@ -16,6 +16,7 @@
 
 from statemachine import State, StateMachine
 
+from bittensor.core.settings import READ_ONLY
 from bittensor.core.config import Config
 from bittensor.utils.btlogging.console import BittensorConsole
 from .defines import (
@@ -584,9 +585,12 @@ def add_args(cls, parser: argparse.ArgumentParser, prefix: str = None):
             default_logging_info = os.getenv("BT_LOGGING_INFO") or False
             default_logging_trace = os.getenv("BT_LOGGING_TRACE") or False
             default_logging_record_log = os.getenv("BT_LOGGING_RECORD_LOG") or False
-            default_logging_logging_dir = os.getenv(
-                "BT_LOGGING_LOGGING_DIR"
-            ) or os.path.join("~", ".bittensor", "miners")
+            default_logging_logging_dir = (
+                None
+                if READ_ONLY
+                else os.getenv("BT_LOGGING_LOGGING_DIR")
+                or os.path.join("~", ".bittensor", "miners")
+            )
             parser.add_argument(
                 "--" + prefix_str + "logging.debug",
                 action="store_true",
diff --git a/tests/e2e_tests/test_commit_weights.py b/tests/e2e_tests/test_commit_weights.py
@@ -167,6 +167,9 @@ async def test_commit_weights_uses_next_nonce(local_chain, subtensor, alice_wall
     Raises:
         AssertionError: If any of the checks or verifications fail
     """
+    # Wait for 2 tempos to pass as CR3 only reveals weights after 2 tempos
+    subtensor.wait_for_block(20)
+
     netuid = 2
     print("Testing test_commit_and_reveal_weights")
     # Register root as Alice
diff --git a/tests/e2e_tests/test_incentive.py b/tests/e2e_tests/test_incentive.py
@@ -23,6 +23,9 @@ async def test_incentive(local_chain, subtensor, templates, alice_wallet, bob_wa
         AssertionError: If any of the checks or verifications fail
     """
 
+    # Wait for 2 tempos to spin up chain properly
+    subtensor.wait_for_block(20)
+
     print("Testing test_incentive")
     netuid = 2
 
diff --git a/tests/e2e_tests/test_neuron_certificate.py b/tests/e2e_tests/test_neuron_certificate.py
@@ -47,5 +47,8 @@ async def test_neuron_certificate(subtensor, alice_wallet):
         )
         == encoded_certificate
     )
+    all_certs_query = subtensor.get_all_neuron_certificates(netuid=netuid)
+    assert alice_wallet.hotkey.ss58_address in all_certs_query.keys()
+    assert all_certs_query[alice_wallet.hotkey.ss58_address] == encoded_certificate
 
     logging.info("✅ Passed test_neuron_certificate")
diff --git a/tests/unit_tests/conftest.py b/tests/unit_tests/conftest.py
@@ -1,5 +1,8 @@
 import pytest
 from aioresponses import aioresponses
+from async_substrate_interface.sync_substrate import SubstrateInterface
+
+import bittensor.core.subtensor
 
 
 @pytest.fixture
@@ -11,3 +14,30 @@ def force_legacy_torch_compatible_api(monkeypatch):
 def mock_aio_response():
     with aioresponses() as m:
         yield m
+
+
+@pytest.fixture
+def mock_substrate_interface(mocker):
+    mocked = mocker.MagicMock(
+        autospec=SubstrateInterface,
+    )
+
+    mocker.patch("bittensor.core.subtensor.SubstrateInterface", return_value=mocked)
+
+    return mocked
+
+
+@pytest.fixture
+def subtensor(mock_substrate_interface):
+    return bittensor.core.subtensor.Subtensor()
+
+
+@pytest.fixture
+def mock_get_external_ip(mocker):
+    mocked = mocker.Mock(
+        return_value="192.168.1.1",
+    )
+
+    mocker.patch("bittensor.utils.networking.get_external_ip", mocked)
+
+    return mocked
diff --git a/tests/unit_tests/extrinsics/asyncex/test_commit_reveal.py b/tests/unit_tests/extrinsics/asyncex/test_commit_reveal.py
@@ -11,7 +11,7 @@
 @pytest.fixture
 def subtensor(mocker):
     fake_substrate = mocker.AsyncMock()
-    fake_substrate.websocket.sock.getsockopt.return_value = 0
+    fake_substrate.websocket.socket.getsockopt.return_value = 0
     mocker.patch.object(
         subtensor_module, "AsyncSubstrateInterface", return_value=fake_substrate
     )
diff --git a/tests/unit_tests/extrinsics/test_commit_reveal.py b/tests/unit_tests/extrinsics/test_commit_reveal.py
@@ -6,17 +6,6 @@
 from bittensor.core import subtensor as subtensor_module
 from bittensor.core.chain_data import SubnetHyperparameters
 from bittensor.core.extrinsics import commit_reveal
-from bittensor.core.subtensor import Subtensor
-
-
-@pytest.fixture
-def subtensor(mocker):
-    fake_substrate = mocker.MagicMock()
-    fake_substrate.websocket.sock.getsockopt.return_value = 0
-    mocker.patch.object(
-        subtensor_module, "SubstrateInterface", return_value=fake_substrate
-    )
-    yield Subtensor()
 
 
 @pytest.fixture
diff --git a/tests/unit_tests/extrinsics/test_commit_weights.py b/tests/unit_tests/extrinsics/test_commit_weights.py
@@ -1,23 +1,10 @@
-import pytest
 from bittensor_wallet import Wallet
 
-from bittensor.core import subtensor as subtensor_module
-from bittensor.core.settings import version_as_int
-from bittensor.core.subtensor import Subtensor
 from bittensor.core.extrinsics.commit_weights import (
     _do_commit_weights,
     _do_reveal_weights,
 )
-
-
-@pytest.fixture
-def subtensor(mocker):
-    fake_substrate = mocker.MagicMock()
-    fake_substrate.websocket.sock.getsockopt.return_value = 0
-    mocker.patch.object(
-        subtensor_module, "SubstrateInterface", return_value=fake_substrate
-    )
-    return Subtensor()
+from bittensor.core.settings import version_as_int
 
 
 def test_do_commit_weights(subtensor, mocker):
diff --git a/tests/unit_tests/extrinsics/test_transfer.py b/tests/unit_tests/extrinsics/test_transfer.py
diff --git a/tests/unit_tests/test_async_subtensor.py b/tests/unit_tests/test_async_subtensor.py
diff --git a/tests/unit_tests/test_axon.py b/tests/unit_tests/test_axon.py
diff --git a/tests/unit_tests/test_dendrite.py b/tests/unit_tests/test_dendrite.py
diff --git a/tests/unit_tests/test_subtensor.py b/tests/unit_tests/test_subtensor.py
diff --git a/tests/unit_tests/utils/test_networking.py b/tests/unit_tests/utils/test_networking.py
