Use taostats for chain data

requirements.txt

@@ -5,4 +5,5 @@ substrate-interface==1.7.10
 plotly==5.24.1
 pandas==2.2.3
 packaging==24.2
-netaddr==1.3.0
+netaddr==1.3.0
+cachetools==5.5.0

src/app.py

@@ -1,6 +1,6 @@
 import gradio as gr
 
-from chain_data import sync_metagraph
+from chain_data import sync_chain
 from leaderboard import create_leaderboard, create_dropdown, create_baseline
 from model_demo import create_demo
 from submissions import create_submissions, DROPDOWN_OPTIONS
@@ -10,7 +10,7 @@ from wandb_data import sync
 
 
 def main():
-    sync_metagraph()
+    sync_chain()
     sync()
     with gr.Blocks(css=".typewriter {font-family: 'JMH Typewriter', sans-serif;}", fill_height=True, fill_width=True) as app:
         with gr.Tab("Leaderboard") as leaderboard_tab:

src/chain_data.py

@@ -3,20 +3,21 @@ import traceback
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 from enum import Enum
-from math import ceil
 from typing import TypeAlias
 
+import requests
+from cachetools import TTLCache, cached
 from fiber import constants
 from fiber.chain.commitments import _deserialize_commitment_field
 from fiber.chain.interface import get_substrate
-from fiber.chain.metagraph import Metagraph
-from fiber.chain.models import Node
+from pydantic import BaseModel
 from substrateinterface import SubstrateInterface
 from substrateinterface.storage import StorageKey
 
 from network_commitments import Decoder
 from src import Key, Uid, TIMEZONE
 
+TAOSTATS_API_KEY = os.getenv("TAOSTATS_API_KEY")
 DISABLE_COMMITMENTS_FETCH = int(os.getenv("DISABLE_COMMITMENTS_FETCH") or 0) > 0
 
 Weight: TypeAlias = float
@@ -28,6 +29,17 @@ class ContestId(Enum):
     SDXL_NEWDREAM_NVIDIA_4090 = 1
 
 
+class Neuron(BaseModel):
+    hotkey: str
+    coldkey: str
+    validator_trust: float
+    validator_permit: bool
+    incentive: float
+    updated: int
+    uid: int
+    block_number: int
+
+
 @dataclass
 class Commitment:
     provider: str
@@ -60,13 +72,10 @@ NET_UID = 39
 WEIGHTS_BY_MINER: dict[Key, list[tuple[Key, Weight]]] = {}
 VALIDATOR_IDENTITIES: dict[Key, str] = {}
 COMMITMENTS: dict[Key, Commitment] = {}
-UPDATED: dict[Key, int] = {}
 
-UIDS_BY_HOTKEY: dict[Key, Uid] = {}
 HOTKEYS_BY_UID: dict[Uid, Key] = {}
 
 substrate = get_substrate(subtensor_address=constants.FINNEY_SUBTENSOR_ADDRESS)
-metagraph = Metagraph(substrate, netuid=str(NET_UID), load_old_nodes=False)
 
 
 def query_subtensor(storage_keys: list[StorageKey], block: int) -> list:
@@ -81,61 +90,47 @@ def query_subtensor(storage_keys: list[StorageKey], block: int) -> list:
         raise
 
 
-def is_validator(node: Node) -> bool:
-    return node.vtrust > 0 or node.stake > 10_000
-
-
-def get_nodes() -> dict[Key, Node]:
-    return metagraph.nodes
-
-
 def fetch_weights(block: int):
     WEIGHTS_BY_MINER.clear()
     storage_keys: list[StorageKey] = []
-    for hotkey, node in metagraph.nodes.items():
-        if not is_validator(node): continue
+    for hotkey, neuron in get_neurons().items():
+        if not neuron.validator_permit: continue
         storage_keys.append(substrate.create_storage_key(
             "SubtensorModule",
             "Weights",
-            [metagraph.netuid, UIDS_BY_HOTKEY[node.hotkey]]
+            [NET_UID, neuron.uid]
         ))
 
     weights = query_subtensor(storage_keys, block)
 
-    for hotkey, node in metagraph.nodes.items():
+    for hotkey, neuron in get_neurons().items():
         for storage, validator_weights in weights:
             validator_hotkey = HOTKEYS_BY_UID[storage.params[1]]
             if hotkey not in WEIGHTS_BY_MINER:
                 WEIGHTS_BY_MINER[hotkey] = []
             weight = 0.0
             for miner_weight in validator_weights:
-                if miner_weight[0].value == UIDS_BY_HOTKEY[hotkey]:
+                if miner_weight[0].value == neuron.uid:
                     weight = miner_weight[1].value / 2 ** 16
                     break
             WEIGHTS_BY_MINER[hotkey].append((validator_hotkey, weight))
 
 
-def fetch_updated(block: int):
-    UPDATED.clear()
-    for hotkey, node in metagraph.nodes.items():
-        UPDATED[hotkey] = ceil(block - node.last_updated)
-
-
 def fetch_identities(block: int):
     VALIDATOR_IDENTITIES.clear()
     storage_keys: list[StorageKey] = []
-    for hotkey, node in metagraph.nodes.items():
-        if not is_validator(node): continue
+    for hotkey, neuron in get_neurons().items():
+        if not neuron.validator_permit: continue
         storage_keys.append(substrate.create_storage_key(
             "SubtensorModule",
             "Identities",
-            [node.coldkey]
+            [neuron.coldkey]
         ))
 
     identities = query_subtensor(storage_keys, block)
-    for hotkey, node in metagraph.nodes.items():
+    for hotkey, neuron in get_neurons().items():
         for storage, info in identities:
-            if node.coldkey != storage.params[0]: continue
+            if neuron.coldkey != storage.params[0]: continue
             if info != None:  # noqa
                 VALIDATOR_IDENTITIES[hotkey] = info.value["name"]
                 break
@@ -147,12 +142,12 @@ def fetch_commitments(block: int):
 
     COMMITMENTS.clear()
     storage_keys: list[StorageKey] = []
-    for hotkey, node in metagraph.nodes.items():
-        if is_validator(node): continue
+    for hotkey, neuron in get_neurons().items():
+        if neuron.validator_permit: continue
         storage_keys.append(substrate.create_storage_key(
             "Commitments",
             "CommitmentOf",
-            [metagraph.netuid, hotkey]
+            [NET_UID, hotkey]
         ))
 
     commitments = query_subtensor(storage_keys, block)
@@ -184,7 +179,39 @@ last_identity_sync: datetime = datetime.fromtimestamp(0, TIMEZONE)
 last_commitment_sync: datetime = datetime.fromtimestamp(0, TIMEZONE)
 
 
-def sync_metagraph():
+@cached(cache=TTLCache(maxsize=1, ttl=120))
+def get_neurons() -> dict[Key, Neuron]:
+    response = requests.get(
+        "https://api.taostats.io/api/metagraph/latest/v1",
+        headers={
+            "accept": "application/json",
+            "Authorization": TAOSTATS_API_KEY,
+        },
+        params={
+            "netuid": 39,
+        }
+    )
+
+    response.raise_for_status()
+
+    return {
+        neuron["hotkey"]["ss58"]: Neuron(
+            hotkey=neuron["hotkey"]["ss58"],
+            coldkey=neuron["coldkey"]["ss58"],
+            validator_trust=float(neuron["validator_trust"]),
+            validator_permit=bool(neuron["validator_permit"]),
+            incentive=float(neuron["incentive"]),
+            updated=int(neuron["updated"]),
+            uid=int(neuron["uid"]),
+            block_number=int(neuron["block_number"]),
+        ) for neuron in response.json()["data"]
+    }
+
+def get_latest_block():
+    return max([neuron.block_number for neuron in get_neurons().values()])
+
+
+def sync_chain():
     global substrate
     global last_sync
     now = datetime.now(TIMEZONE)
@@ -193,16 +220,14 @@ def sync_metagraph():
     last_sync = now
 
     try:
-        print("Syncing metagraph...")
-        metagraph.sync_nodes()
-        block = substrate.get_block_number(None)  # type: ignore
+        print("Syncing chain...")
+
+        block = get_latest_block()
 
-        for uid, node in enumerate(metagraph.nodes.values()):
-            UIDS_BY_HOTKEY[node.hotkey] = uid
-            HOTKEYS_BY_UID[uid] = node.hotkey
+        for hotkey, neuron in get_neurons().items():
+            HOTKEYS_BY_UID[neuron.uid] = hotkey
 
         fetch_weights(block)
-        fetch_updated(block)
 
         global last_identity_sync
         if now - last_identity_sync > timedelta(days=1):
@@ -216,6 +241,6 @@ def sync_metagraph():
             last_commitment_sync = now
             fetch_commitments(block)
     except Exception:
-        print(f"Error occurred while syncing metagraph")
+        print(f"Error occurred while syncing chain")
         traceback.print_exc()
         substrate = SubstrateInterface(substrate.url)

src/submissions.py

@@ -3,9 +3,10 @@ from enum import Enum
 import gradio as gr
 import pandas as pd
 
-from chain_data import sync_metagraph, COMMITMENTS, UIDS_BY_HOTKEY, metagraph
+from chain_data import sync_chain, COMMITMENTS
 from src import Key
-from wandb_data import get_current_runs, Run, BLACKLISTED_HOTKEYS, BLACKLISTED_COLDKEYS, DUPLICATE_SUBMISSIONS
+from src.chain_data import get_neurons
+from wandb_data import get_current_runs, Run, get_blacklisted_keys
 
 
 class SubmissionStatus(Enum):
@@ -17,12 +18,13 @@ class SubmissionStatus(Enum):
 
     @staticmethod
     def get_status(run: Run, hotkey: Key, coldkey: Key, block: int, revision: str) -> "SubmissionStatus":
-        if hotkey in BLACKLISTED_HOTKEYS or coldkey in BLACKLISTED_COLDKEYS:
+        blacklisted_keys = get_blacklisted_keys()
+        if hotkey in blacklisted_keys.hotkeys or coldkey in blacklisted_keys.coldkeys:
             return SubmissionStatus.BLACKLISTED
 
         if any(
             submission.hotkey == hotkey and submission.revision == revision
-            for submission in DUPLICATE_SUBMISSIONS
+            for submission in blacklisted_keys.duplicates
         ):
             return SubmissionStatus.DUPLICATE
 
@@ -43,14 +45,17 @@ DROPDOWN_OPTIONS = [status.value[0] for status in SubmissionStatus]
 
 def create_submissions(submission_filters: list[str]) -> gr.Dataframe:
     data: list[list] = []
-    sync_metagraph()
+    sync_chain()
     runs = sorted(get_current_runs(), key=lambda run: run.uid)
 
     for hotkey, commitment in COMMITMENTS.items():
-        coldkey = metagraph.nodes[hotkey].coldkey
+        neuron = get_neurons().get(hotkey)
+        if not neuron:
+            continue
+        coldkey = neuron.coldkey
 
         row = [
-            UIDS_BY_HOTKEY[hotkey],
+            neuron.uid,
             f"[{'/'.join(commitment.get_repo_link().split('/')[-2:])}]({commitment.get_repo_link()})",
             f"[{commitment.block}](https://taostats.io/block/{commitment.block}/extrinsics)",
             f"[{commitment.revision}]({commitment.get_repo_link()}/commit/{commitment.revision})",

src/validator_states.py

@@ -4,7 +4,7 @@ import gradio as gr
 import pandas as pd
 from packaging import version
 
-from chain_data import get_nodes, UPDATED
+from chain_data import get_neurons
 from wandb_data import get_current_runs, Run
 
 AVERAGE_BENCHMARKING_TIME_WARNING_THRESHOLD = 180  # 3 minutes
@@ -31,10 +31,10 @@ def create_validator_states() -> gr.Dataframe:
     runs = sorted(get_current_runs(), key=lambda run: run.uid)
     latest_version = get_latest_version(runs)
     for run in runs:
-        if not run.hotkey in get_nodes():
+        if not run.hotkey in get_neurons():
             continue
-        vtrust = get_nodes()[run.hotkey].vtrust
-        updated = UPDATED.get(run.hotkey, 0)
+        vtrust = get_neurons()[run.hotkey].validator_trust
+        updated = get_neurons()[run.hotkey].updated
         data.append([
             run.uid,
             run.name,

src/validator_weights.py

@@ -1,7 +1,7 @@
 import gradio as gr
 import pandas as pd
 
-from chain_data import WEIGHTS_BY_MINER, UIDS_BY_HOTKEY, get_nodes, sync_metagraph, Weight
+from chain_data import WEIGHTS_BY_MINER, get_neurons, sync_chain, Weight
 from wandb_data import Key, get_current_runs
 
 
@@ -39,27 +39,28 @@ def get_active_weights() -> dict[Key, list[tuple[Key, Weight]]]:
 
 def create_weights(include_inactive: bool) -> gr.Dataframe:
     data: list[list] = []
-    sync_metagraph()
+    sync_chain()
 
     headers = ["Miner UID", "Incentive"]
     datatype = ["number", "markdown"]
 
     weights = WEIGHTS_BY_MINER if include_inactive else get_active_weights()
 
+    neurons = get_neurons()
     validator_uids = set()
     for _, validator_weights in weights.items():
-        for validator_hotkey, _ in validator_weights:
-            validator_uids.add(UIDS_BY_HOTKEY[validator_hotkey])
+        for hotkey, _ in validator_weights:
+            validator_uids.add(neurons[hotkey].uid)
 
     for validator_uid in sorted(validator_uids):
         headers.append(str(validator_uid))
         datatype.append("markdown")
 
     for hotkey, validator_weights in weights.items():
-        if not hotkey in get_nodes():
+        if not hotkey in neurons:
             continue
-        incentive = get_nodes()[hotkey].incentive / 2 ** 16
-        row = [UIDS_BY_HOTKEY[hotkey], f"<span style='color: {get_color_by_weight(incentive)}'>{incentive:.{3}f}</span>"]
+        incentive = neurons[hotkey].incentive
+        row = [neurons[hotkey].uid, f"<span style='color: {get_color_by_weight(incentive)}'>{incentive:.{3}f}</span>"]
         for _, weight in validator_weights:
             row.append(f"<span style='color: {get_color_by_weight(weight)}'>{weight:.{3}f}</span>")
         data.append(row)

src/wandb_data.py

@@ -5,12 +5,14 @@ from enum import Enum
 
 import requests
 import wandb
+from cachetools import TTLCache, cached
 import wandb.apis.public as wapi
 from pydantic import BaseModel, RootModel
 from substrateinterface import Keypair
 
-from chain_data import UIDS_BY_HOTKEY, VALIDATOR_IDENTITIES, sync_metagraph
+from chain_data import VALIDATOR_IDENTITIES, sync_chain
 from src import TIMEZONE, Key
+from src.chain_data import get_neurons
 
 WANDB_RUN_PATH = os.environ["WANDB_RUN_PATH"]
 
@@ -19,8 +21,7 @@ OFFSET_DAYS = 0
 
 BLACKLIST_ENDPOINT = "https://edge-inputs.api.wombo.ai/blacklist"
 DUPLICATE_SUBMISSIONS_ENDPOINT = "https://edge-inputs.api.wombo.ai/duplicate_submissions"
-BLACKLISTED_COLDKEYS = set()
-BLACKLISTED_HOTKEYS = set()
+
 
 class DuplicateSubmission(BaseModel):
     hotkey: Key
@@ -28,7 +29,10 @@ class DuplicateSubmission(BaseModel):
     revision: str
     copy_of: Key
 
-DUPLICATE_SUBMISSIONS: list[DuplicateSubmission] = []
+class Blacklist(BaseModel):
+    coldkeys: set[Key]
+    hotkeys: set[Key]
+    duplicates: list[DuplicateSubmission]
 
 
 class BenchmarkStatus(Enum):
@@ -160,11 +164,11 @@ def _add_runs(wandb_runs: list[wapi.Run]):
 
         if "submissions" in metrics:
             for hotkey, submission in metrics["submissions"].items():
-                uid = UIDS_BY_HOTKEY.get(hotkey)
-                if not uid:
+                neuron = get_neurons().get(hotkey)
+                if not neuron:
                     continue
                 submission_info[hotkey] = SubmissionInfo(
-                    uid=uid,
+                    uid=neuron.uid,
                     repository=submission["repository_info"]["url"],
                     revision=submission["repository_info"]["revision"],
                     block=submission["block"],
@@ -275,22 +279,25 @@ def _fetch_current_runs(wandb_api: wandb.Api):
     )
     _add_runs(wandb_runs)
 
-
-def _fetch_blacklisted_keys():
+@cached(cache=TTLCache(maxsize=1, ttl=300))
+def get_blacklisted_keys() -> Blacklist:
     response = requests.get(BLACKLIST_ENDPOINT)
     response.raise_for_status()
     data = response.json()
-    BLACKLISTED_COLDKEYS.clear()
-    BLACKLISTED_HOTKEYS.clear()
-    for hotkey in data["hotkeys"]:
-        BLACKLISTED_HOTKEYS.add(hotkey)
-    for coldkey in data["coldkeys"]:
-        BLACKLISTED_COLDKEYS.add(coldkey)
+
+    blacklist_hotkeys = set(data["hotkeys"])
+    blacklist_coldkeys = set(data["coldkeys"])
 
     response = requests.get(DUPLICATE_SUBMISSIONS_ENDPOINT)
     response.raise_for_status()
-    DUPLICATE_SUBMISSIONS.clear()
-    DUPLICATE_SUBMISSIONS.extend(RootModel[list[DuplicateSubmission]].model_validate_json(response.text).root)
+
+    duplicate_submissions = RootModel[list[DuplicateSubmission]].model_validate_json(response.text).root
+
+    return Blacklist(
+        hotkeys=blacklist_hotkeys,
+        coldkeys=blacklist_coldkeys,
+        duplicates=duplicate_submissions
+    )
 
 
 last_sync: datetime = datetime.fromtimestamp(0, TIMEZONE)
@@ -309,11 +316,10 @@ def sync():
         _fetch_history(wandb_api)
     else:
         _fetch_current_runs(wandb_api)
-    _fetch_blacklisted_keys()
 
 
 def get_current_runs() -> list[Run]:
-    sync_metagraph()
+    sync_chain()
     sync()
 
     contest_start = _get_contest_start() - timedelta(days=OFFSET_DAYS)