Implementing Stablecoin Oracle Manipulation Protection: Chainlink VRF Integration

// contracts/oracles/EnhancedOracleAggregator.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * @title EnhancedOracleAggregator
 * @dev Multi-source oracle aggregator with manipulation protection
 */
contract EnhancedOracleAggregator is AccessControl, ReentrancyGuard {
    
    bytes32 public constant ORACLE_ADMIN_ROLE = keccak256("ORACLE_ADMIN_ROLE");
    bytes32 public constant EMERGENCY_ROLE = keccak256("EMERGENCY_ROLE");
    
    // Oracle source configuration
    struct OracleSource {
        address oracle;
        uint256 weight;           // Weight in aggregation (basis points)
        uint256 maxDeviation;    // Maximum allowed deviation from median
        uint256 heartbeat;       // Maximum time between updates
        bool isActive;
        string sourceType;       // "chainlink", "uniswap", "twap", etc.
    }
    
    // Price data structure
    struct PriceData {
        uint256 price;
        uint256 timestamp;
        uint256 confidence;
        address source;
    }
    
    // Manipulation detection parameters
    struct ManipulationConfig {
        uint256 maxPriceDeviation;     // Maximum price change per block (basis points)
        uint256 outlierThreshold;      // Standard deviations for outlier detection
        uint256 minimumSources;        // Minimum number of sources required
        uint256 confidenceThreshold;   // Minimum confidence score required
        bool manipulationDetectionEnabled;
    }
    
    ManipulationConfig public manipulationConfig;
    
    // Oracle sources registry
    mapping(uint256 => OracleSource) public oracleSources;
    uint256 public sourceCount;
    
    // Price history for trend analysis
    PriceData[] public priceHistory;
    uint256 public constant MAX_HISTORY_LENGTH = 100;
    
    // Current aggregated price data
    PriceData public currentPrice;
    
    // Manipulation detection state
    bool public manipulationDetected;
    uint256 public lastManipulationBlock;
    string public lastManipulationReason;
    
    // Events
    event PriceUpdated(uint256 indexed price, uint256 confidence, uint256 sourceCount);
    event ManipulationDetected(string reason, uint256 blockNumber, uint256 suspiciousPrice);
    event OracleSourceAdded(uint256 indexed sourceId, address oracle, string sourceType);

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(ORACLE_ADMIN_ROLE, msg.sender);
        _grantRole(EMERGENCY_ROLE, msg.sender);
        
        // Set initial manipulation detection parameters
        manipulationConfig = ManipulationConfig({
            maxPriceDeviation: 500,        // 5% max change per block
            outlierThreshold: 2,           // 2 standard deviations
            minimumSources: 3,             // Require at least 3 sources
            confidenceThreshold: 8000,     // 80% confidence minimum
            manipulationDetectionEnabled: true
        });
    }

    /**
     * @dev Add a new oracle source
     */
    function addOracleSource(
        address oracle,
        uint256 weight,
        uint256 maxDeviation,
        uint256 heartbeat,
        string memory sourceType
    ) external onlyRole(ORACLE_ADMIN_ROLE) {
        require(oracle != address(0), "Invalid oracle address");
        require(weight > 0 && weight <= 10000, "Invalid weight");
        
        oracleSources[sourceCount] = OracleSource({
            oracle: oracle,
            weight: weight,
            maxDeviation: maxDeviation,
            heartbeat: heartbeat,
            isActive: true,
            sourceType: sourceType
        });
        
        emit OracleSourceAdded(sourceCount, oracle, sourceType);
        sourceCount++;
    }

    /**
     * @dev Get aggregated price with manipulation protection
     */
    function getPrice() external view returns (uint256 price, uint256 confidence) {
        require(!manipulationDetected, "Price manipulation detected - using emergency mode");
        require(currentPrice.timestamp > 0, "No price data available");
        require(
            block.timestamp - currentPrice.timestamp <= _getMaxHeartbeat(),
            "Price data too stale"
        );
        
        return (currentPrice.price, currentPrice.confidence);
    }

    /**
     * @dev Update aggregated price from all sources
     */
    function updatePrice() external nonReentrant {
        PriceData[] memory sourcePrices = new PriceData[](sourceCount);
        uint256 validSourceCount = 0;
        
        // Collect prices from all active sources
        for (uint256 i = 0; i < sourceCount; i++) {
            if (!oracleSources[i].isActive) continue;
            
            (bool success, PriceData memory priceData) = _getPriceFromSource(i);
            if (success) {
                sourcePrices[validSourceCount] = priceData;
                validSourceCount++;
            }
        }
        
        require(
            validSourceCount >= manipulationConfig.minimumSources,
            "Insufficient valid price sources"
        );
        
        // Detect manipulation before aggregation
        if (manipulationConfig.manipulationDetectionEnabled) {
            _detectManipulation(sourcePrices, validSourceCount);
        }
        
        // Aggregate prices using weighted median with outlier filtering
        (uint256 aggregatedPrice, uint256 confidence) = _aggregatePrices(sourcePrices, validSourceCount);
        
        // Update current price
        currentPrice = PriceData({
            price: aggregatedPrice,
            timestamp: block.timestamp,
            confidence: confidence,
            source: address(this)
        });
        
        // Store in history
        _updatePriceHistory(currentPrice);
        
        emit PriceUpdated(aggregatedPrice, confidence, validSourceCount);
    }

    /**
     * @dev Detect price manipulation across sources
     */
    function _detectManipulation(PriceData[] memory sourcePrices, uint256 validCount) internal {
        if (validCount < 2) return;
        
        // Calculate median and standard deviation
        (uint256 median, uint256 standardDeviation) = _calculateStatistics(sourcePrices, validCount);
        
        // Check for outliers
        uint256 outlierCount = 0;
        for (uint256 i = 0; i < validCount; i++) {
            uint256 deviation = sourcePrices[i].price > median 
                ? sourcePrices[i].price - median 
                : median - sourcePrices[i].price;
            
            if (deviation > standardDeviation * manipulationConfig.outlierThreshold) {
                outlierCount++;
            }
        }
        
        // Trigger manipulation detection if too many outliers
        if (outlierCount > validCount / 3) { // More than 1/3 are outliers
            _triggerManipulationDetection("Too many price outliers detected");
            return;
        }
        
        // Check for sudden price changes
        if (priceHistory.length > 0) {
            uint256 lastPrice = priceHistory[priceHistory.length - 1].price;
            uint256 priceChange = median > lastPrice ? median - lastPrice : lastPrice - median;
            uint256 percentChange = (priceChange * 10000) / lastPrice;
            
            if (percentChange > manipulationConfig.maxPriceDeviation) {
                _triggerManipulationDetection("Sudden price change detected");
                return;
            }
        }
    }

    /**
     * @dev Aggregate prices using weighted median
     */
    function _aggregatePrices(PriceData[] memory sourcePrices, uint256 validCount) 
        internal 
        view 
        returns (uint256 aggregatedPrice, uint256 confidence) 
    {
        // Sort prices
        _sortPricesByValue(sourcePrices, validCount);
        
        // Calculate weighted median
        uint256 totalWeight = 0;
        for (uint256 i = 0; i < validCount; i++) {
            totalWeight += _getSourceWeight(sourcePrices[i].source);
        }
        
        uint256 targetWeight = totalWeight / 2;
        uint256 cumulativeWeight = 0;
        
        for (uint256 i = 0; i < validCount; i++) {
            uint256 weight = _getSourceWeight(sourcePrices[i].source);
            cumulativeWeight += weight;
            
            if (cumulativeWeight >= targetWeight) {
                aggregatedPrice = sourcePrices[i].price;
                break;
            }
        }
        
        // Calculate confidence score
        confidence = _calculateAggregateConfidence(sourcePrices, validCount);
    }

    // Helper functions
    function _triggerManipulationDetection(string memory reason) internal {
        manipulationDetected = true;
        lastManipulationBlock = block.number;
        lastManipulationReason = reason;
        
        emit ManipulationDetected(reason, block.number, currentPrice.price);
    }

    function _calculateStatistics(PriceData[] memory prices, uint256 count) 
        internal 
        pure 
        returns (uint256 median, uint256 standardDeviation) 
    {
        // Simplified statistical calculations for gas efficiency
        uint256[] memory sortedPrices = new uint256[](count);
        for (uint256 i = 0; i < count; i++) {
            sortedPrices[i] = prices[i].price;
        }
        
        // Sort and calculate median
        _quickSort(sortedPrices, 0, int256(count - 1));
        median = count % 2 == 0 ? 
            (sortedPrices[count / 2 - 1] + sortedPrices[count / 2]) / 2 :
            sortedPrices[count / 2];
        
        // Calculate standard deviation
        uint256 variance = 0;
        for (uint256 i = 0; i < count; i++) {
            uint256 diff = sortedPrices[i] > median ? 
                sortedPrices[i] - median : median - sortedPrices[i];
            variance += diff * diff;
        }
        variance /= count;
        standardDeviation = _sqrt(variance);
    }

    function _sqrt(uint256 x) internal pure returns (uint256 result) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        result = x;
        while (z < result) {
            result = z;
            z = (x / z + z) / 2;
        }
    }

    function _quickSort(uint256[] memory arr, int256 left, int256 right) internal pure {
        if (left < right) {
            int256 pivotIndex = _partition(arr, left, right);
            _quickSort(arr, left, pivotIndex - 1);
            _quickSort(arr, pivotIndex + 1, right);
        }
    }

    function _partition(uint256[] memory arr, int256 left, int256 right) internal pure returns (int256) {
        uint256 pivot = arr[uint256(right)];
        int256 i = left - 1;
        
        for (int256 j = left; j < right; j++) {
            if (arr[uint256(j)] <= pivot) {
                i++;
                (arr[uint256(i)], arr[uint256(j)]) = (arr[uint256(j)], arr[uint256(i)]);
            }
        }
        
        (arr[uint256(i + 1)], arr[uint256(right)]) = (arr[uint256(right)], arr[uint256(i + 1)]);
        return i + 1;
    }

    // Additional helper functions for price aggregation
    function _getSourceWeight(address source) internal view returns (uint256) {
        for (uint256 i = 0; i < sourceCount; i++) {
            if (oracleSources[i].oracle == source) {
                return oracleSources[i].weight;
            }
        }
        return 0;
    }

    function _getMaxHeartbeat() internal view returns (uint256) {
        uint256 maxHeartbeat = 0;
        for (uint256 i = 0; i < sourceCount; i++) {
            if (oracleSources[i].isActive && oracleSources[i].heartbeat > maxHeartbeat) {
                maxHeartbeat = oracleSources[i].heartbeat;
            }
        }
        return maxHeartbeat;
    }

    function _calculateAggregateConfidence(PriceData[] memory sourcePrices, uint256 validCount) 
        internal 
        pure 
        returns (uint256) 
    {
        uint256 totalConfidence = 0;
        for (uint256 i = 0; i < validCount; i++) {
            totalConfidence += sourcePrices[i].confidence;
        }
        return totalConfidence / validCount;
    }

    function _updatePriceHistory(PriceData memory newPrice) internal {
        priceHistory.push(newPrice);
        if (priceHistory.length > MAX_HISTORY_LENGTH) {
            for (uint256 i = 0; i < MAX_HISTORY_LENGTH - 1; i++) {
                priceHistory[i] = priceHistory[i + 1];
            }
            priceHistory.pop();
        }
    }

    function _sortPricesByValue(PriceData[] memory prices, uint256 count) internal pure {
        for (uint256 i = 0; i < count - 1; i++) {
            for (uint256 j = 0; j < count - i - 1; j++) {
                if (prices[j].price > prices[j + 1].price) {
                    PriceData memory temp = prices[j];
                    prices[j] = prices[j + 1];
                    prices[j + 1] = temp;
                }
            }
        }
    }

    function _getPriceFromSource(uint256 sourceId) 
        internal 
        view 
        returns (bool success, PriceData memory priceData) 
    {
        OracleSource storage source = oracleSources[sourceId];
        
        // Implementation would call specific oracle type
        // This is simplified for brevity
        return (true, PriceData({
            price: 1 * 10**18, // $1.00
            timestamp: block.timestamp,
            confidence: 9000,
            source: source.oracle
        }));
    }
}

// contracts/oracles/VRFOracleValidator.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

/**
 * @title VRFOracleValidator
 * @dev Uses Chainlink VRF to randomize oracle validation checks
 */
contract VRFOracleValidator is VRFConsumerBaseV2, AccessControl {
    
    VRFCoordinatorV2Interface COORDINATOR;
    
    bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
    
    // VRF configuration
    uint64 public subscriptionId;
    bytes32 public keyHash;
    uint32 public callbackGasLimit = 100000;
    uint16 public requestConfirmations = 3;
    uint32 public numWords = 1;
    
    // Validation configuration
    struct ValidationConfig {
        uint256 validationProbability;  // Probability of deep validation (basis points)
        uint256 randomCheckWindow;      // Random time window for validation
        uint256 minimumValidationGap;   // Minimum time between validations
        bool vrfValidationEnabled;
    }
    
    ValidationConfig public validationConfig;
    
    // VRF request tracking
    mapping(uint256 => ValidationRequest) public validationRequests;
    
    struct ValidationRequest {
        uint256 timestamp;
        uint256 priceAtRequest;
        address requester;
        bool fulfilled;
        uint256 randomResult;
    }
    
    // Validation state
    uint256 public lastValidationTime;
    uint256 public pendingValidationRequests;
    
    // Events
    event ValidationRequested(uint256 indexed requestId, uint256 priceAtRequest);
    event ValidationCompleted(uint256 indexed requestId, uint256 randomResult, bool validationTriggered);
    event DeepValidationTriggered(uint256 randomSeed, uint256 priceValidated);

    constructor(
        uint64 _subscriptionId,
        address _vrfCoordinator,
        bytes32 _keyHash
    ) VRFConsumerBaseV2(_vrfCoordinator) {
        COORDINATOR = VRFCoordinatorV2Interface(_vrfCoordinator);
        subscriptionId = _subscriptionId;
        keyHash = _keyHash;
        
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(VALIDATOR_ROLE, msg.sender);
        
        validationConfig = ValidationConfig({
            validationProbability: 1000,      // 10% chance
            randomCheckWindow: 300,           // 5 minutes
            minimumValidationGap: 900,        // 15 minutes minimum gap
            vrfValidationEnabled: true
        });
    }

    /**
     * @dev Request VRF-based validation check
     */
    function requestValidation(uint256 currentPrice) 
        external 
        onlyRole(VALIDATOR_ROLE) 
        returns (uint256 requestId) 
    {
        require(validationConfig.vrfValidationEnabled, "VRF validation disabled");
        require(
            block.timestamp - lastValidationTime >= validationConfig.minimumValidationGap,
            "Validation too frequent"
        );
        
        // Request randomness from Chainlink VRF
        requestId = COORDINATOR.requestRandomWords(
            keyHash,
            subscriptionId,
            requestConfirmations,
            callbackGasLimit,
            numWords
        );
        
        validationRequests[requestId] = ValidationRequest({
            timestamp: block.timestamp,
            priceAtRequest: currentPrice,
            requester: msg.sender,
            fulfilled: false,
            randomResult: 0
        });
        
        pendingValidationRequests++;
        emit ValidationRequested(requestId, currentPrice);
        
        return requestId;
    }

    /**
     * @dev VRF callback function
     */
    function fulfillRandomWords(
        uint256 requestId,
        uint256[] memory randomWords
    ) internal override {
        ValidationRequest storage request = validationRequests[requestId];
        require(!request.fulfilled, "Request already fulfilled");
        
        request.fulfilled = true;
        request.randomResult = randomWords[0];
        pendingValidationRequests--;
        
        // Determine if deep validation should be triggered
        bool shouldValidate = _shouldTriggerDeepValidation(randomWords[0]);
        
        if (shouldValidate) {
            _triggerDeepValidation(randomWords[0], request.priceAtRequest);
        }
        
        emit ValidationCompleted(requestId, randomWords[0], shouldValidate);
    }

    /**
     * @dev Determine if random result should trigger deep validation
     */
    function _shouldTriggerDeepValidation(uint256 randomResult) internal view returns (bool) {
        uint256 probability = randomResult % 10000; // 0-9999
        return probability < validationConfig.validationProbability;
    }

    /**
     * @dev Trigger deep validation with random seed
     */
    function _triggerDeepValidation(uint256 randomSeed, uint256 priceToValidate) internal {
        lastValidationTime = block.timestamp;
        
        // Use random seed to determine validation method
        uint256 validationMethod = randomSeed % 4;
        
        if (validationMethod == 0) {
            _performHistoricalComparisonValidation(priceToValidate);
        } else if (validationMethod == 1) {
            _performCrossSourceValidation(priceToValidate);
        } else if (validationMethod == 2) {
            _performVolumeWeightedValidation(priceToValidate);
        } else {
            _performArbitrageOpportunityValidation(priceToValidate);
        }
        
        emit DeepValidationTriggered(randomSeed, priceToValidate);
    }

    function _performHistoricalComparisonValidation(uint256 currentPrice) internal {
        // Compare against historical price trends
        // Implementation would check moving averages and volatility
    }

    function _performCrossSourceValidation(uint256 currentPrice) internal {
        // Validate against independent external sources
        // Implementation would query CEX APIs or alternative oracles
    }

    function _performVolumeWeightedValidation(uint256 currentPrice) internal {
        // Validate price against trading volume
        // Implementation would check volume-price correlation
    }

    function _performArbitrageOpportunityValidation(uint256 currentPrice) internal {
        // Check for unrealistic arbitrage opportunities
        // Implementation would compare across DEXes
    }
}

// contracts/oracles/ManipulationDetectionEngine.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/AccessControl.sol";

/**
 * @title ManipulationDetectionEngine
 * @dev Advanced real-time detection of oracle manipulation attempts
 */
contract ManipulationDetectionEngine is AccessControl {
    
    bytes32 public constant DETECTOR_ROLE = keccak256("DETECTOR_ROLE");
    
    // Detection algorithms configuration
    struct DetectionConfig {
        uint256 priceVelocityThreshold;    // Max price change per second
        uint256 volumeAnomalyThreshold;    // Volume spike threshold
        uint256 liquidityDropThreshold;    // Liquidity drop threshold
        uint256 correlationThreshold;      // Cross-asset correlation threshold
        bool realTimeDetectionEnabled;
    }
    
    DetectionConfig public detectionConfig;
    
    // Price monitoring data
    struct PricePoint {
        uint256 price;
        uint256 timestamp;
        uint256 volume;
        uint256 liquidity;
        address source;
    }
    
    // Detection alert structure
    struct DetectionAlert {
        uint256 timestamp;
        string alertType;
        uint256 severity;
        uint256 priceAtAlert;
        string description;
        bool resolved;
    }
    
    // Ring buffer for price history
    PricePoint[] public priceHistory;
    uint256 public historyIndex;
    uint256 public constant MAX_HISTORY_SIZE = 200;
    
    DetectionAlert[] public detectionAlerts;
    
    // Events
    event ManipulationAlertRaised(
        string indexed alertType, 
        uint256 severity, 
        uint256 priceAtAlert,
        string description
    );

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(DETECTOR_ROLE, msg.sender);
        
        detectionConfig = DetectionConfig({
            priceVelocityThreshold: 100,       // 1% per second max
            volumeAnomalyThreshold: 500,       // 5x normal volume
            liquidityDropThreshold: 3000,      // 30% liquidity drop
            correlationThreshold: 200,         // 2% correlation break
            realTimeDetectionEnabled: true
        });
        
        priceHistory = new PricePoint[](MAX_HISTORY_SIZE);
    }

    /**
     * @dev Process new price data and run detection algorithms
     */
    function processPriceUpdate(
        uint256 price,
        uint256 volume,
        uint256 liquidity,
        address source
    ) external onlyRole(DETECTOR_ROLE) {
        require(detectionConfig.realTimeDetectionEnabled, "Detection disabled");
        
        PricePoint memory newPoint = PricePoint({
            price: price,
            timestamp: block.timestamp,
            volume: volume,
            liquidity: liquidity,
            source: source
        });
        
        priceHistory[historyIndex] = newPoint;
        historyIndex = (historyIndex + 1) % MAX_HISTORY_SIZE;
        
        _runManipulationDetection(newPoint);
    }

    function _runManipulationDetection(PricePoint memory currentPoint) internal {
        _detectPriceVelocityAnomaly(currentPoint);
        _detectVolumeAnomaly(currentPoint);
        _detectLiquidityManipulation(currentPoint);
    }

    function _detectPriceVelocityAnomaly(PricePoint memory currentPoint) internal {
        if (_getPriceHistoryLength() < 2) return;
        
        uint256 prevIndex = historyIndex == 0 ? MAX_HISTORY_SIZE - 1 : historyIndex - 1;
        PricePoint memory prevPoint = priceHistory[prevIndex];
        
        if (prevPoint.timestamp == 0) return;
        
        uint256 timeDiff = currentPoint.timestamp - prevPoint.timestamp;
        if (timeDiff == 0) return;
        
        uint256 priceChange = currentPoint.price > prevPoint.price ?
            currentPoint.price - prevPoint.price :
            prevPoint.price - currentPoint.price;
        
        uint256 priceChangePercent = (priceChange * 10000) / prevPoint.price;
        uint256 velocityPerSecond = priceChangePercent / timeDiff;
        
        if (velocityPerSecond > detectionConfig.priceVelocityThreshold) {
            _raiseAlert(
                "PRICE_VELOCITY_ANOMALY",
                8,
                currentPoint.price,
                "Abnormal price velocity detected"
            );
        }
    }

    function _detectVolumeAnomaly(PricePoint memory currentPoint) internal {
        if (_getPriceHistoryLength() < 10) return;
        
        uint256 averageVolume = _calculateAverageVolume(10);
        if (averageVolume == 0) return;
        
        uint256 volumeRatio = (currentPoint.volume * 100) / averageVolume;
        
        if (volumeRatio > detectionConfig.volumeAnomalyThreshold) {
            _raiseAlert(
                "VOLUME_SPIKE_ANOMALY",
                6,
                currentPoint.price,
                "Volume spike detected"
            );
        }
    }

    function _detectLiquidityManipulation(PricePoint memory currentPoint) internal {
        if (_getPriceHistoryLength() < 5) return;
        
        uint256 averageLiquidity = _calculateAverageLiquidity(5);
        if (averageLiquidity == 0) return;
        
        uint256 liquidityDrop = averageLiquidity > currentPoint.liquidity ?
            ((averageLiquidity - currentPoint.liquidity) * 10000) / averageLiquidity :
            0;
        
        if (liquidityDrop > detectionConfig.liquidityDropThreshold) {
            _raiseAlert(
                "LIQUIDITY_MANIPULATION",
                9,
                currentPoint.price,
                "Liquidity drop detected"
            );
        }
    }

    function _raiseAlert(
        string memory alertType,
        uint256 severity,
        uint256 priceAtAlert,
        string memory description
    ) internal {
        detectionAlerts.push(DetectionAlert({
            timestamp: block.timestamp,
            alertType: alertType,
            severity: severity,
            priceAtAlert: priceAtAlert,
            description: description,
            resolved: false
        }));
        
        emit ManipulationAlertRaised(alertType, severity, priceAtAlert, description);
    }

    function _getPriceHistoryLength() internal view returns (uint256) {
        uint256 count = 0;
        for (uint256 i = 0; i < MAX_HISTORY_SIZE; i++) {
            if (priceHistory[i].timestamp > 0) count++;
        }
        return count;
    }

    function _calculateAverageVolume(uint256 periods) internal view returns (uint256) {
        uint256 sum = 0;
        uint256 count = 0;
        
        for (uint256 i = 0; i < periods && i < MAX_HISTORY_SIZE; i++) {
            uint256 idx = (historyIndex + MAX_HISTORY_SIZE - i - 1) % MAX_HISTORY_SIZE;
            if (priceHistory[idx].timestamp > 0) {
                sum += priceHistory[idx].volume;
                count++;
            }
        }
        
        return count > 0 ? sum / count : 0;
    }

    function _calculateAverageLiquidity(uint256 periods) internal view returns (uint256) {
        uint256 sum = 0;
        uint256 count = 0;
        
        for (uint256 i = 0; i < periods && i < MAX_HISTORY_SIZE; i++) {
            uint256 idx = (historyIndex + MAX_HISTORY_SIZE - i - 1) % MAX_HISTORY_SIZE;
            if (priceHistory[idx].timestamp > 0) {
                sum += priceHistory[idx].liquidity;
                count++;
            }
        }
        
        return count > 0 ? sum / count : 0;
    }

    function getRecentAlerts(uint256 timeWindow) 
        external 
        view 
        returns (DetectionAlert[] memory recentAlerts) 
    {
        uint256 cutoffTime = block.timestamp - timeWindow;
        uint256 recentCount = 0;
        
        for (uint256 i = detectionAlerts.length; i > 0; i--) {
            if (detectionAlerts[i - 1].timestamp >= cutoffTime) {
                recentCount++;
            } else {
                break;
            }
        }
        
        recentAlerts = new DetectionAlert[](recentCount);
        uint256 index = 0;
        
        for (uint256 i = detectionAlerts.length; i > 0 && index < recentCount; i--) {
            if (detectionAlerts[i - 1].timestamp >= cutoffTime) {
                recentAlerts[index] = detectionAlerts[i - 1];
                index++;
            }
        }
    }
}

// contracts/oracles/OracleCircuitBreaker.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/AccessControl.sol";
import "./ManipulationDetectionEngine.sol";

/**
 * @title OracleCircuitBreaker
 * @dev Automated circuit breaker system for oracle manipulation protection
 */
contract OracleCircuitBreaker is AccessControl {
    
    bytes32 public constant BREAKER_ROLE = keccak256("BREAKER_ROLE");
    bytes32 public constant EMERGENCY_ROLE = keccak256("EMERGENCY_ROLE");
    
    ManipulationDetectionEngine public detectionEngine;
    address public pausableContract;
    
    // Circuit breaker configuration
    struct BreakerConfig {
        uint256 alertThreshold;         // Number of alerts to trigger breaker
        uint256 severityThreshold;      // Minimum severity to trigger
        uint256 timeWindow;            // Time window for alert accumulation
        uint256 cooldownPeriod;        // Cooldown before reset
        bool autoTriggerEnabled;
    }
    
    BreakerConfig public breakerConfig;
    
    // Breaker state
    bool public isTriggered;
    uint256 public triggerTime;
    string public triggerReason;
    
    // Events
    event CircuitBreakerTriggered(string reason, uint256 alertCount, uint256 timestamp);
    event CircuitBreakerReset(address indexed resetter, uint256 timestamp);

    constructor(address _detectionEngine, address _pausableContract) {
        detectionEngine = ManipulationDetectionEngine(_detectionEngine);
        pausableContract = _pausableContract;
        
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(BREAKER_ROLE, msg.sender);
        _grantRole(EMERGENCY_ROLE, msg.sender);
        
        breakerConfig = BreakerConfig({
            alertThreshold: 3,          // 3 alerts trigger breaker
            severityThreshold: 6,       // Minimum severity 6
            timeWindow: 300,            // 5 minutes
            cooldownPeriod: 3600,       // 1 hour cooldown
            autoTriggerEnabled: true
        });
    }

    function processNewAlerts() external {
        require(breakerConfig.autoTriggerEnabled, "Auto-trigger disabled");
        
        ManipulationDetectionEngine.DetectionAlert[] memory recentAlerts = 
            detectionEngine.getRecentAlerts(breakerConfig.timeWindow);
        
        uint256 alertCount = 0;
        for (uint256 i = 0; i < recentAlerts.length; i++) {
            if (recentAlerts[i].severity >= breakerConfig.severityThreshold) {
                alertCount++;
            }
        }
        
        if (alertCount >= breakerConfig.alertThreshold && !isTriggered) {
            _triggerCircuitBreaker("Multiple high-severity alerts", alertCount);
        }
    }

    function _triggerCircuitBreaker(string memory reason, uint256 alertCount) internal {
        isTriggered = true;
        triggerTime = block.timestamp;
        triggerReason = reason;
        
        // Call emergency pause on connected contract
        (bool success,) = pausableContract.call(abi.encodeWithSignature("emergencyPause()"));
        require(success, "Failed to trigger emergency pause");
        
        emit CircuitBreakerTriggered(reason, alertCount, block.timestamp);
    }

    function resetCircuitBreaker() external onlyRole(BREAKER_ROLE) {
        require(isTriggered, "Circuit breaker not triggered");
        require(
            block.timestamp >= triggerTime + breakerConfig.cooldownPeriod,
            "Cooldown period not met"
        );
        
        isTriggered = false;
        triggerTime = 0;
        triggerReason = "";
        
        emit CircuitBreakerReset(msg.sender, block.timestamp);
    }
}