Add metagraph hotkeys tracking and RPC endpoints

- Add registered_hotkeys HashSet to ChainState for all metagraph neurons
- Update validator_sync to populate all hotkeys during metagraph sync
- Add metagraph_hotkeys and metagraph_isRegistered JSON-RPC endpoints
- Optimize CI with cargo-nextest and skip coverage on PRs

Author: echobt

.github/workflows/ci.yml

@@ -16,65 +16,14 @@ env:
   REGISTRY: ghcr.io
   IMAGE_NAME: ${{ github.repository }}
 
-# Cancel in-progress runs for the same branch
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:
-  # Build job - creates shared cache for other jobs (only this job saves cache)
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Free disk space
-        run: |
-          sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/ghc /opt/hostedtoolcache/CodeQL
-          sudo docker image prune --all --force
-
-      - uses: actions/checkout@v4
-
-      - uses: dtolnay/rust-toolchain@stable
-
-      - name: Cache cargo
-        uses: Swatinem/rust-cache@v2
-        with:
-          cache-on-failure: true
-          shared-key: "platform-ci"
-          save-if: ${{ github.ref == format('refs/heads/{0}', github.event.repository.default_branch) }}
-
-      - name: Build
-        run: cargo build --release
-
-  # Clippy runs in parallel with build (reads cache only)
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
-    steps:
-      - name: Free disk space
-        run: |
-          sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/ghc /opt/hostedtoolcache/CodeQL
-          sudo docker image prune --all --force
-
-      - uses: actions/checkout@v4
-
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: clippy
-
-      - name: Cache cargo
-        uses: Swatinem/rust-cache@v2
-        with:
-          cache-on-failure: true
-          shared-key: "platform-ci"
-          save-if: false
-
-      - name: Run clippy
-        run: cargo clippy --all-targets --workspace -- -W clippy::all
-
-  # Test job - runs faster with nextest (reads cache only)
-  test:
-    name: Test
+  # Single CI job - faster than parallel because cache is restored once
+  ci:
+    name: Build & Test
     runs-on: ubuntu-latest
     permissions:
       contents: write
@@ -88,7 +37,7 @@ jobs:
 
       - uses: dtolnay/rust-toolchain@stable
         with:
-          components: llvm-tools-preview
+          components: clippy,llvm-tools-preview
 
       - name: Install cargo-nextest and cargo-llvm-cov
         uses: taiki-e/install-action@v2
@@ -99,21 +48,28 @@ jobs:
         uses: Swatinem/rust-cache@v2
         with:
           cache-on-failure: true
-          shared-key: "platform-ci"
-          save-if: false
+          shared-key: "platform-ci-v1"
+
+      # Build first - subsequent steps reuse artifacts
+      - name: Build
+        run: cargo build --release --all-targets
+
+      # Clippy uses cached build artifacts
+      - name: Clippy
+        run: cargo clippy --all-targets --workspace -- -W clippy::all
 
-      # Run tests with nextest (faster) - coverage only on main
+      # Tests - with coverage only on main
       - name: Run tests
-        if: github.ref != format('refs/heads/{0}', github.event.repository.default_branch)
+        if: github.ref != 'refs/heads/main'
         run: cargo nextest run --workspace -E 'not (test(/live/) | test(/integration/))'
 
       - name: Run tests with coverage
-        if: github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+        if: github.ref == 'refs/heads/main'
         run: |
           cargo llvm-cov nextest --workspace --json --output-path coverage.json -E 'not (test(/live/) | test(/integration/))'
 
       - name: Generate coverage badge
-        if: github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+        if: github.ref == 'refs/heads/main'
         run: |
           COVERAGE=$(jq '.data[0].totals.lines.percent // 0 | round' coverage.json)
           echo "Coverage: $COVERAGE%"
@@ -125,19 +81,19 @@ jobs:
           curl -s "https://img.shields.io/badge/coverage-${COVERAGE}%25-${COLOR}" > badges/coverage.svg
 
       - name: Deploy coverage badge
-        if: github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+        if: github.ref == 'refs/heads/main'
         uses: peaceiris/actions-gh-pages@v4
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           publish_dir: ./badges
           destination_dir: badges
           keep_files: true
 
-  # Docker build - only after tests pass
+  # Docker build - only after CI passes
   docker:
     name: Build & Push Docker
     runs-on: ubuntu-latest
-    needs: [build, test]
+    needs: [ci]
     permissions:
       contents: read
       packages: write
@@ -187,25 +143,19 @@ jobs:
   release:
     name: Release
     runs-on: ubuntu-latest
-    needs: [build, test, docker]
+    needs: [ci, docker]
     if: startsWith(github.ref, 'refs/tags/v')
     permissions:
       contents: write
     steps:
-      - name: Free disk space
-        run: |
-          sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/ghc /opt/hostedtoolcache/CodeQL
-          sudo docker image prune --all --force
-
       - uses: actions/checkout@v4
 
       - uses: dtolnay/rust-toolchain@stable
 
       - name: Cache cargo
         uses: Swatinem/rust-cache@v2
         with:
-          shared-key: "platform-ci"
-          save-if: false
+          shared-key: "platform-ci-v1"
 
       - name: Build release binaries
         run: cargo build --release

crates/bittensor-integration/src/validator_sync.rs

@@ -88,11 +88,17 @@ impl ValidatorSync {
             .await
             .map_err(|e| SyncError::ClientError(e.to_string()))?;
 
-        // Parse validators from metagraph
-        let bt_validators = self.parse_metagraph(metagraph)?;
+        // Parse validators and all hotkeys from metagraph
+        let (bt_validators, all_hotkeys) = self.parse_metagraph(metagraph)?;
         drop(client); // Release lock
 
-        // Update state
+        // Update registered hotkeys in state (all miners + validators)
+        {
+            let mut state_guard = state.write();
+            state_guard.registered_hotkeys = all_hotkeys;
+        }
+
+        // Update state with validators
         let result = self.update_state(state, bt_validators, banned_validators);
 
         // Update last sync block
@@ -106,49 +112,58 @@ impl ValidatorSync {
         Ok(result)
     }
 
-    /// Parse metagraph data to extract validators
-    fn parse_metagraph(&self, metagraph: &Metagraph) -> Result<Vec<MetagraphValidator>, SyncError> {
+    /// Parse metagraph data to extract validators and all registered hotkeys
+    fn parse_metagraph(
+        &self,
+        metagraph: &Metagraph,
+    ) -> Result<(Vec<MetagraphValidator>, std::collections::HashSet<Hotkey>), SyncError> {
         let mut validators = Vec::new();
+        let mut all_hotkeys = std::collections::HashSet::new();
 
         // Parse neurons from metagraph
         for (uid, neuron) in &metagraph.neurons {
             // Convert AccountId32 hotkey to our Hotkey type
             let hotkey_bytes: &[u8; 32] = neuron.hotkey.as_ref();
             let hotkey = Hotkey(*hotkey_bytes);
 
+            // Add ALL hotkeys to the registered set (miners + validators)
+            all_hotkeys.insert(hotkey.clone());
+
             // Get effective stake: alpha stake + root stake (TAO on root subnet)
             // This matches how Bittensor calculates validator weight
             let alpha_stake = neuron.stake;
             let root_stake = neuron.root_stake;
             let effective_stake = alpha_stake.saturating_add(root_stake);
             let stake = effective_stake.min(u64::MAX as u128) as u64;
 
-            // Skip if below minimum stake
-            if stake < self.min_stake {
-                continue;
+            // Only add to validators if above minimum stake
+            if stake >= self.min_stake {
+                // Extract normalized scores (u16 -> f64, divide by u16::MAX)
+                let incentive = neuron.incentive / u16::MAX as f64;
+                let trust = neuron.trust / u16::MAX as f64;
+                let consensus = neuron.consensus / u16::MAX as f64;
+
+                // Check if active (has stake)
+                let active = stake > 0;
+
+                validators.push(MetagraphValidator {
+                    hotkey,
+                    uid: *uid as u16,
+                    stake,
+                    active,
+                    incentive,
+                    trust,
+                    consensus,
+                });
             }
-
-            // Extract normalized scores (u16 -> f64, divide by u16::MAX)
-            let incentive = neuron.incentive / u16::MAX as f64;
-            let trust = neuron.trust / u16::MAX as f64;
-            let consensus = neuron.consensus / u16::MAX as f64;
-
-            // Check if active (has stake)
-            let active = stake > 0;
-
-            validators.push(MetagraphValidator {
-                hotkey,
-                uid: *uid as u16,
-                stake,
-                active,
-                incentive,
-                trust,
-                consensus,
-            });
         }
 
-        debug!("Parsed {} validators from metagraph", validators.len());
-        Ok(validators)
+        debug!(
+            "Parsed {} validators and {} total hotkeys from metagraph",
+            validators.len(),
+            all_hotkeys.len()
+        );
+        Ok((validators, all_hotkeys))
     }
 
     /// Update chain state with validators from Bittensor

crates/core/src/state.rs

@@ -59,6 +59,11 @@ pub struct ChainState {
 
     /// Last update timestamp
     pub last_updated: chrono::DateTime<chrono::Utc>,
+
+    /// All registered hotkeys from metagraph (miners + validators)
+    /// Updated during metagraph sync, used for submission verification
+    #[serde(default)]
+    pub registered_hotkeys: std::collections::HashSet<Hotkey>,
 }
 
 impl ChainState {
@@ -78,6 +83,7 @@ impl ChainState {
             pending_jobs: Vec::new(),
             state_hash: [0u8; 32],
             last_updated: chrono::Utc::now(),
+            registered_hotkeys: std::collections::HashSet::new(),
         };
         state.update_hash();
         state

crates/rpc-server/src/jsonrpc.rs

@@ -349,6 +349,10 @@ impl RpcHandler {
             ["validator", "get"] => self.validator_get(req.id, req.params),
             ["validator", "count"] => self.validator_count(req.id),
 
+            // Metagraph namespace
+            ["metagraph", "hotkeys"] => self.metagraph_hotkeys(req.id),
+            ["metagraph", "isRegistered"] => self.metagraph_is_registered(req.id, req.params),
+
             // Challenge namespace
             ["challenge", "list"] => self.challenge_list(req.id, req.params),
             ["challenge", "get"] => self.challenge_get(req.id, req.params),
@@ -891,6 +895,58 @@ impl RpcHandler {
         JsonRpcResponse::result(id, json!(chain.validators.len()))
     }
 
+    // ==================== Metagraph Namespace ====================
+
+    /// Get all registered hotkeys from metagraph (miners + validators)
+    fn metagraph_hotkeys(&self, id: Value) -> JsonRpcResponse {
+        let chain = self.chain_state.read();
+        let hotkeys: Vec<String> = chain
+            .registered_hotkeys
+            .iter()
+            .map(|h| h.to_hex())
+            .collect();
+
+        JsonRpcResponse::result(
+            id,
+            json!({
+                "count": hotkeys.len(),
+                "hotkeys": hotkeys,
+            }),
+        )
+    }
+
+    /// Check if a hotkey is registered in the metagraph
+    fn metagraph_is_registered(&self, id: Value, params: Value) -> JsonRpcResponse {
+        let hotkey = match self.get_param_str(&params, 0, "hotkey") {
+            Some(h) => h,
+            None => {
+                return JsonRpcResponse::error(id, INVALID_PARAMS, "Missing 'hotkey' parameter")
+            }
+        };
+
+        let hk = match platform_core::Hotkey::from_hex(&hotkey) {
+            Some(h) => h,
+            None => {
+                // Try SS58 format
+                match platform_core::Hotkey::from_ss58(&hotkey) {
+                    Some(h) => h,
+                    None => return JsonRpcResponse::error(id, INVALID_PARAMS, "Invalid hotkey format"),
+                }
+            }
+        };
+
+        let chain = self.chain_state.read();
+        let is_registered = chain.registered_hotkeys.contains(&hk);
+
+        JsonRpcResponse::result(
+            id,
+            json!({
+                "hotkey": hotkey,
+                "isRegistered": is_registered,
+            }),
+        )
+    }
+
     // ==================== Challenge Namespace ====================
 
     fn challenge_list(&self, id: Value, params: Value) -> JsonRpcResponse {