feat: complete block tracking integration

- Add block_id to PutOptions for automatic block tracking
- Add PutOptions::with_block() helper method
- LocalStorage::put now automatically updates metadata with block info
- Add execute_sync_with_block() and execute_get_weights_with_block() methods
- Pass block_height and epoch to WASM instances via InstanceConfig
- Add put_options_with_block() helper in validator
- Update sync and weight execution to pass current block context

Author: echobt

bins/validator-node/src/main.rs

@@ -92,6 +92,12 @@ where
     result
 }
 
+/// Create PutOptions with the current block number for tracking
+fn put_options_with_block(state_manager: &StateManager) -> PutOptions {
+    let block = state_manager.apply(|state| state.bittensor_block);
+    PutOptions::with_block(block)
+}
+
 // ==================== Shutdown Handler ====================
 
 /// Handles graceful shutdown with state persistence
@@ -1519,12 +1525,13 @@ async fn main() -> Result<()> {
                                 .collect()
                         };
 
+                        let current_epoch = current_block / 360;
                         for challenge_id in challenges {
                             let challenge_id_str = challenge_id.to_string();
                             let module_path = format!("{}.wasm", challenge_id_str);
 
                             if let Some(ref executor) = wasm_executor {
-                                match executor.execute_sync(&module_path) {
+                                match executor.execute_sync_with_block(&module_path, current_block, current_epoch) {
                                     Ok(sync_result) => {
                                         info!(
                                             challenge_id = %challenge_id,
@@ -3163,8 +3170,10 @@ async fn handle_block_event(
                 let challenges: Vec<String> = state_manager
                     .apply(|state| state.challenges.keys().map(|k| k.to_string()).collect());
                 let local_hotkey = keypair.hotkey();
+                let block_height = state_manager.apply(|state| state.bittensor_block);
+                let epoch = block_height / 360;
                 for cid in &challenges {
-                    match executor.execute_get_weights(cid) {
+                    match executor.execute_get_weights_with_block(cid, block_height, epoch) {
                         Ok(assignments) if !assignments.is_empty() => {
                             // Read emission_weight from chain state
                             let emission_weight = {

bins/validator-node/src/wasm_executor.rs

@@ -915,6 +915,16 @@ impl WasmChallengeExecutor {
     pub fn execute_get_weights(
         &self,
         module_path: &str,
+    ) -> Result<Vec<platform_challenge_sdk::WeightAssignment>> {
+        self.execute_get_weights_with_block(module_path, 0, 0)
+    }
+
+    /// Execute get_weights on a WASM challenge module with block context.
+    pub fn execute_get_weights_with_block(
+        &self,
+        module_path: &str,
+        block_height: u64,
+        epoch: u64,
     ) -> Result<Vec<platform_challenge_sdk::WeightAssignment>> {
         let start = Instant::now();
 
@@ -932,6 +942,8 @@ impl WasmChallengeExecutor {
             },
             storage_backend: Arc::clone(&self.config.storage_backend),
             consensus_policy: ConsensusPolicy::read_only(),
+            block_height,
+            epoch,
             ..Default::default()
         };
 
@@ -990,6 +1002,17 @@ impl WasmChallengeExecutor {
     pub fn execute_sync(
         &self,
         module_path: &str,
+    ) -> Result<platform_challenge_sdk_wasm::WasmSyncResult> {
+        self.execute_sync_with_block(module_path, 0, 0)
+    }
+
+    /// Execute sync on a WASM challenge module with block context.
+    /// Returns WasmSyncResult with leaderboard hash and stats for consensus.
+    pub fn execute_sync_with_block(
+        &self,
+        module_path: &str,
+        block_height: u64,
+        epoch: u64,
     ) -> Result<platform_challenge_sdk_wasm::WasmSyncResult> {
         let start = Instant::now();
 
@@ -1007,6 +1030,8 @@ impl WasmChallengeExecutor {
             },
             storage_backend: Arc::clone(&self.config.storage_backend),
             consensus_policy: ConsensusPolicy::read_only(),
+            block_height,
+            epoch,
             ..Default::default()
         };
 

crates/distributed-storage/src/local.rs

@@ -597,14 +597,22 @@ impl DistributedStore for LocalStorage {
             stored_value.metadata.ttl_seconds = options.ttl_seconds;
         }
 
-        // Create entry with replication info (no block_id for regular put)
+        // Update metadata with block tracking if provided
+        if let Some(block_id) = options.block_id {
+            if stored_value.metadata.created_block == 0 {
+                stored_value.metadata.created_block = block_id;
+            }
+            stored_value.metadata.updated_block = block_id;
+        }
+
+        // Create entry with replication info and optional block_id
         let entry = LocalEntry {
             value: stored_value.clone(),
             replication: ReplicationInfo {
                 needs_replication: !options.local_only,
                 ..Default::default()
             },
-            block_id: None,
+            block_id: options.block_id,
         };
 
         self.put_entry(&key, &entry)?;

crates/distributed-storage/src/store.rs

@@ -238,6 +238,18 @@ pub struct PutOptions {
     pub ttl_seconds: u64,
     /// Expected version for optimistic concurrency (None = ignore)
     pub expected_version: Option<u64>,
+    /// Block number for tracking when this write occurred
+    pub block_id: Option<u64>,
+}
+
+impl PutOptions {
+    /// Create options with a specific block ID for tracking
+    pub fn with_block(block_id: u64) -> Self {
+        Self {
+            block_id: Some(block_id),
+            ..Default::default()
+        }
+    }
 }
 
 /// Result of a list operation