chore(validator): disable old validator migration (#509)

* disable old validator migraiton

Author: JannikSt

crates/validator/src/main.rs

@@ -371,15 +371,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         None
     };
 
-    // Run rejection data migration if validator exists
-    if let Some(validator) = &synthetic_validator {
-        info!("Running rejection data migration...");
-        if let Err(e) = validator.migrate_rejection_data().await {
-            error!("Failed to migrate rejection data: {}", e);
-            // Don't exit - this is not critical for startup
-        }
-    }
-
     // Start HTTP server with access to the validator
     let validator_for_server = synthetic_validator.clone();
     tokio::spawn(async move {

crates/validator/src/validators/synthetic_data/mod.rs

@@ -599,7 +599,7 @@ impl SyntheticDataValidator<WalletProvider> {
 
         if is_rejected {
             // Add to rejections set with current timestamp
-            let timestamp = chrono::Utc::now().timestamp() as f64;
+            let timestamp = chrono::Utc::now().timestamp();
             let _: () = con
                 .zadd(rejection_set_key, work_key, timestamp)
                 .await
@@ -1425,153 +1425,6 @@ impl SyntheticDataValidator<WalletProvider> {
 
         Ok(rejections)
     }
-
-    /// Idempotent migration of old rejection data to new optimized format.
-    /// Safe to run multiple times - uses migration marker to avoid duplicate work.
-    pub async fn migrate_rejection_data(&self) -> Result<(), Error> {
-        let migration_key = "rejection_migration_completed";
-        let mut con = self
-            .redis_store
-            .client
-            .get_multiplexed_async_connection()
-            .await?;
-
-        // Check if migration was already completed
-        let migration_completed: Option<String> = con
-            .get(migration_key)
-            .await
-            .map_err(|e| Error::msg(format!("Failed to check migration status: {}", e)))?;
-
-        if migration_completed.is_some() {
-            debug!("Rejection data migration already completed, skipping");
-            return Ok(());
-        }
-
-        info!("Starting rejection data migration...");
-        warn!("Migration uses KEYS command - this is a one-time operation during startup");
-
-        // Get all work validation status keys
-        let keys: Vec<String> = con
-            .keys("work_validation_status:*")
-            .await
-            .map_err(|e| Error::msg(format!("Failed to get validation status keys: {}", e)))?;
-
-        if keys.is_empty() {
-            info!("No validation status keys found, migration completed");
-            // Still mark as completed
-            let completion_timestamp = chrono::Utc::now().to_rfc3339();
-            let _: () = con
-                .set(migration_key, &completion_timestamp)
-                .await
-                .map_err(|e| Error::msg(format!("Failed to mark migration complete: {}", e)))?;
-            return Ok(());
-        }
-
-        info!("Found {} validation status keys to check", keys.len());
-
-        // Process in batches to avoid overwhelming Redis
-        let batch_size = 100;
-        let mut migrated_count = 0;
-
-        for batch in keys.chunks(batch_size) {
-            // Batch fetch validation data
-            let validation_data: Vec<Option<String>> = con
-                .mget(batch)
-                .await
-                .map_err(|e| Error::msg(format!("Failed to batch get validation data: {}", e)))?;
-
-            // Process each key in this batch
-            for (i, key) in batch.iter().enumerate() {
-                if let Some(Some(data)) = validation_data.get(i) {
-                    if let Ok(validation_info) = self.parse_validation_data(data) {
-                        if validation_info.status == ValidationResult::Reject {
-                            let work_key =
-                                key.strip_prefix("work_validation_status:").unwrap_or(key);
-
-                            // Check if already in rejection set (idempotency)
-                            let exists: bool = con
-                                .zscore("work_rejections", work_key)
-                                .await
-                                .map(|score: Option<f64>| score.is_some())
-                                .unwrap_or(false);
-
-                            if !exists {
-                                // Add to rejection set with current timestamp
-                                let timestamp = chrono::Utc::now().timestamp() as f64;
-                                let _: () = con
-                                    .zadd("work_rejections", work_key, timestamp)
-                                    .await
-                                    .map_err(|e| {
-                                        Error::msg(format!("Failed to migrate rejection: {}", e))
-                                    })?;
-
-                                // Create rejection detail if reason exists (unlikely for old data)
-                                if let Some(reason) = &validation_info.reason {
-                                    let rejection_detail = serde_json::json!({
-                                        "reason": reason,
-                                        "timestamp": timestamp
-                                    });
-                                    let rejection_data_key =
-                                        format!("work_rejection_data:{}", work_key);
-                                    let _: () = con
-                                        .set(&rejection_data_key, rejection_detail.to_string())
-                                        .await
-                                        .map_err(|e| {
-                                            Error::msg(format!(
-                                                "Failed to set migrated rejection data: {}",
-                                                e
-                                            ))
-                                        })?;
-                                }
-
-                                migrated_count += 1;
-                            }
-                        }
-                    }
-                }
-            }
-
-            // Progress reporting and throttling
-            if migrated_count > 0 && migrated_count % 100 == 0 {
-                info!("Migration progress: {} rejections migrated", migrated_count);
-            }
-
-            // Small delay between batches to avoid overwhelming Redis
-            tokio::time::sleep(tokio::time::Duration::from_millis(5)).await;
-        }
-
-        // Mark migration as completed with timestamp
-        let completion_timestamp = chrono::Utc::now().to_rfc3339();
-        let _: () = con
-            .set(migration_key, &completion_timestamp)
-            .await
-            .map_err(|e| Error::msg(format!("Failed to mark migration complete: {}", e)))?;
-
-        info!(
-            "Rejection data migration completed: {} rejections migrated",
-            migrated_count
-        );
-        Ok(())
-    }
-
-    fn parse_validation_data(&self, data: &str) -> Result<WorkValidationInfo, Error> {
-        // Try to parse as WorkValidationInfo first (new format)
-        if let Ok(validation_info) = serde_json::from_str::<WorkValidationInfo>(data) {
-            Ok(validation_info)
-        } else {
-            // Fall back to old format (just ValidationResult)
-            match serde_json::from_str::<ValidationResult>(data) {
-                Ok(status) => Ok(WorkValidationInfo {
-                    status,
-                    reason: None,
-                }),
-                Err(e) => Err(Error::msg(format!(
-                    "Failed to parse validation data: {}",
-                    e
-                ))),
-            }
-        }
-    }
 }
 
 impl SyntheticDataValidator<WalletProvider> {
@@ -3106,95 +2959,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[tokio::test]
-    async fn test_migration_idempotency() -> Result<(), Error> {
-        let (store, contracts) = setup_test_env()?;
-        let mock_storage = MockStorageProvider::new();
-        let storage_provider = Arc::new(mock_storage);
-        let validator = SyntheticDataValidator::new(
-            "0".to_string(),
-            contracts.synthetic_data_validator.unwrap(),
-            contracts.prime_network,
-            vec![],
-            U256::from(0),
-            storage_provider,
-            store,
-            CancellationToken::new(),
-            10,
-            60,
-            1,
-            10,
-            false,
-            false,
-            0,
-            None,
-        );
-
-        // Create some old-format rejection data manually
-        let mut con = validator
-            .redis_store
-            .client
-            .get_multiplexed_async_connection()
-            .await?;
-
-        // Old format: just ValidationResult enum
-        let _: () = con
-            .set("work_validation_status:old_reject_1", "\"Reject\"")
-            .await?;
-        let _: () = con
-            .set("work_validation_status:old_reject_2", "\"Reject\"")
-            .await?;
-        let _: () = con
-            .set("work_validation_status:old_accept_1", "\"Accept\"")
-            .await?;
-
-        // Run migration first time
-        validator.migrate_rejection_data().await?;
-
-        // Check rejections were migrated
-        let rejections_first = validator.get_all_rejections().await?;
-        assert_eq!(rejections_first.len(), 2);
-
-        let rejection_keys: Vec<&str> = rejections_first
-            .iter()
-            .map(|r| r.work_key.as_str())
-            .collect();
-        assert!(rejection_keys.contains(&"old_reject_1"));
-        assert!(rejection_keys.contains(&"old_reject_2"));
-
-        // Run migration second time (should be idempotent)
-        validator.migrate_rejection_data().await?;
-
-        // Check rejections are still the same (no duplicates)
-        let rejections_second = validator.get_all_rejections().await?;
-        assert_eq!(rejections_second.len(), 2);
-
-        // Add some new rejection data in new format
-        validator
-            .update_work_validation_info(
-                "new_reject_1",
-                &WorkValidationInfo {
-                    status: ValidationResult::Reject,
-                    reason: Some("New rejection".to_string()),
-                },
-            )
-            .await?;
-
-        // Run migration third time (should skip already-migrated data)
-        validator.migrate_rejection_data().await?;
-
-        // Check we have all rejections (old + new)
-        let rejections_final = validator.get_all_rejections().await?;
-        assert_eq!(rejections_final.len(), 3);
-
-        // Verify the new rejection has a reason
-        let new_rejection = rejections_final
-            .iter()
-            .find(|r| r.work_key == "new_reject_1")
-            .expect("New rejection should exist");
-        assert_eq!(new_rejection.reason, Some("New rejection".to_string()));
-
-        Ok(())
-    }
 }