feat: add tempo fetching from Bittensor chain

- Update bittensor-rs to 9cf5991 (exports get_tempo, get_reveal_period)
- Add tempo and current_block fields to AppState
- Fetch tempo from Bittensor on startup and cache it
- Return tempo in /api/v1/network/state endpoint
- NetworkStateEvent now includes tempo field

Author: echobt

Cargo.lock

@@ -31,8 +31,8 @@ license = "Apache-2.0"
 
 [workspace.dependencies]
 # Bittensor (with CRv4 timelock encryption support and new Subtensor API)
-# Updated to 453ce56: proper SCALE decoding for stake (includes parent inheritance)
-bittensor-rs = { git = "https://github.com/CortexLM/bittensor-rs", rev = "453ce56" }
+# Updated to 9cf5991: export get_tempo and get_reveal_period functions
+bittensor-rs = { git = "https://github.com/CortexLM/bittensor-rs", rev = "9cf5991" }
 
 # Async runtime
 tokio = { version = "1.40", features = ["full", "sync", "macros", "rt-multi-thread"] }

Cargo.toml

@@ -108,30 +108,49 @@ pub async fn run(args: ServerArgs) -> Result<()> {
     let db = db::init_db(&args.database_url).await?;
     info!("Database: platform_server");
 
-    // Sync metagraph BEFORE accepting connections (blocking)
+    // Sync metagraph and fetch tempo BEFORE accepting connections (blocking)
     info!("Syncing metagraph (netuid={})...", args.netuid);
-    let metagraph = match platform_bittensor::BittensorClient::new(&args.subtensor_endpoint).await {
-        Ok(client) => match platform_bittensor::sync_metagraph(&client, args.netuid).await {
-            Ok(mg) => {
-                info!("Metagraph synced: {} neurons", mg.n);
-                Some(mg)
+    let (metagraph, tempo) =
+        match platform_bittensor::BittensorClient::new(&args.subtensor_endpoint).await {
+            Ok(client) => {
+                // Fetch tempo from chain
+                let tempo = match platform_bittensor::get_tempo(&client, args.netuid).await {
+                    Ok(t) => {
+                        info!("Tempo fetched from chain: {}", t);
+                        t as u64
+                    }
+                    Err(e) => {
+                        warn!("Failed to fetch tempo: {} (using default 360)", e);
+                        360u64
+                    }
+                };
+
+                // Sync metagraph
+                let metagraph = match platform_bittensor::sync_metagraph(&client, args.netuid).await
+                {
+                    Ok(mg) => {
+                        info!("Metagraph synced: {} neurons", mg.n);
+                        Some(mg)
+                    }
+                    Err(e) => {
+                        warn!(
+                            "Metagraph sync failed: {} (validators will have stake=0)",
+                            e
+                        );
+                        None
+                    }
+                };
+
+                (metagraph, tempo)
             }
             Err(e) => {
                 warn!(
-                    "Metagraph sync failed: {} (validators will have stake=0)",
+                    "Could not connect to subtensor: {} (validators will have stake=0, tempo=360)",
                     e
                 );
-                None
+                (None, 360u64)
             }
-        },
-        Err(e) => {
-            warn!(
-                "Could not connect to subtensor: {} (validators will have stake=0)",
-                e
-            );
-            None
-        }
-    };
+        };
 
     // Initialize challenge orchestrator
     info!("Initializing Challenge Orchestrator...");
@@ -157,6 +176,10 @@ pub async fn run(args: ServerArgs) -> Result<()> {
         metagraph,
     ));
 
+    // Set cached tempo from Bittensor
+    state.set_tempo(tempo);
+    info!("Tempo cached: {} blocks per epoch", tempo);
+
     // Build router
     let app = Router::new()
         .route("/health", get(health_check))

bins/platform/src/server.rs

@@ -39,5 +39,8 @@ pub use bittensor_rs::{
     WeightResponseData,
 };
 
+// Re-export tempo/epoch functions
+pub use bittensor_rs::{get_reveal_period, get_tempo};
+
 // Re-export chain types needed for weight submission
 pub use bittensor_rs::chain::{signer_from_seed, BittensorSigner, ExtrinsicWait};

crates/bittensor-integration/src/lib.rs

@@ -10,11 +10,22 @@ pub async fn get_network_state(
     State(state): State<Arc<AppState>>,
 ) -> Result<Json<NetworkStateEvent>, StatusCode> {
     let current_epoch = queries::get_current_epoch(&state.db).await.unwrap_or(0);
-    let current_block = queries::get_network_state(&state.db, "current_block")
-        .await
-        .unwrap_or(None)
-        .and_then(|s| s.parse().ok())
-        .unwrap_or(0u64);
+    // Use cached current_block from state (updated by block sync)
+    // Fall back to database if not set
+    let current_block = {
+        let cached = state.get_current_block();
+        if cached > 0 {
+            cached
+        } else {
+            queries::get_network_state(&state.db, "current_block")
+                .await
+                .unwrap_or(None)
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(0u64)
+        }
+    };
+    // Use cached tempo from state (fetched from Bittensor)
+    let tempo = state.get_tempo();
     let total_stake = queries::get_total_stake(&state.db).await.unwrap_or(0);
     let validators = queries::get_validators(&state.db).await.unwrap_or_default();
     let pending = queries::get_pending_submissions(&state.db)
@@ -24,6 +35,7 @@ pub async fn get_network_state(
     Ok(Json(NetworkStateEvent {
         current_epoch,
         current_block,
+        tempo,
         total_stake,
         active_validators: validators.len() as u32,
         pending_submissions: pending.len() as u32,

crates/platform-server/src/api/challenges.rs

@@ -498,6 +498,7 @@ pub struct ValidatorEvent {
 pub struct NetworkStateEvent {
     pub current_epoch: u64,
     pub current_block: u64,
+    pub tempo: u64,
     pub total_stake: u64,
     pub active_validators: u32,
     pub pending_submissions: u32,

crates/platform-server/src/models/mod.rs

@@ -59,6 +59,9 @@ impl Default for MetricsCache {
     }
 }
 
+/// Default tempo (blocks per epoch) - Bittensor default
+pub const DEFAULT_TEMPO: u64 = 360;
+
 pub struct AppState {
     pub db: DbPool,
     pub sessions: DashMap<String, crate::models::AuthSession>,
@@ -72,6 +75,10 @@ pub struct AppState {
     pub validator_whitelist: RwLock<HashSet<String>>,
     /// In-memory cache for validator metrics
     pub metrics_cache: MetricsCache,
+    /// Cached tempo (blocks per epoch) from Bittensor
+    pub tempo: RwLock<u64>,
+    /// Current block number from Bittensor
+    pub current_block: RwLock<u64>,
 }
 
 impl AppState {
@@ -92,6 +99,8 @@ impl AppState {
             metagraph: RwLock::new(metagraph),
             validator_whitelist: RwLock::new(HashSet::new()),
             metrics_cache: MetricsCache::new(),
+            tempo: RwLock::new(DEFAULT_TEMPO),
+            current_block: RwLock::new(0),
         }
     }
 
@@ -112,9 +121,31 @@ impl AppState {
             metagraph: RwLock::new(metagraph),
             validator_whitelist: RwLock::new(validator_whitelist.into_iter().collect()),
             metrics_cache: MetricsCache::new(),
+            tempo: RwLock::new(DEFAULT_TEMPO),
+            current_block: RwLock::new(0),
         }
     }
 
+    /// Set tempo (called when syncing with Bittensor)
+    pub fn set_tempo(&self, tempo: u64) {
+        *self.tempo.write() = tempo;
+    }
+
+    /// Get cached tempo
+    pub fn get_tempo(&self) -> u64 {
+        *self.tempo.read()
+    }
+
+    /// Set current block
+    pub fn set_current_block(&self, block: u64) {
+        *self.current_block.write() = block;
+    }
+
+    /// Get current block
+    pub fn get_current_block(&self) -> u64 {
+        *self.current_block.read()
+    }
+
     /// Get validator stake from metagraph (returns 0 if not found)
     /// If validator is in whitelist, returns a high stake value (for testing)
     pub fn get_validator_stake(&self, hotkey: &str) -> u64 {