Merge branch 'staging-pre-merge-new-async' into tests/zyzniewski/e2e_templates_teardown

Author: Roman

bittensor/core/extrinsics/move_stake.py

@@ -289,13 +289,6 @@ def move_stake_extrinsic(
     """
 
     amount.set_unit(netuid=origin_netuid)
-    # Verify ownership of origin hotkey
-    origin_owner = subtensor.get_hotkey_owner(origin_hotkey)
-    if origin_owner != wallet.coldkeypub.ss58_address:
-        logging.error(
-            f":cross_mark: [red]Failed[/red]: Origin hotkey: {origin_hotkey} does not belong to the coldkey owner: {wallet.coldkeypub.ss58_address}"
-        )
-        return False
 
     # Check sufficient stake
     stake_in_origin, stake_in_destination = _get_stake_in_origin_and_dest(

bittensor/core/metagraph.py

@@ -19,7 +19,7 @@
     MetagraphInfoPool,
     MetagraphInfoParams,
 )
-
+from bittensor.utils import determine_chain_endpoint_and_network
 from bittensor.utils.btlogging import logging
 from bittensor.utils.registration import torch, use_torch
 from bittensor.utils.weight_utils import (
@@ -42,6 +42,7 @@
 
 
 Tensor = Union["torch.nn.Parameter", NDArray]
+ROOT_TAO_STAKES_WEIGHT = 0.018
 
 
 METAGRAPH_STATE_DICT_NDARRAY_KEYS = [
@@ -142,26 +143,6 @@ def latest_block_path(dir_path: str) -> str:
         return latest_file_full_path
 
 
-def determine_chain_endpoint_and_network(network: str) -> tuple[str, str]:
-    """
-    Determine the chain endpoint and network name from the passed arg
-
-    Args:
-        network: The network name (e.g. 'finney', 'test') or
-            chain endpoint (e.g. wss://entrypoint-finney.opentensor.ai:443)
-
-    Returns:
-        (network name, chain endpoint)
-    """
-    pathless_network = network[:-1] if network.endswith("/") else network
-    if pathless_network in settings.NETWORK_MAP:
-        return pathless_network, settings.NETWORK_MAP[pathless_network]
-    elif pathless_network in settings.REVERSE_NETWORK_MAP:
-        return settings.REVERSE_NETWORK_MAP[pathless_network], pathless_network
-    else:
-        return "unknown", network
-
-
 class MetagraphMixin(ABC):
     """
     The metagraph class is a core component of the Bittensor network, representing the neural graph that forms the
@@ -258,6 +239,11 @@ class MetagraphMixin(ABC):
     _dtype_registry = {"int64": np.int64, "float32": np.float32, "bool": bool}
 
     # metagraph_info fields
+    name: str
+    symbol: str
+    network_registered_at: int
+    num_uids: int
+    max_uids: int
     identities: list[Optional["ChainIdentity"]]
     identity: Optional["SubnetIdentity"]
     pruning_score: list[float]
@@ -537,6 +523,15 @@ def __init__(
 
                 metagraph = Metagraph(netuid=123, network="finney", lite=True, sync=True)
         """
+        self.lite = lite
+        self.subtensor = subtensor
+        self.should_sync = sync
+        self.netuid = netuid
+        self.network, self.chain_endpoint = determine_chain_endpoint_and_network(
+            network
+        )
+        self.neurons = []
+        self.axons: list[AxonInfo] = []
 
     def __str__(self) -> str:
         """
@@ -937,6 +932,11 @@ def _apply_metagraph_info_mixin(self, metagraph_info: "MetagraphInfo"):
             metagraph_info (MetagraphInfo): An instance of the MetagraphInfo class containing the data to be applied to
                 the current object.
         """
+        self.name = metagraph_info.name
+        self.symbol = metagraph_info.symbol
+        self.network_registered_at = metagraph_info.network_registered_at
+        self.num_uids = metagraph_info.num_uids
+        self.max_uids = metagraph_info.max_uids
         self.identities = metagraph_info.identities
         self.identity = metagraph_info.identity
         self.pruning_score = metagraph_info.pruning_score
@@ -1043,10 +1043,6 @@ def __init__(
         """
         BaseClass.__init__(self)
         MetagraphMixin.__init__(self, netuid, network, lite, sync, subtensor)
-        self.netuid = netuid
-        self.network, self.chain_endpoint = determine_chain_endpoint_and_network(
-            network
-        )
         self._dtype_registry = {
             "int64": torch.int64,
             "float32": torch.float32,
@@ -1107,10 +1103,6 @@ def __init__(
         self.uids = torch.nn.Parameter(
             torch.tensor([], dtype=torch.int64), requires_grad=False
         )
-        self.axons: list[AxonInfo] = []
-        self.neurons = []
-        self.subtensor = subtensor
-        self.should_sync = sync
         self.alpha_stake = torch.nn.Parameter(
             torch.tensor([], dtype=torch.float32), requires_grad=False
         )
@@ -1239,9 +1231,6 @@ def __init__(
         self.tao_stake: Tensor = np.array([], dtype=np.int64)
         self.stake: Tensor = np.array([], dtype=np.int64)
         self.total_stake: Tensor = np.array([], dtype=np.int64)
-
-        self.axons: list[AxonInfo] = []
-        self.neurons = []
         self.subtensor = subtensor
         self.should_sync = sync
 
@@ -1343,7 +1332,7 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
     async def sync(
         self,
         block: Optional[int] = None,
-        lite: bool = True,
+        lite: Optional[bool] = None,
         subtensor: Optional["AsyncSubtensor"] = None,
     ):
         """
@@ -1354,8 +1343,9 @@ async def sync(
         Args:
             block (Optional[int]): A specific block number to synchronize with. If None, the metagraph syncs with the
                 latest block. This allows for historical analysis or specific state examination of the network.
-            lite (bool): If True, a lite version of the metagraph is used for quicker synchronization. This is
+            lite (Optional[bool]): If True, a lite version of the metagraph is used for quicker synchronization. This is
                 beneficial when full detail is not necessary, allowing for reduced computational and time overhead.
+                Defaults to `True`.
             subtensor (Optional[bittensor.core.subtensor.Subtensor]): An instance of the subtensor class from Bittensor,
                 providing an interface to the underlying blockchain data. If provided, this instance is used for data
                 retrieval during synchronization.
@@ -1390,6 +1380,9 @@ async def sync(
 
                 metagraph.sync(block=history_block, lite=False, subtensor=subtensor)
         """
+        if lite is None:
+            lite = self.lite
+
         subtensor = await self._initialize_subtensor(subtensor)
 
         if (
@@ -1608,8 +1601,14 @@ async def _get_all_stakes_from_chain(self):
                 )
                 return subnet_state
 
-            self.alpha_stake = subnet_state.alpha_stake
-            self.tao_stake = [b * 0.018 for b in subnet_state.tao_stake]
+            self.alpha_stake = self._create_tensor(
+                [b.tao for b in subnet_state.alpha_stake],
+                dtype=self._dtype_registry["float32"],
+            )
+            self.tao_stake = self._create_tensor(
+                [b.tao * ROOT_TAO_STAKES_WEIGHT for b in subnet_state.tao_stake],
+                dtype=self._dtype_registry["float32"],
+            )
             self.total_stake = self.stake = self._create_tensor(
                 [stake.tao for stake in subnet_state.total_stake],
                 dtype=self._dtype_registry["float32"],
@@ -1641,7 +1640,7 @@ def __init__(
     def sync(
         self,
         block: Optional[int] = None,
-        lite: bool = True,
+        lite: Optional[bool] = None,
         subtensor: Optional["Subtensor"] = None,
     ):
         """
@@ -1652,8 +1651,9 @@ def sync(
         Args:
             block (Optional[int]): A specific block number to synchronize with. If None, the metagraph syncs with the
                 latest block. This allows for historical analysis or specific state examination of the network.
-            lite (bool): If True, a lite version of the metagraph is used for quicker synchronization. This is
+            lite (Optional[bool]): If True, a lite version of the metagraph is used for quicker synchronization. This is
                 beneficial when full detail is not necessary, allowing for reduced computational and time overhead.
+                Defaults to `True`.
             subtensor (Optional[bittensor.core.subtensor.Subtensor]): An instance of the subtensor class from Bittensor,
                 providing an interface to the underlying blockchain data. If provided, this instance is used for data
                 retrieval during synchronization.
@@ -1688,6 +1688,8 @@ def sync(
 
                 metagraph.sync(block=history_block, lite=False, subtensor=subtensor)
         """
+        if lite is None:
+            lite = self.lite
 
         # Initialize subtensor
         subtensor = self._initialize_subtensor(subtensor=subtensor)
@@ -1908,7 +1910,7 @@ def _get_all_stakes_from_chain(self):
                 dtype=self._dtype_registry["float32"],
             )
             self.tao_stake = self._create_tensor(
-                [b.tao * 0.018 for b in subnet_state.tao_stake],
+                [b.tao * ROOT_TAO_STAKES_WEIGHT for b in subnet_state.tao_stake],
                 dtype=self._dtype_registry["float32"],
             )
             self.total_stake = self.stake = self._create_tensor(

bittensor/core/types.py

@@ -7,6 +7,7 @@
 from bittensor.core import settings
 from bittensor.core.config import Config
 from bittensor.core.chain_data import NeuronInfo, NeuronInfoLite
+from bittensor.utils import determine_chain_endpoint_and_network
 
 
 class SubtensorMixin(ABC):
@@ -95,8 +96,8 @@ def setup_config(network: Optional[str], config: "Config"):
                 if check:
                     network = config_network
 
-        evaluated_network, evaluated_endpoint = (
-            SubtensorMixin.determine_chain_endpoint_and_network(network)
+        evaluated_network, evaluated_endpoint = determine_chain_endpoint_and_network(
+            network
         )
 
         return networking.get_formatted_ws_endpoint_url(
@@ -166,41 +167,6 @@ def add_args(cls, parser: "argparse.ArgumentParser", prefix: Optional[str] = Non
             # re-parsing arguments.
             pass
 
-    @staticmethod
-    def determine_chain_endpoint_and_network(
-        network: str,
-    ) -> tuple[Optional[str], Optional[str]]:
-        """Determines the chain endpoint and network from the passed network or chain_endpoint.
-
-        Arguments:
-            network (str): The network flag. The choices are: ``finney`` (main network), ``archive`` (archive network
-                +300 blocks), ``local`` (local running network), ``test`` (test network).
-
-        Returns:
-            tuple[Optional[str], Optional[str]]: The network and chain endpoint flag. If passed, overrides the
-                ``network`` argument.
-        """
-
-        if network is None:
-            return None, None
-        if network in settings.NETWORKS:
-            return network, settings.NETWORK_MAP[network]
-
-        substrings_map = {
-            "entrypoint-finney.opentensor.ai": ("finney", settings.FINNEY_ENTRYPOINT),
-            "test.finney.opentensor.ai": ("test", settings.FINNEY_TEST_ENTRYPOINT),
-            "archive.chain.opentensor.ai": ("archive", settings.ARCHIVE_ENTRYPOINT),
-            "subvortex": ("subvortex", settings.SUBVORTEX_ENTRYPOINT),
-            "127.0.0.1": ("local", settings.LOCAL_ENTRYPOINT),
-            "localhost": ("local", settings.LOCAL_ENTRYPOINT),
-        }
-
-        for substring, result in substrings_map.items():
-            if substring in network:
-                return result
-
-        return "unknown", network
-
 
 class AxonServeCallParams:
     def __init__(

bittensor/utils/__init__.py

@@ -12,6 +12,7 @@
 from bittensor_wallet.errors import KeyFileError, PasswordError
 from scalecodec import ss58_decode, is_valid_ss58_address as _is_valid_ss58_address
 
+from bittensor.core import settings
 from bittensor.core.settings import SS58_FORMAT
 from bittensor.utils.btlogging import logging
 from .registration import torch, use_torch
@@ -410,3 +411,38 @@ def unlock_key(wallet: "Wallet", unlock_type="coldkey") -> "UnlockStatus":
     except KeyFileError:
         err_msg = f"{unlock_type.capitalize()} keyfile is corrupt, non-writable, or non-readable, or non-existent."
         return UnlockStatus(False, err_msg)
+
+
+def determine_chain_endpoint_and_network(
+    network: str,
+) -> tuple[Optional[str], Optional[str]]:
+    """Determines the chain endpoint and network from the passed network or chain_endpoint.
+
+    Arguments:
+        network (str): The network flag. The choices are: ``finney`` (main network), ``archive`` (archive network
+            +300 blocks), ``local`` (local running network), ``test`` (test network).
+
+    Returns:
+        tuple[Optional[str], Optional[str]]: The network and chain endpoint flag. If passed, overrides the
+            ``network`` argument.
+    """
+
+    if network is None:
+        return None, None
+    if network in settings.NETWORKS:
+        return network, settings.NETWORK_MAP[network]
+
+    substrings_map = {
+        "entrypoint-finney.opentensor.ai": ("finney", settings.FINNEY_ENTRYPOINT),
+        "test.finney.opentensor.ai": ("test", settings.FINNEY_TEST_ENTRYPOINT),
+        "archive.chain.opentensor.ai": ("archive", settings.ARCHIVE_ENTRYPOINT),
+        "subvortex": ("subvortex", settings.SUBVORTEX_ENTRYPOINT),
+        "127.0.0.1": ("local", network),
+        "localhost": ("local", network),
+    }
+
+    for substring, result in substrings_map.items():
+        if substring in network and validate_chain_endpoint(network):
+            return result
+
+    return "unknown", network

tests/unit_tests/test_subtensor.py

@@ -34,7 +34,12 @@
 from bittensor.core.settings import version_as_int
 from bittensor.core.subtensor import Subtensor
 from bittensor.core.types import AxonServeCallParams
-from bittensor.utils import Certificate, u16_normalized_float, u64_normalized_float
+from bittensor.utils import (
+    Certificate,
+    u16_normalized_float,
+    u64_normalized_float,
+    determine_chain_endpoint_and_network,
+)
 from bittensor.utils.balance import Balance
 
 U16_MAX = 65535
@@ -269,8 +274,10 @@ def mock_add_argument(*args, **kwargs):
             "archive",
             settings.ARCHIVE_ENTRYPOINT,
         ),
-        ("127.0.0.1", "local", settings.LOCAL_ENTRYPOINT),
-        ("localhost", "local", settings.LOCAL_ENTRYPOINT),
+        ("127.0.0.1", "local", "127.0.0.1"),
+        ("localhost", "local", "localhost"),
+        ("ws://127.0.0.1:9945", "local", "ws://127.0.0.1:9945"),
+        ("ws://localhost:9945", "local", "ws://localhost:9945"),
         # Edge cases
         (None, None, None),
         ("unknown", "unknown", "unknown"),
@@ -280,9 +287,7 @@ def test_determine_chain_endpoint_and_network(
     network, expected_network, expected_endpoint
 ):
     # Act
-    result_network, result_endpoint = Subtensor.determine_chain_endpoint_and_network(
-        network
-    )
+    result_network, result_endpoint = determine_chain_endpoint_and_network(network)
 
     # Assert
     assert result_network == expected_network