Adds a command to compare latencies of given connections to help the user pick the fastest for their region.

Author: thewhaleking

bittensor_cli/cli.py

@@ -42,7 +42,10 @@
 from bittensor_cli.src.bittensor import utils
 from bittensor_cli.src.bittensor.balances import Balance
 from bittensor_cli.src.bittensor.chain_data import SubnetHyperparameters
-from bittensor_cli.src.bittensor.subtensor_interface import SubtensorInterface
+from bittensor_cli.src.bittensor.subtensor_interface import (
+    SubtensorInterface,
+    best_connection,
+)
 from bittensor_cli.src.bittensor.utils import (
     console,
     err_console,
@@ -1048,6 +1051,9 @@ def __init__(self):
             "remove", rich_help_panel=HELP_PANELS["LIQUIDITY"]["LIQUIDITY_MGMT"]
         )(self.liquidity_remove)
 
+        # utils app
+        self.utils_app.command("latency")(self.best_connection)
+
     def generate_command_tree(self) -> Tree:
         """
         Generates a rich.Tree of the commands, subcommands, and groups of this app
@@ -6326,6 +6332,57 @@ def convert(
                 f"{Balance.from_tao(tao).rao}{Balance.rao_unit}",
             )
 
+    def best_connection(
+        self,
+        additional_networks: Optional[list[str]] = typer.Option(
+            None,
+            "--network",
+            help="Network(s) to test for the best connection",
+        ),
+    ):
+        f"""
+        This command will give you the latency of all finney-like network in additional to any additional networks you specify via the {arg__("--network")} flag
+        
+        The results are two-fold. One column is the overall time to initialise a connection, send a request, and wait for the result. The second column measures single ping-pong speed once connected.
+        
+        EXAMPLE
+        
+        [green]$[/green] btcli utils latency --network ws://189.234.12.45 --network wss://mysubtensor.duckdns.org
+
+        """
+        additional_networks = additional_networks or []
+        if any(not x.startswith("ws") for x in additional_networks):
+            err_console.print(
+                "Invalid network endpoint. Ensure you are specifying a valid websocket endpoint.",
+            )
+            return False
+        results: dict[str, list[float]] = self._run_command(
+            best_connection(Constants.finney_nodes + (additional_networks or []))
+        )
+        sorted_results = {
+            k: v for k, v in sorted(results.items(), key=lambda item: item[1][0])
+        }
+        table = Table(
+            Column("Network"),
+            Column("End to End Latency", style="cyan"),
+            Column("Single Request Ping", style="cyan"),
+            title="Connection Latencies (seconds)",
+            caption="lower value is faster",
+        )
+        for n_name, (overall_latency, single_request) in sorted_results.items():
+            table.add_row(n_name, str(overall_latency), str(single_request))
+        console.print(table)
+        fastest = next(iter(sorted_results.keys()))
+        if conf_net := self.config.get("network", ""):
+            if not conf_net.startswith("ws") and conf_net in Constants.networks:
+                conf_net = Constants.network_map[conf_net]
+            if conf_net != fastest:
+                console.print(
+                    f"The fastest network is {fastest}. You currently have {conf_net} selected as your default network."
+                    f"\nYou can update this with {arg__(f'btcli config set --network {fastest}')}"
+                )
+        return True
+
     def run(self):
         self.app()
 

bittensor_cli/src/__init__.py

@@ -23,6 +23,7 @@ class Constants:
     dev_entrypoint = "wss://dev.chain.opentensor.ai:443"
     local_entrypoint = "ws://127.0.0.1:9944"
     latent_lite_entrypoint = "wss://lite.sub.latent.to:443"
+    finney_nodes = [finney_entrypoint, subvortex_entrypoint, latent_lite_entrypoint]
     network_map = {
         "finney": finney_entrypoint,
         "test": finney_test_entrypoint,

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -1,21 +1,22 @@
 import asyncio
 import os
+import time
 from typing import Optional, Any, Union, TypedDict, Iterable
 
 import aiohttp
+from async_substrate_interface.async_substrate import (
+    DiskCachedAsyncSubstrateInterface,
+    AsyncSubstrateInterface,
+)
+from async_substrate_interface.errors import SubstrateRequestException
 from async_substrate_interface.utils.storage import StorageKey
 from bittensor_wallet import Wallet
 from bittensor_wallet.bittensor_wallet import Keypair
 from bittensor_wallet.utils import SS58_FORMAT
 from scalecodec import GenericCall
-from async_substrate_interface.errors import SubstrateRequestException
 import typer
+import websockets
 
-
-from async_substrate_interface.async_substrate import (
-    DiskCachedAsyncSubstrateInterface,
-    AsyncSubstrateInterface,
-)
 from bittensor_cli.src.bittensor.chain_data import (
     DelegateInfo,
     StakeInfo,
@@ -1654,3 +1655,24 @@ async def get_subnet_prices(
             map_[netuid_] = Balance.from_rao(int(current_price * 1e9))
 
         return map_
+
+
+async def best_connection(networks: list[str]):
+    """
+    Basic function to compare the latency of a given list of websocket endpoints
+    Args:
+        networks: list of network URIs
+
+    Returns:
+        {network_name: [end_to_end_latency, single_request_latency]}
+
+    """
+    results = {n: [0.0, 0.0] for n in networks}
+    for network in networks:
+        t1 = time.monotonic()
+        async with websockets.connect(network) as websocket:
+            pong = await websocket.ping()
+            latency = await pong
+            t2 = time.monotonic()
+        results[network] = [t2 - t1, latency]
+    return results