How to Implement Stablecoin Circuit Breakers: Emergency Pause Mechanisms

// Common circuit breaker failure patterns I've observed
interface CircuitBreakerFailure {
  protocol: string;
  failure_type: string;
  time_to_exploit: number; // seconds
  damage: number; // USD
  root_cause: string;
}

const historicalFailures: CircuitBreakerFailure[] = [
  {
    protocol: "Protocol A",
    failure_type: "Manual trigger too slow",
    time_to_exploit: 480, // 8 minutes
    damage: 50000000,
    root_cause: "Required human intervention during attack"
  },
  {
    protocol: "Protocol B", 
    failure_type: "Threshold set too high",
    time_to_exploit: 180, // 3 minutes
    damage: 25000000,
    root_cause: "Circuit breaker only triggered after 20% loss"
  },
  {
    protocol: "Protocol C",
    failure_type: "Single point of failure",
    time_to_exploit: 90, // 1.5 minutes
    damage: 15000000,
    root_cause: "Attacker disabled circuit breaker first"
  }
];

// contracts/security/EnhancedPausable.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Address.sol";

/**
 * @title EnhancedPausable
 * @dev Extended pausable contract with multiple pause levels and automated triggers
 */
contract EnhancedPausable is Pausable, AccessControl {
    using Address for address;

    // Role definitions
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    bytes32 public constant EMERGENCY_ROLE = keccak256("EMERGENCY_ROLE");
    bytes32 public constant CIRCUIT_BREAKER_ROLE = keccak256("CIRCUIT_BREAKER_ROLE");

    // Pause levels for granular control
    enum PauseLevel {
        NONE,           // Normal operation
        PARTIAL,        // Pause risky functions only
        FULL,           // Pause all functions
        EMERGENCY       // Emergency shutdown
    }

    PauseLevel public currentPauseLevel;
    
    // Function-specific pause states
    mapping(bytes4 => bool) public functionPaused;
    
    // Automated circuit breaker settings
    struct CircuitBreakerConfig {
        uint256 maxTransactionValue;
        uint256 maxHourlyVolume; 
        uint256 maxDailyVolume;
        uint256 priceDeviationThreshold; // basis points
        bool enabled;
    }
    
    CircuitBreakerConfig public circuitBreakerConfig;
    
    // Volume tracking for circuit breakers
    mapping(uint256 => uint256) public hourlyVolume; // hour timestamp => volume
    mapping(uint256 => uint256) public dailyVolume;  // day timestamp => volume
    
    // Events
    event PauseLevelChanged(PauseLevel oldLevel, PauseLevel newLevel, address indexed changer);
    event FunctionPaused(bytes4 indexed functionSelector, bool paused);
    event CircuitBreakerTriggered(string reason, uint256 value, address indexed trigger);
    event VolumeThresholdExceeded(string period, uint256 volume, uint256 threshold);

    modifier whenNotPausedLevel(PauseLevel level) {
        require(currentPauseLevel < level, "EnhancedPausable: function paused at current level");
        _;
    }

    modifier whenFunctionNotPaused() {
        require(!functionPaused[msg.sig], "EnhancedPausable: function specifically paused");
        _;
    }

    modifier circuitBreakerCheck(uint256 transactionValue) {
        if (circuitBreakerConfig.enabled) {
            _checkCircuitBreakers(transactionValue);
        }
        _;
    }

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(PAUSER_ROLE, msg.sender);
        _grantRole(EMERGENCY_ROLE, msg.sender);
        
        // Set conservative default circuit breaker values
        circuitBreakerConfig = CircuitBreakerConfig({
            maxTransactionValue: 1000000 * 10**18, // $1M in tokens
            maxHourlyVolume: 10000000 * 10**18,    // $10M per hour
            maxDailyVolume: 50000000 * 10**18,     // $50M per day
            priceDeviationThreshold: 500,          // 5%
            enabled: true
        });
    }

    /**
     * @dev Sets the pause level with proper access control
     */
    function setPauseLevel(PauseLevel newLevel) external {
        if (newLevel == PauseLevel.EMERGENCY) {
            require(hasRole(EMERGENCY_ROLE, msg.sender), "EnhancedPausable: emergency role required");
        } else {
            require(hasRole(PAUSER_ROLE, msg.sender), "EnhancedPausable: pauser role required");
        }

        PauseLevel oldLevel = currentPauseLevel;
        currentPauseLevel = newLevel;

        // Update the base Pausable state
        if (newLevel >= PauseLevel.FULL && !paused()) {
            _pause();
        } else if (newLevel < PauseLevel.FULL && paused()) {
            _unpause();
        }

        emit PauseLevelChanged(oldLevel, newLevel, msg.sender);
    }

    /**
     * @dev Pause/unpause specific functions
     */
    function setFunctionPaused(bytes4 functionSelector, bool isPaused) 
        external 
        onlyRole(PAUSER_ROLE) 
    {
        functionPaused[functionSelector] = isPaused;
        emit FunctionPaused(functionSelector, isPaused);
    }

    /**
     * @dev Emergency pause with immediate effect
     */
    function emergencyPause() external onlyRole(EMERGENCY_ROLE) {
        currentPauseLevel = PauseLevel.EMERGENCY;
        _pause();
        emit PauseLevelChanged(currentPauseLevel, PauseLevel.EMERGENCY, msg.sender);
        emit CircuitBreakerTriggered("Emergency pause activated", 0, msg.sender);
    }

    /**
     * @dev Internal circuit breaker logic
     */
    function _checkCircuitBreakers(uint256 transactionValue) internal {
        // Check transaction size limit
        if (transactionValue > circuitBreakerConfig.maxTransactionValue) {
            _triggerCircuitBreaker("Transaction value exceeded", transactionValue);
            return;
        }

        // Check hourly volume limit
        uint256 currentHour = block.timestamp / 3600;
        hourlyVolume[currentHour] += transactionValue;
        
        if (hourlyVolume[currentHour] > circuitBreakerConfig.maxHourlyVolume) {
            _triggerCircuitBreaker("Hourly volume exceeded", hourlyVolume[currentHour]);
            return;
        }

        // Check daily volume limit  
        uint256 currentDay = block.timestamp / 86400;
        dailyVolume[currentDay] += transactionValue;
        
        if (dailyVolume[currentDay] > circuitBreakerConfig.maxDailyVolume) {
            _triggerCircuitBreaker("Daily volume exceeded", dailyVolume[currentDay]);
            return;
        }
    }

    /**
     * @dev Trigger circuit breaker with automatic pause
     */
    function _triggerCircuitBreaker(string memory reason, uint256 value) internal {
        currentPauseLevel = PauseLevel.FULL;
        _pause();
        
        emit CircuitBreakerTriggered(reason, value, address(this));
        emit PauseLevelChanged(PauseLevel.NONE, PauseLevel.FULL, address(this));
    }

    /**
     * @dev Update circuit breaker configuration
     */
    function updateCircuitBreakerConfig(
        uint256 _maxTransactionValue,
        uint256 _maxHourlyVolume,
        uint256 _maxDailyVolume,
        uint256 _priceDeviationThreshold,
        bool _enabled
    ) external onlyRole(DEFAULT_ADMIN_ROLE) {
        circuitBreakerConfig.maxTransactionValue = _maxTransactionValue;
        circuitBreakerConfig.maxHourlyVolume = _maxHourlyVolume;
        circuitBreakerConfig.maxDailyVolume = _maxDailyVolume;
        circuitBreakerConfig.priceDeviationThreshold = _priceDeviationThreshold;
        circuitBreakerConfig.enabled = _enabled;
    }

    /**
     * @dev Check if a specific function is callable at current pause level
     */
    function isFunctionCallable(bytes4 functionSelector) external view returns (bool) {
        if (functionPaused[functionSelector]) {
            return false;
        }
        
        // Add function-specific pause level logic here
        // For example, minting might be paused at PARTIAL level
        return true;
    }
}

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./security/EnhancedPausable.sol";
import "./interfaces/IPriceOracle.sol";

contract StablecoinWithCircuitBreakers is ERC20, EnhancedPausable {
    
    // Role for minting operations
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
    
    // Oracle for price monitoring
    IPriceOracle public priceOracle;
    uint256 public lastPriceCheckTimestamp;
    uint256 public referencePriceUSD; // 1e18 = $1.00
    
    // Collateral tracking
    mapping(address => uint256) public collateralBalances;
    uint256 public totalCollateral;
    
    // Events
    event Mint(address indexed to, uint256 amount, uint256 collateralAmount);
    event Burn(address indexed from, uint256 amount, uint256 collateralReturned);
    event CollateralDeposited(address indexed user, uint256 amount);
    event PriceDeviationDetected(uint256 currentPrice, uint256 referencePrice, uint256 deviation);

    constructor(
        string memory name,
        string memory symbol,
        address _priceOracle
    ) ERC20(name, symbol) EnhancedPausable() {
        priceOracle = IPriceOracle(_priceOracle);
        referencePriceUSD = 1e18; // $1.00
        lastPriceCheckTimestamp = block.timestamp;
        
        _grantRole(MINTER_ROLE, msg.sender);
        _grantRole(BURNER_ROLE, msg.sender);
    }

    /**
     * @dev Mint new stablecoins with comprehensive circuit breaker checks
     */
    function mint(address to, uint256 amount, uint256 collateralAmount) 
        external 
        onlyRole(MINTER_ROLE)
        whenNotPausedLevel(PauseLevel.PARTIAL)
        whenFunctionNotPaused()
        circuitBreakerCheck(amount)
    {
        // Check price stability before minting
        _checkPriceStability();
        
        // Verify sufficient collateral
        require(
            _isCollateralSufficient(amount, collateralAmount),
            "Insufficient collateral"
        );
        
        // Update collateral tracking
        collateralBalances[to] += collateralAmount;
        totalCollateral += collateralAmount;
        
        // Mint tokens
        _mint(to, amount);
        
        emit Mint(to, amount, collateralAmount);
        emit CollateralDeposited(to, collateralAmount);
    }

    /**
     * @dev Burn stablecoins with collateral return
     */
    function burn(uint256 amount) 
        external 
        whenNotPausedLevel(PauseLevel.FULL)
        whenFunctionNotPaused()
        circuitBreakerCheck(amount)
    {
        require(balanceOf(msg.sender) >= amount, "Insufficient balance");
        
        // Calculate collateral to return
        uint256 collateralToReturn = _calculateCollateralReturn(msg.sender, amount);
        
        // Update tracking
        collateralBalances[msg.sender] -= collateralToReturn;
        totalCollateral -= collateralToReturn;
        
        // Burn tokens
        _burn(msg.sender, amount);
        
        emit Burn(msg.sender, amount, collateralToReturn);
    }

    /**
     * @dev Emergency withdrawal function (only when paused)
     */
    function emergencyWithdraw() 
        external 
        whenPaused
    {
        uint256 userBalance = balanceOf(msg.sender);
        require(userBalance > 0, "No balance to withdraw");
        
        uint256 collateralToReturn = collateralBalances[msg.sender];
        
        // Clear user's position
        collateralBalances[msg.sender] = 0;
        totalCollateral -= collateralToReturn;
        
        // Burn user's tokens
        _burn(msg.sender, userBalance);
        
        // Return collateral (implementation depends on collateral type)
        _returnCollateral(msg.sender, collateralToReturn);
        
        emit Burn(msg.sender, userBalance, collateralToReturn);
    }

    /**
     * @dev Check price stability and trigger circuit breaker if needed
     */
    function _checkPriceStability() internal {
        // Only check price every 5 minutes to avoid gas waste
        if (block.timestamp - lastPriceCheckTimestamp < 300) {
            return;
        }
        
        uint256 currentPrice = priceOracle.getPrice();
        lastPriceCheckTimestamp = block.timestamp;
        
        // Calculate price deviation
        uint256 deviation;
        if (currentPrice > referencePriceUSD) {
            deviation = ((currentPrice - referencePriceUSD) * 10000) / referencePriceUSD;
        } else {
            deviation = ((referencePriceUSD - currentPrice) * 10000) / referencePriceUSD;
        }
        
        // Trigger circuit breaker if deviation exceeds threshold
        if (deviation > circuitBreakerConfig.priceDeviationThreshold) {
            _triggerCircuitBreaker("Price deviation exceeded", deviation);
            emit PriceDeviationDetected(currentPrice, referencePriceUSD, deviation);
        }
    }

    /**
     * @dev Check if provided collateral is sufficient for minting
     */
    function _isCollateralSufficient(uint256 mintAmount, uint256 collateralAmount) 
        internal 
        view 
        returns (bool) 
    {
        // Require 150% collateralization ratio
        uint256 requiredCollateral = (mintAmount * 15) / 10;
        return collateralAmount >= requiredCollateral;
    }

    /**
     * @dev Calculate collateral to return for burning
     */
    function _calculateCollateralReturn(address user, uint256 burnAmount) 
        internal 
        view 
        returns (uint256) 
    {
        uint256 userBalance = balanceOf(user);
        uint256 userCollateral = collateralBalances[user];
        
        // Proportional return based on burn amount
        return (userCollateral * burnAmount) / userBalance;
    }

    /**
     * @dev Return collateral to user (implementation depends on collateral type)
     */
    function _returnCollateral(address user, uint256 amount) internal {
        // Implementation depends on collateral token
        // This could be ETH transfer, ERC20 transfer, etc.
    }

    /**
     * @dev Admin function to manually trigger circuit breaker
     */
    function manualCircuitBreakerTrigger(string memory reason) 
        external 
        onlyRole(EMERGENCY_ROLE) 
    {
        _triggerCircuitBreaker(reason, 0);
    }

    /**
     * @dev Get current collateralization ratio
     */
    function getCollateralizationRatio() external view returns (uint256) {
        if (totalSupply() == 0) return type(uint256).max;
        return (totalCollateral * 100) / totalSupply();
    }
}

// contracts/monitoring/AutomatedCircuitBreaker.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 "../interfaces/IStablecoinWithCircuitBreakers.sol";

contract AutomatedCircuitBreaker is AccessControl {
    
    bytes32 public constant MONITOR_ROLE = keccak256("MONITOR_ROLE");
    bytes32 public constant KEEPER_ROLE = keccak256("KEEPER_ROLE");
    
    IStablecoinWithCircuitBreakers public stablecoin;
    AggregatorV3Interface public priceFeed;
    
    // Monitoring parameters
    struct MonitoringConfig {
        uint256 priceDeviationThreshold;     // basis points (100 = 1%)
        uint256 volumeSpikeFactor;           // multiplier for normal volume
        uint256 liquidityDropThreshold;     // percentage drop
        uint256 checkInterval;              // seconds between checks
        bool automatedTriggersEnabled;
    }
    
    MonitoringConfig public config;
    
    // Historical data for anomaly detection
    struct HistoricalData {
        uint256[] hourlyVolumes;     // last 24 hours
        uint256[] prices;            // last 100 price points
        uint256 averageHourlyVolume;
        uint256 averagePrice;
        uint256 lastUpdateTimestamp;
    }
    
    HistoricalData public historicalData;
    
    // Circuit breaker state
    mapping(string => bool) public triggerActive;
    mapping(string => uint256) public triggerCount;
    
    // Events
    event AutomatedTriggerActivated(string triggerType, uint256 value, uint256 threshold);
    event AnomalyDetected(string anomalyType, uint256 severity, uint256 timestamp);
    event MonitoringConfigUpdated(MonitoringConfig newConfig);

    constructor(
        address _stablecoin,
        address _priceFeed
    ) {
        stablecoin = IStablecoinWithCircuitBreakers(_stablecoin);
        priceFeed = AggregatorV3Interface(_priceFeed);
        
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MONITOR_ROLE, msg.sender);
        _grantRole(KEEPER_ROLE, msg.sender);
        
        // Set default monitoring configuration
        config = MonitoringConfig({
            priceDeviationThreshold: 200,    // 2%
            volumeSpikeFactor: 5,            // 5x normal volume
            liquidityDropThreshold: 30,      // 30% liquidity drop
            checkInterval: 300,              // 5 minutes
            automatedTriggersEnabled: true
        });
        
        // Initialize historical data arrays
        historicalData.hourlyVolumes = new uint256[](24);
        historicalData.prices = new uint256[](100);
        historicalData.lastUpdateTimestamp = block.timestamp;
    }

    /**
     * @dev Main monitoring function called by Chainlink Keepers
     */
    function performUpkeep(bytes calldata /* performData */) external onlyRole(KEEPER_ROLE) {
        if (!config.automatedTriggersEnabled) return;
        
        // Update historical data
        _updateHistoricalData();
        
        // Run all monitoring checks
        _checkPriceAnomaly();
        _checkVolumeAnomaly();
        _checkLiquidityAnomaly();
        _checkCollateralizationRatio();
        _checkOracleHealth();
    }

    /**
     * @dev Check if automated circuit breaker should be triggered
     */
    function checkUpkeep(bytes calldata /* checkData */) 
        external 
        view 
        returns (bool upkeepNeeded, bytes memory /* performData */) 
    {
        upkeepNeeded = (block.timestamp - historicalData.lastUpdateTimestamp) >= config.checkInterval;
    }

    /**
     * @dev Check for price anomalies
     */
    function _checkPriceAnomaly() internal {
        (, int256 price, , uint256 updatedAt, ) = priceFeed.latestRoundData();
        require(price > 0, "Invalid price");
        require(block.timestamp - updatedAt < 3600, "Stale price data");
        
        uint256 currentPrice = uint256(price);
        
        // Check deviation from $1.00 (assuming 8 decimal oracle)
        uint256 targetPrice = 1e8; // $1.00
        uint256 deviation;
        
        if (currentPrice > targetPrice) {
            deviation = ((currentPrice - targetPrice) * 10000) / targetPrice;
        } else {
            deviation = ((targetPrice - currentPrice) * 10000) / targetPrice;
        }
        
        if (deviation > config.priceDeviationThreshold) {
            _activateTrigger("price_deviation", deviation, config.priceDeviationThreshold);
        }
        
        // Store price for historical analysis
        _updatePriceHistory(currentPrice);
    }

    /**
     * @dev Check for volume anomalies
     */
    function _checkVolumeAnomaly() internal {
        uint256 currentHourlyVolume = _getCurrentHourlyVolume();
        
        if (historicalData.averageHourlyVolume > 0) {
            uint256 volumeRatio = currentHourlyVolume / historicalData.averageHourlyVolume;
            
            if (volumeRatio > config.volumeSpikeFactor) {
                _activateTrigger("volume_spike", volumeRatio, config.volumeSpikeFactor);
            }
        }
        
        // Update historical volume data
        _updateVolumeHistory(currentHourlyVolume);
    }

    /**
     * @dev Check collateralization ratio health
     */
    function _checkCollateralizationRatio() internal {
        uint256 collateralizationRatio = stablecoin.getCollateralizationRatio();
        
        // Trigger if collateralization drops below 120%
        if (collateralizationRatio < 120) {
            _activateTrigger("low_collateralization", collateralizationRatio, 120);
        }
    }

    /**
     * @dev Check oracle health and freshness
     */
    function _checkOracleHealth() internal {
        (, , , uint256 updatedAt, ) = priceFeed.latestRoundData();
        
        // Trigger if oracle data is more than 1 hour old
        if (block.timestamp - updatedAt > 3600) {
            _activateTrigger("stale_oracle", block.timestamp - updatedAt, 3600);
        }
    }

    /**
     * @dev Activate circuit breaker trigger
     */
    function _activateTrigger(
        string memory triggerType, 
        uint256 value, 
        uint256 threshold
    ) internal {
        if (triggerActive[triggerType]) {
            return; // Already triggered
        }
        
        triggerActive[triggerType] = true;
        triggerCount[triggerType]++;
        
        // Trigger emergency pause on stablecoin contract
        try stablecoin.emergencyPause() {
            emit AutomatedTriggerActivated(triggerType, value, threshold);
        } catch {
            // Log failed trigger attempt
            emit AnomalyDetected(triggerType, value, block.timestamp);
        }
    }

    /**
     * @dev Update historical price data for trend analysis
     */
    function _updatePriceHistory(uint256 currentPrice) internal {
        // Shift array and add new price
        for (uint i = historicalData.prices.length - 1; i > 0; i--) {
            historicalData.prices[i] = historicalData.prices[i-1];
        }
        historicalData.prices[0] = currentPrice;
        
        // Recalculate average
        uint256 sum = 0;
        for (uint i = 0; i < historicalData.prices.length; i++) {
            sum += historicalData.prices[i];
        }
        historicalData.averagePrice = sum / historicalData.prices.length;
    }

    /**
     * @dev Update historical volume data
     */
    function _updateVolumeHistory(uint256 currentVolume) internal {
        uint256 currentHour = block.timestamp / 3600;
        uint256 arrayIndex = currentHour % 24;
        
        historicalData.hourlyVolumes[arrayIndex] = currentVolume;
        
        // Recalculate average hourly volume
        uint256 sum = 0;
        for (uint i = 0; i < 24; i++) {
            sum += historicalData.hourlyVolumes[i];
        }
        historicalData.averageHourlyVolume = sum / 24;
    }

    /**
     * @dev Get current hourly volume from stablecoin contract
     */
    function _getCurrentHourlyVolume() internal view returns (uint256) {
        uint256 currentHour = block.timestamp / 3600;
        return stablecoin.hourlyVolume(currentHour);
    }

    /**
     * @dev Update all historical data
     */
    function _updateHistoricalData() internal {
        historicalData.lastUpdateTimestamp = block.timestamp;
    }

    /**
     * @dev Check for liquidity anomalies (implementation depends on DEX integration)
     */
    function _checkLiquidityAnomaly() internal {
        // Implementation would check DEX liquidity levels
        // This is protocol-specific based on where liquidity is provided
    }

    /**
     * @dev Reset trigger state (only callable by admin)
     */
    function resetTrigger(string memory triggerType) external onlyRole(DEFAULT_ADMIN_ROLE) {
        triggerActive[triggerType] = false;
    }

    /**
     * @dev Update monitoring configuration
     */
    function updateMonitoringConfig(MonitoringConfig memory newConfig) 
        external 
        onlyRole(DEFAULT_ADMIN_ROLE) 
    {
        config = newConfig;
        emit MonitoringConfigUpdated(newConfig);
    }

    /**
     * @dev Emergency manual trigger
     */
    function manualTrigger(string memory reason) external onlyRole(MONITOR_ROLE) {
        stablecoin.manualCircuitBreakerTrigger(reason);
        emit AutomatedTriggerActivated("manual", 0, 0);
    }
}

// scripts/setup-chainlink-keeper.js
const { ethers } = require("hardhat");

async function setupChainlinkKeeper() {
    const [deployer] = await ethers.getSigners();
    
    // Deploy the automated circuit breaker
    const AutomatedCircuitBreaker = await ethers.getContractFactory("AutomatedCircuitBreaker");
    const circuitBreaker = await AutomatedCircuitBreaker.deploy(
        process.env.STABLECOIN_ADDRESS,
        process.env.CHAINLINK_PRICE_FEED
    );
    
    await circuitBreaker.deployed();
    console.log("Automated Circuit Breaker deployed to:", circuitBreaker.address);
    
    // Register with Chainlink Keeper Network
    const keeperRegistryInterface = new ethers.utils.Interface([
        "function registerUpkeep(address target, uint32 gasLimit, address admin, bytes calldata checkData, bytes calldata offchainConfig) external returns (uint256 id)"
    ]);
    
    const keeperRegistry = new ethers.Contract(
        process.env.CHAINLINK_KEEPER_REGISTRY,
        keeperRegistryInterface,
        deployer
    );
    
    // Register upkeep with 500k gas limit
    const tx = await keeperRegistry.registerUpkeep(
        circuitBreaker.address,
        500000, // gas limit
        deployer.address, // admin
        "0x", // check data
        "0x"  // offchain config
    );
    
    console.log("Chainlink Keeper registration transaction:", tx.hash);
    
    // Grant KEEPER_ROLE to Chainlink Keeper network
    const keeperRole = await circuitBreaker.KEEPER_ROLE();
    await circuitBreaker.grantRole(keeperRole, process.env.CHAINLINK_KEEPER_ADDRESS);
    
    console.log("Setup complete. Circuit breaker will be monitored by Chainlink Keepers.");
}

setupChainlinkKeeper()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });

// contracts/security/GraduatedCircuitBreaker.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./EnhancedPausable.sol";

contract GraduatedCircuitBreaker is EnhancedPausable {
    
    // Threat levels with corresponding responses
    enum ThreatLevel {
        GREEN,      // Normal operation
        YELLOW,     // Elevated monitoring
        ORANGE,     // Restricted operations
        RED,        // Emergency pause
        BLACK       // Complete shutdown
    }
    
    ThreatLevel public currentThreatLevel;
    
    // Response configurations for each threat level
    struct ThreatResponse {
        uint256 maxTransactionSize;
        uint256 maxHourlyVolume;
        uint256 minTimeBetweenLargeTransactions; // seconds
        bool mintingPaused;
        bool burningSaused;
        bool transfersPaused;
        bool emergencyWithdrawalsOnly;
    }
    
    mapping(ThreatLevel => ThreatResponse) public threatResponses;
    
    // Transaction timing tracking
    mapping(address => uint256) public lastLargeTransaction;
    uint256 public constant LARGE_TRANSACTION_THRESHOLD = 100000 * 1e18; // $100k
    
    // Events
    event ThreatLevelChanged(ThreatLevel oldLevel, ThreatLevel newLevel, string reason);
    event TransactionRestricted(address user, uint256 amount, string reason);

    constructor() {
        _setupThreatResponses();
        currentThreatLevel = ThreatLevel.GREEN;
    }

    /**
     * @dev Setup default responses for each threat level
     */
    function _setupThreatResponses() internal {
        // GREEN: Normal operation
        threatResponses[ThreatLevel.GREEN] = ThreatResponse({
            maxTransactionSize: 10000000 * 1e18,    // $10M
            maxHourlyVolume: 100000000 * 1e18,      // $100M
            minTimeBetweenLargeTransactions: 0,
            mintingPaused: false,
            burningSaused: false,
            transfersPaused: false,
            emergencyWithdrawalsOnly: false
        });
        
        // YELLOW: Elevated monitoring
        threatResponses[ThreatLevel.YELLOW] = ThreatResponse({
            maxTransactionSize: 5000000 * 1e18,     // $5M
            maxHourlyVolume: 50000000 * 1e18,       // $50M
            minTimeBetweenLargeTransactions: 300,    // 5 minutes
            mintingPaused: false,
            burningSaused: false,
            transfersPaused: false,
            emergencyWithdrawalsOnly: false
        });
        
        // ORANGE: Restricted operations
        threatResponses[ThreatLevel.ORANGE] = ThreatResponse({
            maxTransactionSize: 1000000 * 1e18,     // $1M
            maxHourlyVolume: 10000000 * 1e18,       // $10M
            minTimeBetweenLargeTransactions: 900,    // 15 minutes
            mintingPaused: true,
            burningSaused: false,
            transfersPaused: false,
            emergencyWithdrawalsOnly: false
        });
        
        // RED: Emergency pause
        threatResponses[ThreatLevel.RED] = ThreatResponse({
            maxTransactionSize: 100000 * 1e18,      // $100k
            maxHourlyVolume: 1000000 * 1e18,        // $1M
            minTimeBetweenLargeTransactions: 3600,   // 1 hour
            mintingPaused: true,
            burningSaused: false,
            transfersPaused: true,
            emergencyWithdrawalsOnly: true
        });
        
        // BLACK: Complete shutdown
        threatResponses[ThreatLevel.BLACK] = ThreatResponse({
            maxTransactionSize: 0,
            maxHourlyVolume: 0,
            minTimeBetweenLargeTransactions: type(uint256).max,
            mintingPaused: true,
            burningSaused: true,
            transfersPaused: true,
            emergencyWithdrawalsOnly: true
        });
    }

    /**
     * @dev Escalate threat level based on detected anomalies
     */
    function escalateThreatLevel(ThreatLevel newLevel, string memory reason) 
        external 
        onlyRole(EMERGENCY_ROLE) 
    {
        require(newLevel > currentThreatLevel, "Can only escalate threat level");
        
        ThreatLevel oldLevel = currentThreatLevel;
        currentThreatLevel = newLevel;
        
        // Apply corresponding pause level
        PauseLevel pauseLevel = _threatToPauseLevel(newLevel);
        if (pauseLevel != currentPauseLevel) {
            _setPauseLevel(pauseLevel);
        }
        
        emit ThreatLevelChanged(oldLevel, newLevel, reason);
    }

    /**
     * @dev De-escalate threat level (requires multiple confirmations)
     */
    function deescalateThreatLevel(ThreatLevel newLevel, string memory reason) 
        external 
        onlyRole(DEFAULT_ADMIN_ROLE) 
    {
        require(newLevel < currentThreatLevel, "Can only de-escalate threat level");
        
        // Implement time delay for de-escalation
        // In production, this would require multiple admin confirmations
        
        ThreatLevel oldLevel = currentThreatLevel;
        currentThreatLevel = newLevel;
        
        PauseLevel pauseLevel = _threatToPauseLevel(newLevel);
        if (pauseLevel != currentPauseLevel) {
            _setPauseLevel(pauseLevel);
        }
        
        emit ThreatLevelChanged(oldLevel, newLevel, reason);
    }

    /**
     * @dev Check if transaction is allowed under current threat level
     */
    function isTransactionAllowed(
        address user,
        uint256 amount,
        bytes4 functionSelector
    ) external view returns (bool allowed, string memory reason) {
        ThreatResponse memory response = threatResponses[currentThreatLevel];
        
        // Check transaction size limit
        if (amount > response.maxTransactionSize) {
            return (false, "Transaction size exceeds limit for current threat level");
        }
        
        // Check function-specific restrictions
        if (functionSelector == bytes4(keccak256("mint(address,uint256,uint256)"))) {
            if (response.mintingPaused) {
                return (false, "Minting paused due to elevated threat level");
            }
        }
        
        if (functionSelector == bytes4(keccak256("burn(uint256)"))) {
            if (response.burningSaused) {
                return (false, "Burning paused due to elevated threat level");
            }
        }
        
        if (functionSelector == bytes4(keccak256("transfer(address,uint256)"))) {
            if (response.transfersPaused) {
                return (false, "Transfers paused due to elevated threat level");
            }
        }
        
        // Check timing restrictions for large transactions
        if (amount >= LARGE_TRANSACTION_THRESHOLD) {
            uint256 timeSinceLastLarge = block.timestamp - lastLargeTransaction[user];
            if (timeSinceLastLarge < response.minTimeBetweenLargeTransactions) {
                return (false, "Large transaction cooldown period not met");
            }
        }
        
        return (true, "");
    }

    /**
     * @dev Convert threat level to pause level
     */
    function _threatToPauseLevel(ThreatLevel threat) internal pure returns (PauseLevel) {
        if (threat == ThreatLevel.GREEN || threat == ThreatLevel.YELLOW) {
            return PauseLevel.NONE;
        } else if (threat == ThreatLevel.ORANGE) {
            return PauseLevel.PARTIAL;
        } else if (threat == ThreatLevel.RED) {
            return PauseLevel.FULL;
        } else { // BLACK
            return PauseLevel.EMERGENCY;
        }
    }

    /**
     * @dev Update last large transaction timestamp
     */
    function _updateLargeTransactionTimestamp(address user, uint256 amount) internal {
        if (amount >= LARGE_TRANSACTION_THRESHOLD) {
            lastLargeTransaction[user] = block.timestamp;
        }
    }

    /**
     * @dev Auto-escalation based on multiple triggers
     */
    function checkAutoEscalation() external view returns (bool shouldEscalate, ThreatLevel newLevel) {
        // Implement logic to automatically escalate based on:
        // - Multiple circuit breaker triggers in short time
        // - Sustained high volume
        // - Price volatility
        // - Oracle health issues
        
        // This is a simplified example
        if (currentThreatLevel == ThreatLevel.GREEN) {
            // Check if we should move to YELLOW
            // Implementation would check various metrics
            return (false, currentThreatLevel);
        }
        
        return (false, currentThreatLevel);
    }
}

// contracts/security/CrossProtocolCircuitBreaker.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

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

/**
 * @title CrossProtocolCircuitBreaker
 * @dev Coordinates circuit breakers across multiple related protocols
 */
contract CrossProtocolCircuitBreaker is AccessControl {
    
    bytes32 public constant PROTOCOL_ROLE = keccak256("PROTOCOL_ROLE");
    bytes32 public constant COORDINATOR_ROLE = keccak256("COORDINATOR_ROLE");
    
    // Protocol registry
    struct ProtocolInfo {
        address contractAddress;
        string name;
        uint256 riskWeight;        // Higher weight = more important
        bool isActive;
        bool hasCircuitBreaker;
    }
    
    mapping(address => ProtocolInfo) public protocols;
    address[] public protocolAddresses;
    
    // Cross-protocol event tracking
    struct SecurityEvent {
        address protocol;
        string eventType;
        uint256 severity;      // 1-10 scale
        uint256 timestamp;
        bool resolved;
    }
    
    SecurityEvent[] public securityEvents;
    mapping(address => uint256[]) public protocolEvents; // protocol => event indices
    
    // Coordination rules
    struct CoordinationRule {
        uint256 severityThreshold;
        uint256 timeWindow;           // seconds
        uint256 minAffectedProtocols;
        bool autoTriggerEnabled;
        string responseType;          // "pause", "restrict", "alert"
    }
    
    mapping(string => CoordinationRule) public coordinationRules;
    
    // Events
    event SecurityEventReported(address indexed protocol, string eventType, uint256 severity);
    event CrossProtocolTriggerActivated(string triggerType, uint256 affectedProtocols);
    event ProtocolRegistered(address indexed protocol, string name);

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(COORDINATOR_ROLE, msg.sender);
        
        _setupDefaultRules();
    }

    /**
     * @dev Register a protocol with the coordination system
     */
    function registerProtocol(
        address protocolAddress,
        string memory name,
        uint256 riskWeight,
        bool hasCircuitBreaker
    ) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(protocolAddress != address(0), "Invalid protocol address");
        require(!protocols[protocolAddress].isActive, "Protocol already registered");
        
        protocols[protocolAddress] = ProtocolInfo({
            contractAddress: protocolAddress,
            name: name,
            riskWeight: riskWeight,
            isActive: true,
            hasCircuitBreaker: hasCircuitBreaker
        });
        
        protocolAddresses.push(protocolAddress);
        _grantRole(PROTOCOL_ROLE, protocolAddress);
        
        emit ProtocolRegistered(protocolAddress, name);
    }

    /**
     * @dev Report a security event from a protocol
     */
    function reportSecurityEvent(
        string memory eventType,
        uint256 severity,
        bytes memory additionalData
    ) external onlyRole(PROTOCOL_ROLE) {
        require(severity >= 1 && severity <= 10, "Invalid severity level");
        require(protocols[msg.sender].isActive, "Protocol not active");
        
        // Create security event
        SecurityEvent memory newEvent = SecurityEvent({
            protocol: msg.sender,
            eventType: eventType,
            severity: severity,
            timestamp: block.timestamp,
            resolved: false
        });
        
        securityEvents.push(newEvent);
        uint256 eventIndex = securityEvents.length - 1;
        protocolEvents[msg.sender].push(eventIndex);
        
        emit SecurityEventReported(msg.sender, eventType, severity);
        
        // Check if cross-protocol response should be triggered
        _checkCrossProtocolTriggers(eventType, severity);
    }

    /**
     * @dev Check if cross-protocol circuit breakers should be triggered
     */
    function _checkCrossProtocolTriggers(string memory eventType, uint256 severity) internal {
        CoordinationRule memory rule = coordinationRules[eventType];
        
        if (!rule.autoTriggerEnabled || severity < rule.severityThreshold) {
            return;
        }
        
        // Count recent similar events across protocols
        uint256 recentEventCount = 0;
        uint256 cutoffTime = block.timestamp - rule.timeWindow;
        
        for (uint256 i = 0; i < securityEvents.length; i++) {
            SecurityEvent memory eventData = securityEvents[i];
            
            if (eventData.timestamp >= cutoffTime && 
                !eventData.resolved &&
                keccak256(abi.encodePacked(eventData.eventType)) == keccak256(abi.encodePacked(eventType)) &&
                eventData.severity >= rule.severityThreshold) {
                recentEventCount++;
            }
        }
        
        // Trigger cross-protocol response if threshold met
        if (recentEventCount >= rule.minAffectedProtocols) {
            _triggerCrossProtocolResponse(rule.responseType, recentEventCount);
        }
    }

    /**
     * @dev Trigger coordinated response across protocols
     */
    function _triggerCrossProtocolResponse(string memory responseType, uint256 affectedCount) internal {
        if (keccak256(abi.encodePacked(responseType)) == keccak256(abi.encodePacked("pause"))) {
            _pauseAllProtocols();
        } else if (keccak256(abi.encodePacked(responseType)) == keccak256(abi.encodePacked("restrict"))) {
            _restrictAllProtocols();
        }
        
        emit CrossProtocolTriggerActivated(responseType, affectedCount);
    }

    /**
     * @dev Pause all registered protocols with circuit breakers
     */
    function _pauseAllProtocols() internal {
        for (uint256 i = 0; i < protocolAddresses.length; i++) {
            address protocol = protocolAddresses[i];
            ProtocolInfo memory info = protocols[protocol];
            
            if (info.isActive && info.hasCircuitBreaker) {
                // Call emergency pause on each protocol
                (bool success, ) = protocol.call(abi.encodeWithSignature("emergencyPause()"));
                if (!success) {
                    // Log failed pause attempt
                }
            }
        }
    }

    /**
     * @dev Apply restrictions to all protocols
     */
    function _restrictAllProtocols() internal {
        for (uint256 i = 0; i < protocolAddresses.length; i++) {
            address protocol = protocolAddresses[i];
            ProtocolInfo memory info = protocols[protocol];
            
            if (info.isActive && info.hasCircuitBreaker) {
                // Call restriction function on each protocol
                (bool success, ) = protocol.call(
                    abi.encodeWithSignature("escalateThreatLevel(uint8,string)", 2, "Cross-protocol coordination")
                );
            }
        }
    }

    /**
     * @dev Setup default coordination rules
     */
    function _setupDefaultRules() internal {
        // Rule for oracle manipulation events
        coordinationRules["oracle_manipulation"] = CoordinationRule({
            severityThreshold: 7,
            timeWindow: 1800,        // 30 minutes
            minAffectedProtocols: 2,
            autoTriggerEnabled: true,
            responseType: "pause"
        });
        
        // Rule for large volume anomalies
        coordinationRules["volume_anomaly"] = CoordinationRule({
            severityThreshold: 6,
            timeWindow: 3600,        // 1 hour
            minAffectedProtocols: 3,
            autoTriggerEnabled: true,
            responseType: "restrict"
        });
        
        // Rule for governance attacks
        coordinationRules["governance_attack"] = CoordinationRule({
            severityThreshold: 8,
            timeWindow: 7200,        // 2 hours
            minAffectedProtocols: 1, // Single protocol can trigger
            autoTriggerEnabled: true,
            responseType: "pause"
        });
    }

    /**
     * @dev Manual cross-protocol trigger
     */
    function manualCrossProtocolTrigger(string memory responseType) 
        external 
        onlyRole(COORDINATOR_ROLE) 
    {
        uint256 activeProtocols = 0;
        for (uint256 i = 0; i < protocolAddresses.length; i++) {
            if (protocols[protocolAddresses[i]].isActive) {
                activeProtocols++;
            }
        }
        
        _triggerCrossProtocolResponse(responseType, activeProtocols);
    }

    /**
     * @dev Resolve a security event
     */
    function resolveSecurityEvent(uint256 eventIndex) 
        external 
        onlyRole(COORDINATOR_ROLE) 
    {
        require(eventIndex < securityEvents.length, "Invalid event index");
        securityEvents[eventIndex].resolved = true;
    }

    /**
     * @dev Get recent security events for analysis
     */
    function getRecentEvents(uint256 timeWindow) 
        external 
        view 
        returns (SecurityEvent[] memory) 
    {
        uint256 cutoffTime = block.timestamp - timeWindow;
        uint256 recentCount = 0;
        
        // First pass: count recent events
        for (uint256 i = 0; i < securityEvents.length; i++) {
            if (securityEvents[i].timestamp >= cutoffTime) {
                recentCount++;
            }
        }
        
        // Second pass: collect recent events
        SecurityEvent[] memory recentEvents = new SecurityEvent[](recentCount);
        uint256 index = 0;
        
        for (uint256 i = 0; i < securityEvents.length; i++) {
            if (securityEvents[i].timestamp >= cutoffTime) {
                recentEvents[index] = securityEvents[i];
                index++;
            }
        }
        
        return recentEvents;
    }
}

// test/CircuitBreakerTest.ts
import { expect } from "chai";
import { ethers } from "hardhat";
import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers";

describe("Circuit Breaker Comprehensive Testing", function() {
  let stablecoin: any;
  let circuitBreaker: any;
  let accounts: SignerWithAddress[];
  
  beforeEach(async function() {
    accounts = await ethers.getSigners();
    
    // Deploy test contracts
    const StablecoinFactory = await ethers.getContractFactory("StablecoinWithCircuitBreakers");
    stablecoin = await StablecoinFactory.deploy("TestCoin", "TEST", accounts[0].address);
    
    const CircuitBreakerFactory = await ethers.getContractFactory("AutomatedCircuitBreaker");
    circuitBreaker = await CircuitBreakerFactory.deploy(stablecoin.address, accounts[0].address);
    
    // Grant necessary roles
    const pauserRole = await stablecoin.PAUSER_ROLE();
    await stablecoin.grantRole(pauserRole, circuitBreaker.address);
  });

  describe("Transaction Size Circuit Breakers", function() {
    it("Should trigger on oversized transactions", async function() {
      const maxTransactionValue = ethers.utils.parseEther("1000000"); // $1M
      
      // Set up circuit breaker config
      await circuitBreaker.updateCircuitBreakerConfig(
        maxTransactionValue,
        ethers.utils.parseEther("10000000"), // hourly
        ethers.utils.parseEther("50000000"), // daily
        500, // 5% price deviation
        true // enabled
      );
      
      // Attempt transaction exceeding limit
      const oversizedAmount = ethers.utils.parseEther("2000000"); // $2M
      
      await expect(
        stablecoin.mint(accounts[1].address, oversizedAmount, oversizedAmount)
      ).to.be.revertedWith("EnhancedPausable: function paused at current level");
      
      // Verify circuit breaker was triggered
      expect(await stablecoin.paused()).to.be.true;
    });

    it("Should allow transactions under limit", async function() {
      const maxTransactionValue = ethers.utils.parseEther("1000000");
      
      await circuitBreaker.updateCircuitBreakerConfig(
        maxTransactionValue,
        ethers.utils.parseEther("10000000"),
        ethers.utils.parseEther("50000000"),
        500,
        true
      );
      
      // Transaction under limit should succeed
      const normalAmount = ethers.utils.parseEther("500000"); // $500k
      
      await expect(
        stablecoin.mint(accounts[1].address, normalAmount, normalAmount)
      ).to.not.be.reverted;
      
      expect(await stablecoin.paused()).to.be.false;
    });
  });

  describe("Volume-Based Circuit Breakers", function() {
    it("Should trigger on excessive hourly volume", async function() {
      const maxHourlyVolume = ethers.utils.parseEther("1000000"); // $1M/hour
      
      await circuitBreaker.updateCircuitBreakerConfig(
        ethers.utils.parseEther("10000000"), // transaction limit
        maxHourlyVolume,
        ethers.utils.parseEther("50000000"),
        500,
        true
      );
      
      // Execute multiple transactions within the hour
      const txAmount = ethers.utils.parseEther("300000"); // $300k each
      
      // First three transactions should succeed
      await stablecoin.mint(accounts[1].address, txAmount, txAmount);
      await stablecoin.mint(accounts[2].address, txAmount, txAmount);
      await stablecoin.mint(accounts[3].address, txAmount, txAmount);
      
      // Fourth transaction should trigger circuit breaker (total > $1M)
      await expect(
        stablecoin.mint(accounts[4].address, txAmount, txAmount)
      ).to.be.revertedWith("EnhancedPausable: function paused at current level");
    });
  });

  describe("Price Deviation Circuit Breakers", function() {
    it("Should trigger on significant price deviation", async function() {
      // Mock oracle with significant price deviation
      const MockOracle = await ethers.getContractFactory("MockPriceOracle");
      const oracle = await MockOracle.deploy();
      
      // Set initial price at $1.00
      await oracle.setPrice(ethers.utils.parseEther("1"));
      
      // Update stablecoin to use mock oracle
      await stablecoin.setPriceOracle(oracle.address);
      
      // Set circuit breaker to trigger at 2% deviation
      await circuitBreaker.updateCircuitBreakerConfig(
        ethers.utils.parseEther("10000000"),
        ethers.utils.parseEther("10000000"),
        ethers.utils.parseEther("50000000"),
        200, // 2%
        true
      );
      
      // Change oracle price to $1.05 (5% deviation)
      await oracle.setPrice(ethers.utils.parseEther("1.05"));
      
      // Any transaction should now trigger circuit breaker
      await expect(
        stablecoin.mint(accounts[1].address, ethers.utils.parseEther("1000"), ethers.utils.parseEther("1000"))
      ).to.be.revertedWith("EnhancedPausable: function paused at current level");
    });
  });

  describe("Graduated Response Testing", function() {
    let graduatedBreaker: any;
    
    beforeEach(async function() {
      const GraduatedFactory = await ethers.getContractFactory("GraduatedCircuitBreaker");
      graduatedBreaker = await GraduatedFactory.deploy();
    });

    it("Should implement graduated threat levels", async function() {
      // Start at GREEN level
      expect(await graduatedBreaker.currentThreatLevel()).to.equal(0); // GREEN
      
      // Escalate to YELLOW
      const emergencyRole = await graduatedBreaker.EMERGENCY_ROLE();
      await graduatedBreaker.grantRole(emergencyRole, accounts[0].address);
      
      await graduatedBreaker.escalateThreatLevel(1, "Suspicious activity detected");
      expect(await graduatedBreaker.currentThreatLevel()).to.equal(1); // YELLOW
      
      // Check transaction restrictions at YELLOW level
      const [allowed, reason] = await graduatedBreaker.isTransactionAllowed(
        accounts[1].address,
        ethers.utils.parseEther("6000000"), // $6M (exceeds YELLOW limit)
        "0x40c10f19" // mint function selector
      );
      
      expect(allowed).to.be.false;
      expect(reason).to.include("Transaction size exceeds limit");
    });

    it("Should enforce cooldown periods for large transactions", async function() {
      // Set to YELLOW level (5-minute cooldown for large transactions)
      await graduatedBreaker.escalateThreatLevel(1, "Test escalation");
      
      const largeAmount = ethers.utils.parseEther("200000"); // > $100k threshold
      
      // First large transaction should be allowed
      const [allowed1] = await graduatedBreaker.isTransactionAllowed(
        accounts[1].address,
        largeAmount,
        "0x40c10f19"
      );
      expect(allowed1).to.be.true;
      
      // Simulate the transaction happening
      await graduatedBreaker._updateLargeTransactionTimestamp(accounts[1].address, largeAmount);
      
      // Second large transaction immediately should be rejected
      const [allowed2, reason2] = await graduatedBreaker.isTransactionAllowed(
        accounts[1].address,
        largeAmount,
        "0x40c10f19"
      );
      expect(allowed2).to.be.false;
      expect(reason2).to.include("cooldown period");
    });
  });

  describe("Cross-Protocol Coordination Testing", function() {
    let crossProtocolBreaker: any;
    let mockProtocol1: any;
    let mockProtocol2: any;
    
    beforeEach(async function() {
      const CrossProtocolFactory = await ethers.getContractFactory("CrossProtocolCircuitBreaker");
      crossProtocolBreaker = await CrossProtocolFactory.deploy();
      
      // Deploy mock protocols
      const MockProtocolFactory = await ethers.getContractFactory("MockProtocol");
      mockProtocol1 = await MockProtocolFactory.deploy();
      mockProtocol2 = await MockProtocolFactory.deploy();
      
      // Register protocols
      await crossProtocolBreaker.registerProtocol(
        mockProtocol1.address,
        "MockProtocol1",
        100, // risk weight
        true // has circuit breaker
      );
      
      await crossProtocolBreaker.registerProtocol(
        mockProtocol2.address,
        "MockProtocol2", 
        100,
        true
      );
    });

    it("Should coordinate circuit breakers across protocols", async function() {
      // Grant protocol role to test account for reporting
      const protocolRole = await crossProtocolBreaker.PROTOCOL_ROLE();
      await crossProtocolBreaker.grantRole(protocolRole, accounts[0].address);
      
      // Report security events from multiple protocols
      await crossProtocolBreaker.reportSecurityEvent("oracle_manipulation", 8, "0x");
      
      // Advance time slightly
      await ethers.provider.send("evm_increaseTime", [60]); // 1 minute
      
      // Report another similar event (should trigger cross-protocol response)
      await crossProtocolBreaker.reportSecurityEvent("oracle_manipulation", 7, "0x");
      
      // Verify that cross-protocol trigger was activated
      const events = await crossProtocolBreaker.getRecentEvents(3600); // last hour
      expect(events.length).to.equal(2);
      
      // Check if protocols were paused (would need to check mock contracts)
      expect(await mockProtocol1.paused()).to.be.true;
      expect(await mockProtocol2.paused()).to.be.true;
    });
  });

  describe("Performance and Gas Testing", function() {
    it("Should have reasonable gas costs for circuit breaker checks", async function() {
      const tx = await stablecoin.mint(
        accounts[1].address,
        ethers.utils.parseEther("1000"),
        ethers.utils.parseEther("1000")
      );
      
      const receipt = await tx.wait();
      console.log(`Gas used for mint with circuit breaker: ${receipt.gasUsed}`);
      
      // Circuit breaker overhead should be < 50k gas
      expect(receipt.gasUsed.toNumber()).to.be.lessThan(300000);
    });

    it("Should handle rapid consecutive transactions", async function() {
      const promises = [];
      
      // Fire 10 transactions simultaneously
      for (let i = 0; i < 10; i++) {
        promises.push(
          stablecoin.mint(
            accounts[i % accounts.length].address,
            ethers.utils.parseEther("10000"),
            ethers.utils.parseEther("10000")
          )
        );
      }
      
      // Some should succeed, some might trigger circuit breaker
      const results = await Promise.allSettled(promises);
      
      const successful = results.filter(r => r.status === 'fulfilled').length;
      const failed = results.filter(r => r.status === 'rejected').length;
      
      console.log(`Successful: ${successful}, Failed: ${failed}`);
      
      // At least one should succeed before circuit breaker triggers
      expect(successful).to.be.greaterThan(0);
    });
  });

  describe("Emergency Recovery Testing", function() {
    it("Should allow emergency withdrawals when paused", async function() {
      // First mint some tokens
      await stablecoin.mint(
        accounts[1].address,
        ethers.utils.parseEther("1000"),
        ethers.utils.parseEther("1000")
      );
      
      // Trigger emergency pause
      await stablecoin.emergencyPause();
      expect(await stablecoin.paused()).to.be.true;
      
      // Normal operations should be blocked
      await expect(
        stablecoin.mint(accounts[2].address, ethers.utils.parseEther("100"), ethers.utils.parseEther("100"))
      ).to.be.revertedWith("Pausable: paused");
      
      // But emergency withdrawal should work
      await expect(
        stablecoin.connect(accounts[1]).emergencyWithdraw()
      ).to.not.be.reverted;
      
      // Verify tokens were burned and collateral returned
      expect(await stablecoin.balanceOf(accounts[1].address)).to.equal(0);
    });
  });
});