imp(validator): ability to pick invalidation type for rejection (#542)

* ability to pick invalidation type for rejection

Author: JannikSt

crates/validator/Dockerfile

@@ -42,6 +42,8 @@ $([ "$DISABLE_TOPLOC_INVALIDATION" = "true" ] && echo "--disable-toploc-invalida
 $([ ! -z "$INCOMPLETE_GROUP_GRACE_PERIOD_MINUTES" ] && echo "--incomplete-group-grace-period-minutes $INCOMPLETE_GROUP_GRACE_PERIOD_MINUTES") \
 $([ ! -z "$VALIDATOR_PENALTY" ] && echo "--validator-penalty $VALIDATOR_PENALTY") \
 $([ "$DISABLE_HARDWARE_VALIDATION" = "true" ] && echo "--disable-hardware-validation") \
+$([ ! -z "$TOPLOC_INVALIDATION_TYPE" ] && echo "--toploc-invalidation-type $TOPLOC_INVALIDATION_TYPE") \
+$([ ! -z "$WORK_UNIT_INVALIDATION_TYPE" ] && echo "--work-unit-invalidation-type $WORK_UNIT_INVALIDATION_TYPE") \
 "$@"' > /entrypoint.sh && \
 chmod +x /entrypoint.sh
 

crates/validator/src/main.rs

@@ -31,6 +31,7 @@ use url::Url;
 use validators::hardware::HardwareValidator;
 use validators::synthetic_data::SyntheticDataValidator;
 
+use crate::validators::synthetic_data::types::InvalidationType;
 // Track the last time the validation loop ran
 static LAST_VALIDATION_TIMESTAMP: AtomicI64 = AtomicI64::new(0);
 // Maximum allowed time between validation loops (2 minutes)
@@ -179,6 +180,14 @@ struct Args {
     #[arg(long, default_value = "0")]
     incomplete_group_grace_period_minutes: u64,
 
+    /// Optional: toploc invalidation type
+    #[arg(long, default_value = "hard")]
+    toploc_invalidation_type: InvalidationType,
+
+    /// Optional: work unit invalidation type
+    #[arg(long, default_value = "hard")]
+    work_unit_invalidation_type: InvalidationType,
+
     /// Optional: Validator penalty in whole tokens
     /// Note: This value will be multiplied by 10^18 (1 token = 10^18 wei)
     #[arg(long, default_value = "200")]
@@ -359,6 +368,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     args.use_grouping,
                     args.disable_toploc_invalidation,
                     args.incomplete_group_grace_period_minutes,
+                    args.toploc_invalidation_type,
+                    args.work_unit_invalidation_type,
                     Some(metrics_ctx.clone()),
                 ))
             }

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

@@ -0,0 +1,99 @@
+use super::*;
+
+impl SyntheticDataValidator<WalletProvider> {
+    pub async fn soft_invalidate_work(&self, work_key: &str) -> Result<(), Error> {
+        info!("Soft invalidating work: {}", work_key);
+
+        if self.disable_chain_invalidation {
+            info!("Chain invalidation is disabled, skipping work soft invalidation");
+            return Ok(());
+        }
+
+        // Special case for tests - skip actual blockchain interaction
+        #[cfg(test)]
+        {
+            info!("Test mode: skipping actual work soft invalidation");
+            let _ = &self.prime_network;
+            Ok(())
+        }
+
+        #[cfg(not(test))]
+        {
+            let work_info = self
+                .get_work_info_from_redis(work_key)
+                .await?
+                .ok_or_else(|| Error::msg("Work info not found for soft invalidation"))?;
+            let work_key_bytes = hex::decode(work_key)
+                .map_err(|e| Error::msg(format!("Failed to decode hex work key: {}", e)))?;
+
+            // Create 64-byte payload: work_key (32 bytes) + work_units (32 bytes)
+            let mut data = Vec::with_capacity(64);
+            data.extend_from_slice(&work_key_bytes);
+
+            // Convert work_units to 32-byte representation
+            let work_units_bytes = work_info.work_units.to_be_bytes::<32>();
+            data.extend_from_slice(&work_units_bytes);
+
+            match self
+                .prime_network
+                .soft_invalidate_work(self.pool_id, data)
+                .await
+            {
+                Ok(_) => Ok(()),
+                Err(e) => {
+                    error!("Failed to soft invalidate work {}: {}", work_key, e);
+                    Err(Error::msg(format!("Failed to soft invalidate work: {}", e)))
+                }
+            }
+        }
+    }
+
+    pub async fn invalidate_work(&self, work_key: &str) -> Result<(), Error> {
+        info!("Invalidating work: {}", work_key);
+
+        if let Some(metrics) = &self.metrics {
+            metrics.record_work_key_invalidation();
+        }
+
+        if self.disable_chain_invalidation {
+            info!("Chain invalidation is disabled, skipping work invalidation");
+            return Ok(());
+        }
+
+        #[cfg(test)]
+        {
+            info!("Test mode: skipping actual work invalidation");
+            let _ = &self.prime_network;
+            let _ = &self.penalty;
+            Ok(())
+        }
+
+        #[cfg(not(test))]
+        {
+            let data = hex::decode(work_key)
+                .map_err(|e| Error::msg(format!("Failed to decode hex work key: {}", e)))?;
+            match self
+                .prime_network
+                .invalidate_work(self.pool_id, self.penalty, data)
+                .await
+            {
+                Ok(_) => Ok(()),
+                Err(e) => {
+                    error!("Failed to invalidate work {}: {}", work_key, e);
+                    Err(Error::msg(format!("Failed to invalidate work: {}", e)))
+                }
+            }
+        }
+    }
+
+    pub async fn invalidate_according_to_invalidation_type(
+        &self,
+        work_key: &str,
+        invalidation_type: InvalidationType,
+    ) -> Result<(), Error> {
+        match invalidation_type {
+            InvalidationType::Soft => self.soft_invalidate_work(work_key).await,
+            InvalidationType::Hard => self.invalidate_work(work_key).await,
+        }
+    }
+}