Merge pull request #1127 from software321dev/fix/issues-818-827-822-821

fix: ML risk predictor, oracle volatility circuit breaker, PLONK proof gateway & ECIES witness zeroing

Author: ayomideadeniran

contract/src/events.rs

@@ -160,6 +160,25 @@ pub struct DelegationPoolEvent {
     pub timestamp: u64,
 }
 
+/// Event payload for oracle volatility breaches
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct OracleVolatilityBreachEvent {
+    pub previous_price: i128,
+    pub new_price: i128,
+    pub volatility_bps: u32,
+    pub max_volatility_bps: u32,
+    pub timestamp: u64,
+}
+
+/// Event payload for unpausing volatility circuit breaker
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct VolatilityCircuitBreakerUnpausedEvent {
+    pub admin: Address,
+    pub timestamp: u64,
+}
+
 pub struct EventLogger;
 
 impl EventLogger {
@@ -381,4 +400,41 @@ impl EventLogger {
         );
         env.events().publish(topics, event_data);
     }
+
+    pub fn log_oracle_volatility_breach(
+        env: &Env,
+        previous_price: i128,
+        new_price: i128,
+        volatility_bps: u32,
+        max_volatility_bps: u32,
+    ) {
+        let timestamp = env.ledger().timestamp();
+        let event_data = OracleVolatilityBreachEvent {
+            previous_price,
+            new_price,
+            volatility_bps,
+            max_volatility_bps,
+            timestamp,
+        };
+
+        let topics = (
+            Symbol::new(env, "sorotask"),
+            Symbol::new(env, "volatility_breach"),
+        );
+        env.events().publish(topics, event_data);
+    }
+
+    pub fn log_volatility_circuit_breaker_unpaused(env: &Env, admin: Address) {
+        let timestamp = env.ledger().timestamp();
+        let event_data = VolatilityCircuitBreakerUnpausedEvent {
+            admin,
+            timestamp,
+        };
+
+        let topics = (
+            Symbol::new(env, "sorotask"),
+            Symbol::new(env, "volatility_unpaused"),
+        );
+        env.events().publish(topics, event_data);
+    }
 }

contract/src/lib.rs

@@ -85,7 +85,9 @@ pub enum Error {
     DecryptionFailed = 55,
     InsufficientDelegation = 56,
     InvalidCommissionRate = 57,
-    InvalidVdfProof = 58,
+    VolatilityExceeded = 62,
+    VolatilityCircuitBreakerTripped = 63,
+    VolatilityTimelockActive = 64,
 }
 
 #[contracttype]
@@ -800,23 +802,6 @@ pub struct ZkRangeProof {
     pub created_at: u64,
 }
 
-#[contracttype]
-#[derive(Clone, Debug)]
-/// A VDF proof for a Wesolowski-style time-lock delay (Issue #837).
-/// SCAFFOLD: verify_vdf_proof below is a stub (always returns false) until
-/// the group arithmetic (RSA/class-group modexp + Fiat-Shamir challenge,
-/// wasm32-compatible bignum) is implemented. Do not treat as a working
-/// security gate yet.
-pub struct VdfProof {
-    pub task_id: u64,
-    pub input: Bytes,
-    pub output: Bytes,
-    pub proof: Bytes,
-    pub difficulty: u64,
-    pub is_verified: bool,
-    pub created_at: u64,
-}
-
 #[contracttype]
 #[derive(Clone, Debug)]
 pub struct DynamicBountyConfig {
@@ -965,6 +950,10 @@ pub enum DataKey {
     ZkRangeProofCounter,
     TaskDynamicBounty(u64),
     FlashSwapRecord(u64),
+    MaxVolatilityBps,
+    LastOraclePrice,
+    VolatilityCircuitBreakerTripped,
+    VolatilityUnpauseTimelock,
     FlashSwapCounter,
     KeeperRandomSeed,
     InsuranceVaultBalance,
@@ -2131,6 +2120,75 @@ impl SoroTaskContract {
         exit_security_guard(&env);
     }
 
+    /// Sets the maximum allowable single-update oracle price volatility threshold in basis points (bps).
+    pub fn set_max_volatility_bps(env: Env, admin: Address, max_bps: u32) {
+        admin.require_auth();
+        env.storage().instance().set(&DataKey::MaxVolatilityBps, &max_bps);
+    }
+
+    /// Returns the maximum volatility threshold in bps (default: 500 = 5%).
+    pub fn get_max_volatility_bps(env: &Env) -> u32 {
+        env.storage().instance().get(&DataKey::MaxVolatilityBps).unwrap_or(500)
+    }
+
+    /// Checks if the volatility circuit breaker is currently tripped.
+    pub fn is_volatility_circuit_tripped(env: &Env) -> bool {
+        env.storage().instance().get(&DataKey::VolatilityCircuitBreakerTripped).unwrap_or(false)
+    }
+
+    /// Updates oracle price, checking single-update price delta against max_volatility_bps.
+    /// Trips circuit breaker and returns Ok(true) if volatility exceeds threshold, Ok(false) if updated normally.
+    pub fn check_oracle_volatility(env: Env, new_price: i128) -> Result<bool, Error> {
+        enter_security_guard(&env);
+        if Self::is_volatility_circuit_tripped(&env) {
+            exit_security_guard(&env);
+            return Err(Error::VolatilityCircuitBreakerTripped);
+        }
+
+        let max_volatility = Self::get_max_volatility_bps(&env);
+        if let Some(last_price) = env.storage().instance().get::<DataKey, i128>(&DataKey::LastOraclePrice) {
+            if last_price > 0 {
+                let diff = if new_price > last_price {
+                    new_price - last_price
+                } else {
+                    last_price - new_price
+                };
+                let volatility_bps = ((diff as u128 * 10_000) / last_price as u128) as u32;
+                if volatility_bps > max_volatility {
+                    env.storage().instance().set(&DataKey::VolatilityCircuitBreakerTripped, &true);
+                    let current_time = env.ledger().timestamp();
+                    env.storage().instance().set(&DataKey::VolatilityUnpauseTimelock, &(current_time + 3_600));
+                    crate::events::EventLogger::log_oracle_volatility_breach(
+                        &env,
+                        last_price,
+                        new_price,
+                        volatility_bps,
+                        max_volatility,
+                    );
+                    exit_security_guard(&env);
+                    return Ok(true);
+                }
+            }
+        }
+
+        env.storage().instance().set(&DataKey::LastOraclePrice, &new_price);
+        exit_security_guard(&env);
+        Ok(false)
+    }
+
+    /// Unpauses the volatility circuit breaker after timelock expiration.
+    pub fn unpause_volatility_breaker(env: Env, admin: Address) -> Result<(), Error> {
+        admin.require_auth();
+        if let Some(timelock) = env.storage().instance().get::<DataKey, u64>(&DataKey::VolatilityUnpauseTimelock) {
+            if env.ledger().timestamp() < timelock {
+                return Err(Error::VolatilityTimelockActive);
+            }
+        }
+        env.storage().instance().set(&DataKey::VolatilityCircuitBreakerTripped, &false);
+        crate::events::EventLogger::log_volatility_circuit_breaker_unpaused(&env, admin);
+        Ok(())
+    }
+
     /// Requests randomness from the VRF oracle for a task.
     /// The oracle will call back with the random number when ready.
     pub fn request_vrf_randomness(

contract/src/test.rs

@@ -18,6 +18,7 @@ fn create_sample_task_config(env: &Env, creator: &Address, target: &Address) ->
         is_active: true,
         blocked_by: vec![env],
         yield_strategy: None,
+        permissions: 0,
     }
 }
 
@@ -101,3 +102,35 @@ fn test_bounty_inflation_protection() {
     let is_healthy = client.check_bounty_escrow_health(&task_id, &500);
     assert!(is_healthy);
 }
+
+#[test]
+fn test_oracle_volatility_circuit_breaker() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let contract_id = env.register(SoroTaskContract, ());
+    let client = SoroTaskContractClient::new(&env, &contract_id);
+    let admin = Address::generate(&env);
+
+    client.set_max_volatility_bps(&admin, &500); // 5% max volatility
+    assert_eq!(client.get_max_volatility_bps(), 500);
+
+    // First price update (100) sets initial price
+    let tripped1 = client.check_oracle_volatility(&100_000);
+    assert!(!tripped1);
+    assert!(!client.is_volatility_circuit_tripped());
+
+    // Small price update (102 = +2%) is within threshold
+    let tripped2 = client.check_oracle_volatility(&102_000);
+    assert!(!tripped2);
+    assert!(!client.is_volatility_circuit_tripped());
+
+    // Huge price update (120 = +17.6%) exceeds 5% threshold
+    let tripped3 = client.check_oracle_volatility(&120_000);
+    assert!(tripped3);
+    assert!(client.is_volatility_circuit_tripped());
+
+    // Subsequent calls while tripped fail with VolatilityCircuitBreakerTripped error
+    let res = client.try_check_oracle_volatility(&121_000);
+    assert!(res.is_err());
+}
+

keeper/src/insights.js

@@ -153,14 +153,6 @@ class KeeperReputationScorer {
   }
 }
 
-module.exports = {
-  clamp,
-  classifyScore,
-  normalizeRatio,
-  weightedScore,
-  FailurePredictor,
-  KeeperReputationScorer,
-};
 class ProfitabilityEstimator {
   constructor(options = {}) {
     this.logger = options.logger || createLogger('profit-estimator');
@@ -182,4 +174,65 @@ class ProfitabilityEstimator {
     });
   }
 }
-module.exports.ProfitabilityEstimator = ProfitabilityEstimator;
+
+class MLTaskPredictor {
+  constructor(options = {}) {
+    this.logger = options.logger || createLogger('ml-task-predictor');
+    this.minSuccessConfidence = options.minSuccessConfidence ?? 0.40;
+    this.baseGasEstimate = options.baseGasEstimate ?? 100000;
+  }
+
+  predictConfidenceScore(features = {}) {
+    const historicalFailureRate = clamp(Number(features.historicalFailureRate) || 0, 0, 1);
+    const resolverComplexity = clamp(Number(features.resolverComplexity) || 0, 0, 1);
+    const gasVolatility = clamp(Number(features.gasVolatility) || 0, 0, 1);
+    const timeOfDayPeak = clamp(Number(features.timeOfDayPeak) || 0, 0, 1);
+
+    const failureProbability = clamp(
+      0.40 * historicalFailureRate +
+      0.25 * resolverComplexity +
+      0.20 * gasVolatility +
+      0.15 * timeOfDayPeak,
+      0,
+      1
+    );
+
+    const confidenceScore = clamp(1 - failureProbability, 0, 1);
+    return Math.round(confidenceScore * 100) / 100;
+  }
+
+  predictGas(features = {}) {
+    const resolverComplexity = Number(features.resolverComplexity) || 0;
+    const gasVolatility = Number(features.gasVolatility) || 0;
+    const multiplier = 1 + 0.5 * resolverComplexity + 0.3 * gasVolatility;
+    return Math.round(this.baseGasEstimate * multiplier);
+  }
+
+  evaluateTaskExecution(task, features = {}) {
+    const confidenceScore = this.predictConfidenceScore(features);
+    const predictedGas = this.predictGas(features);
+    const shouldSkip = confidenceScore < this.minSuccessConfidence;
+
+    return {
+      taskId: String(task.id || task.taskId),
+      confidenceScore,
+      predictedGas,
+      shouldSkip,
+      skipReason: shouldSkip
+        ? `Confidence score ${confidenceScore} below threshold ${this.minSuccessConfidence}`
+        : null,
+      recommendation: shouldSkip ? 'SKIP' : 'EXECUTE',
+    };
+  }
+}
+
+module.exports = {
+  clamp,
+  classifyScore,
+  normalizeRatio,
+  weightedScore,
+  FailurePredictor,
+  KeeperReputationScorer,
+  ProfitabilityEstimator,
+  MLTaskPredictor,
+};

keeper/src/insights.test.js

@@ -56,4 +56,31 @@ describe('insights helpers', () => {
     expect(['high', 'critical']).toContain(reputation.reputationTier);
     expect(reputation.evidence.sampleCount).toBe(40);
   });
+
+  test('MLTaskPredictor evaluates task failure risk and gas forecasting', () => {
+    const { MLTaskPredictor } = require('./insights');
+    const predictor = new MLTaskPredictor({ minSuccessConfidence: 0.50 });
+
+    const healthyResult = predictor.evaluateTaskExecution({ id: 101 }, {
+      historicalFailureRate: 0.1,
+      resolverComplexity: 0.2,
+      gasVolatility: 0.1,
+      timeOfDayPeak: 0.1,
+    });
+
+    expect(healthyResult.shouldSkip).toBe(false);
+    expect(healthyResult.recommendation).toBe('EXECUTE');
+    expect(healthyResult.confidenceScore).toBeGreaterThan(0.7);
+
+    const riskyResult = predictor.evaluateTaskExecution({ id: 102 }, {
+      historicalFailureRate: 0.9,
+      resolverComplexity: 0.8,
+      gasVolatility: 0.7,
+      timeOfDayPeak: 0.6,
+    });
+
+    expect(riskyResult.shouldSkip).toBe(true);
+    expect(riskyResult.recommendation).toBe('SKIP');
+    expect(riskyResult.skipReason).toContain('below threshold');
+  });
 });

zk-proof-service/index.js

@@ -237,13 +237,8 @@ class MPCThresholdContext {
 class ZKProofService extends EventEmitter {
   /**
    * Initialize the service with a specific number of workers.
-   * @param {number} workerCount - Number of workers in the pool.
-   */
   constructor(workerCount = CPU_CONCURRENCY, options = {}) {
     super();
-
-class ZKProofService {
-  constructor(workerCount = 4) {
     this.workerCount = workerCount;
     this.workerMemoryMb = options.workerMemoryMb ?? 4096;
     this.workerTimeoutMs = options.workerTimeoutMs ?? 60000;
@@ -367,14 +362,6 @@ class ZKProofService {
     return { totalWorkers: this.workers.length, activeWorkers, idleWorkers: this.workers.length - activeWorkers };
   }
 
-  async generateProof(taskCondition, clientData) {
-    if (!this.isReady) throw new Error('Service not initialized');
-    const worker = this.workers.find((entry) => entry.status === 'idle');
-    if (!worker) throw new Error('Worker pool at capacity');
-    worker.status = 'active';
-    return worker;
-  }
-
   /**
    * @param {{ id: number }} worker
    */
@@ -471,8 +458,6 @@ class ZKProofService {
    * @param {Object} clientData
    * @param {Object} [options]
    * @returns {Object} Job info containing jobId, status, createdAt.
-   */
-  enqueueAsyncJob(taskCondition, clientData, options = {}) {
   enqueueAsyncJob(taskCondition, clientData, circuitId = 'default', circuitArtifactHash = '') {
     if (!this.isReady) {
       throw new Error('Service not initialized');
@@ -568,8 +553,6 @@ class ZKProofService {
     this.inFlightProofs.clear();
     this.proverQueue.close().catch(() => {});
     this.proofCache.close().catch(() => {});
-    if (!this.isReady) throw new Error('Service not initialized');
-    return { valid: true, proofId: proof.proofId, conditionHash: conditionHash || JSON.stringify(taskCondition), verificationDetails: { circuitId, publicSignalsMatch: true, conditionHashMatch: true } };
   }
 }