Merge branch 'staging-pre-merge-new-async' into merge/roman/async-pre-merge-new-async-to-staging

# Conflicts:
#	tests/e2e_tests/test_incentive.py

Author: Roman

bittensor/core/extrinsics/asyncex/move_stake.py

@@ -290,14 +290,6 @@ async def move_stake_extrinsic(
         bool: True if the move was successful, False otherwise.
     """
     amount.set_unit(netuid=origin_netuid)
-    # Verify ownership of origin hotkey
-    origin_owner = await 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: "
-            f"{wallet.coldkeypub.ss58_address}"
-        )
-        return False
 
     # Check sufficient stake
     stake_in_origin, stake_in_destination = await _get_stake_in_origin_and_dest(

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 (
@@ -143,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

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/e2e_tests/conftest.py

@@ -49,13 +49,6 @@ def local_chain(request):
 
     # Pattern match indicates node is compiled and ready
     pattern = re.compile(r"Imported #1")
-
-    # install neuron templates
-    logging.info("downloading and installing neuron templates from github")
-    # commit with subnet-template-repo changes for rust wallet
-    templates_dir = clone_or_update_templates()
-    install_templates(templates_dir)
-
     timestamp = int(time.time())
 
     def wait_for_node_start(process, pattern):
@@ -87,7 +80,7 @@ def read_output():
     wait_for_node_start(process, pattern)
 
     # Run the test, passing in substrate interface
-    yield SubstrateInterface(url="ws://127.0.0.1:9945")
+    yield SubstrateInterface(url="ws://127.0.0.1:9944")
 
     # Terminate the process group (includes all child processes)
     os.killpg(os.getpgid(process.pid), signal.SIGTERM)
@@ -102,14 +95,25 @@ def read_output():
     # Ensure the process has terminated
     process.wait()
 
-    # uninstall templates
+
+@pytest.fixture
+def templates():
+    logging.info("downloading and installing neuron templates from github")
+
+    templates_dir = clone_or_update_templates()
+
+    install_templates(templates_dir)
+
+    yield templates_dir
+
     logging.info("uninstalling neuron templates")
+
     uninstall_templates(template_path)
 
 
 @pytest.fixture
 def subtensor(local_chain):
-    return Subtensor(network="ws://localhost:9945")
+    return Subtensor(network="ws://localhost:9944")
 
 
 @pytest.fixture

tests/e2e_tests/test_axon.py

@@ -4,14 +4,10 @@
 import pytest
 
 from bittensor.utils import networking
-from tests.e2e_tests.utils.e2e_test_utils import (
-    template_path,
-    templates_repo,
-)
 
 
 @pytest.mark.asyncio
-async def test_axon(subtensor, alice_wallet):
+async def test_axon(subtensor, templates, alice_wallet):
     """
     Test the Axon mechanism and successful registration on the network.
 
@@ -53,13 +49,13 @@ async def test_axon(subtensor, alice_wallet):
     cmd = " ".join(
         [
             f"{sys.executable}",
-            f'"{template_path}{templates_repo}/miner.py"',
+            f'"{templates}/miner.py"',
             "--netuid",
             str(netuid),
             "--subtensor.network",
             "local",
             "--subtensor.chain_endpoint",
-            "ws://localhost:9945",
+            "ws://localhost:9944",
             "--wallet.path",
             alice_wallet.path,
             "--wallet.name",

tests/e2e_tests/test_dendrite.py

@@ -10,14 +10,10 @@
     sudo_set_hyperparameter_values,
     wait_epoch,
 )
-from tests.e2e_tests.utils.e2e_test_utils import (
-    template_path,
-    templates_repo,
-)
 
 
 @pytest.mark.asyncio
-async def test_dendrite(local_chain, subtensor, alice_wallet, bob_wallet):
+async def test_dendrite(local_chain, subtensor, templates, alice_wallet, bob_wallet):
     """
     Test the Dendrite mechanism
 
@@ -112,13 +108,13 @@ async def test_dendrite(local_chain, subtensor, alice_wallet, bob_wallet):
     cmd = " ".join(
         [
             f"{sys.executable}",
-            f'"{template_path}{templates_repo}/validator.py"',
+            f'"{templates}/validator.py"',
             "--netuid",
             str(netuid),
             "--subtensor.network",
             "local",
             "--subtensor.chain_endpoint",
-            "ws://localhost:9945",
+            "ws://localhost:9944",
             "--wallet.path",
             bob_wallet.path,
             "--wallet.name",

tests/e2e_tests/test_incentive.py

@@ -8,14 +8,10 @@
     sudo_set_hyperparameter_values,
     wait_epoch,
 )
-from tests.e2e_tests.utils.e2e_test_utils import (
-    template_path,
-    templates_repo,
-)
 
 
 @pytest.mark.asyncio
-async def test_incentive(local_chain, subtensor, alice_wallet, bob_wallet):
+async def test_incentive(local_chain, subtensor, templates, alice_wallet, bob_wallet):
     """
     Test the incentive mechanism and interaction of miners/validators
 
@@ -80,7 +76,7 @@ async def test_incentive(local_chain, subtensor, alice_wallet, bob_wallet):
     cmd = " ".join(
         [
             f"{sys.executable}",
-            f'"{template_path}{templates_repo}/miner.py"',
+            f'"{templates}/miner.py"',
             "--netuid",
             str(netuid),
             "--subtensor.network",
@@ -109,13 +105,13 @@ async def test_incentive(local_chain, subtensor, alice_wallet, bob_wallet):
     cmd = " ".join(
         [
             f"{sys.executable}",
-            f'"{template_path}{templates_repo}/validator.py"',
+            f'"{templates}/validator.py"',
             "--netuid",
             str(netuid),
             "--subtensor.network",
             "local",
             "--subtensor.chain_endpoint",
-            "ws://localhost:9945",
+            "ws://localhost:9944",
             "--wallet.path",
             alice_wallet.path,
             "--wallet.name",

tests/e2e_tests/test_root_set_weights.py

@@ -6,10 +6,6 @@
     wait_epoch,
     sudo_set_hyperparameter_values,
 )
-from tests.e2e_tests.utils.e2e_test_utils import (
-    template_path,
-    templates_repo,
-)
 
 FAST_BLOCKS_SPEEDUP_FACTOR = 5
 
@@ -34,7 +30,13 @@
 
 
 @pytest.mark.asyncio
-async def test_root_reg_hyperparams(local_chain, subtensor, alice_wallet, bob_wallet):
+async def test_root_reg_hyperparams(
+    local_chain,
+    subtensor,
+    templates,
+    alice_wallet,
+    bob_wallet,
+):
     """
     Test root weights and hyperparameters in the Subtensor network.
 
@@ -86,13 +88,13 @@ async def test_root_reg_hyperparams(local_chain, subtensor, alice_wallet, bob_wa
     cmd = " ".join(
         [
             f"{sys.executable}",
-            f'"{template_path}{templates_repo}/validator.py"',
+            f'"{templates}/validator.py"',
             "--netuid",
             str(netuid),
             "--subtensor.network",
             "local",
             "--subtensor.chain_endpoint",
-            "ws://localhost:9945",
+            "ws://localhost:9944",
             "--wallet.path",
             alice_wallet.path,
             "--wallet.name",