010_DeFi协议安全基础：去中心化金融的风险防范与安全架构

DeFi安全防护层次：
1. 协议层：智能合约安全、经济模型设计
2. 网络层：区块链共识安全、节点安全
3. 应用层：前端安全、用户交互安全
4. 生态层：跨协议安全、系统性风险控制
5. 治理层：安全决策机制、升级管理

// 简化的借贷协议抵押率检查示例
function checkCollateralRatio(address user) internal view returns (uint256) {
    uint256 totalCollateral = getCollateralValue(user);
    uint256 totalBorrowed = getBorrowedValue(user);
    
    // 防止除以零
    if (totalBorrowed == 0) return type(uint256).max;
    
    // 计算抵押率（乘以1e18以避免浮点运算）
    return (totalCollateral * 1e18) / totalBorrowed;
}

// 清算逻辑
function liquidate(address user, uint256 repayAmount) external {
    // 获取用户当前抵押率
    uint256 currentRatio = checkCollateralRatio(user);
    
    // 检查是否低于清算阈值
    require(currentRatio < LIQUIDATION_THRESHOLD, "用户未达到清算条件");
    require(repayAmount > 0, "还款金额必须大于0");
    
    // 计算可获取的抵押品数量（包含清算奖励）
    uint256 liquidationBonus = (repayAmount * LIQUIDATION_BONUS) / 10000;
    uint256 collateralSeizeAmount = repayAmount + liquidationBonus;
    
    // 更新用户债务和抵押品
    userBorrowed[user] -= repayAmount;
    userCollateral[user] -= collateralSeizeAmount;
    
    // 增加清算人的抵押品
    userCollateral[msg.sender] += collateralSeizeAmount;
    
    emit Liquidation(user, msg.sender, repayAmount, collateralSeizeAmount);
}

// 简化的恒定乘积自动做市商(AMM)实现
contract SimpleAMM {
    IERC20 public tokenA;
    IERC20 public tokenB;
    
    uint256 public reserveA;
    uint256 public reserveB;
    
    uint256 public constant K = reserveA * reserveB; // 恒定乘积
    
    // 添加流动性
    function addLiquidity(uint256 amountA, uint256 amountB) external {
        require(amountA > 0 && amountB > 0, "金额必须大于0");
        
        // 检查是否首次添加流动性
        if (reserveA == 0 && reserveB == 0) {
            // 首次添加，直接接受任何比例
            reserveA = amountA;
            reserveB = amountB;
        } else {
            // 非首次，检查比例是否匹配
            require(
                amountA * reserveB == amountB * reserveA,
                "提供的资产比例不匹配"
            );
            reserveA += amountA;
            reserveB += amountB;
        }
        
        // 转移代币到合约
        require(tokenA.transferFrom(msg.sender, address(this), amountA), "TokenA转账失败");
        require(tokenB.transferFrom(msg.sender, address(this), amountB), "TokenB转账失败");
        
        // 铸造LP代币给用户
        // ...
    }
    
    // 交换代币
    function swap(uint256 amountIn, bool isTokenAIn) external {
        require(amountIn > 0, "输入金额必须大于0");
        
        uint256 amountOut;
        
        if (isTokenAIn) {
            // 输入TokenA，输出TokenB
            require(tokenA.transferFrom(msg.sender, address(this), amountIn), "TokenA转账失败");
            
            // 计算输出金额（减去手续费）
            uint256 amountInWithFee = amountIn * 997; // 0.3%手续费
            uint256 numerator = amountInWithFee * reserveB;
            uint256 denominator = (reserveA * 1000) + amountInWithFee;
            amountOut = numerator / denominator;
            
            require(amountOut > 0, "输出金额必须大于0");
            
            // 更新储备
            reserveA += amountIn;
            reserveB -= amountOut;
            
            // 转移TokenB给用户
            require(tokenB.transfer(msg.sender, amountOut), "TokenB转账失败");
        } else {
            // 输入TokenB，输出TokenA
            require(tokenB.transferFrom(msg.sender, address(this), amountIn), "TokenB转账失败");
            
            // 计算输出金额（减去手续费）
            uint256 amountInWithFee = amountIn * 997; // 0.3%手续费
            uint256 numerator = amountInWithFee * reserveA;
            uint256 denominator = (reserveB * 1000) + amountInWithFee;
            amountOut = numerator / denominator;
            
            require(amountOut > 0, "输出金额必须大于0");
            
            // 更新储备
            reserveB += amountIn;
            reserveA -= amountOut;
            
            // 转移TokenA给用户
            require(tokenA.transfer(msg.sender, amountOut), "TokenA转账失败");
        }
        
        emit Swap(msg.sender, amountIn, amountOut, isTokenAIn);
    }
}

// 简化的抵押稳定币铸造和清算示例
contract CollateralizedStablecoin {
    IERC20 public collateralToken;
    mapping(address => uint256) public collateral;
    mapping(address => uint256) public stablecoinsIssued;
    
    uint256 public constant COLLATERAL_RATIO = 150; // 150%抵押率
    uint256 public constant LIQUIDATION_THRESHOLD = 110; // 110%清算阈值
    
    // 铸造稳定币
    function mint(uint256 stablecoinAmount) external {
        // 计算所需抵押品数量
        uint256 requiredCollateral = (stablecoinAmount * COLLATERAL_RATIO) / 100;
        
        // 转移抵押品到合约
        require(
            collateralToken.transferFrom(msg.sender, address(this), requiredCollateral),
            "抵押品转账失败"
        );
        
        // 更新用户抵押品和稳定币余额
        collateral[msg.sender] += requiredCollateral;
        stablecoinsIssued[msg.sender] += stablecoinAmount;
        
        // 铸造稳定币给用户
        // ...
    }
    
    // 检查抵押率
    function getCollateralRatio(address user) public view returns (uint256) {
        if (stablecoinsIssued[user] == 0) return type(uint256).max;
        
        // 获取抵押品当前价值
        uint256 collateralValue = getCollateralValue(user);
        
        // 计算抵押率
        return (collateralValue * 100) / stablecoinsIssued[user];
    }
    
    // 清算函数
    function liquidate(address user, uint256 repayAmount) external {
        // 检查用户是否达到清算条件
        require(getCollateralRatio(user) < LIQUIDATION_THRESHOLD, "用户未达到清算条件");
        require(repayAmount > 0 && repayAmount <= stablecoinsIssued[user], "无效的还款金额");
        
        // 计算可获取的抵押品（包含清算奖励）
        uint256 liquidationBonus = (repayAmount * 5) / 100; // 5%清算奖励
        uint256 collateralToSeize = (repayAmount + liquidationBonus) * COLLATERAL_RATIO / 100;
        
        // 更新用户债务和抵押品
        stablecoinsIssued[user] -= repayAmount;
        collateral[user] -= collateralToSeize;
        
        // 转移稳定币和抵押品
        require(
            // 销毁用户偿还的稳定币
            // ...
            true,
            "稳定币销毁失败"
        );
        
        require(
            collateralToken.transfer(msg.sender, collateralToSeize),
            "抵押品转账失败"
        );
        
        emit Liquidation(user, msg.sender, repayAmount, collateralToSeize);
    }
    
    // 获取抵押品当前价值
    function getCollateralValue(address user) public view returns (uint256) {
        // 通过预言机获取抵押品价格
        uint256 price = getOraclePrice();
        return (collateral[user] * price) / 1e18; // 假设价格精度为18位
    }
    
    // 获取预言机价格
    function getOraclePrice() public view returns (uint256) {
        // 实现预言机价格获取逻辑
        // ...
        return 1e18; // 示例返回值
    }
}

// 简化的收益聚合器示例
contract YieldAggregator {
    address public owner;
    mapping(address => uint256) public userDeposits;
    mapping(address => uint256) public userShares;
    
    IERC20 public token;
    
    // 外部协议接口
    ILendingProtocol public lendingProtocol;
    IDEX public dex;
    
    uint256 public totalShares;
    uint256 public totalDeposits;
    
    constructor(address _token, address _lendingProtocol, address _dex) {
        owner = msg.sender;
        token = IERC20(_token);
        lendingProtocol = ILendingProtocol(_lendingProtocol);
        dex = IDEX(_dex);
    }
    
    // 存款函数
    function deposit(uint256 amount) external nonReentrant {
        require(amount > 0, "存款金额必须大于0");
        
        // 计算用户应得份额
        uint256 shares;
        if (totalShares == 0) {
            shares = amount;
        } else {
            shares = (amount * totalShares) / totalDeposits;
        }
        
        // 更新状态
        userDeposits[msg.sender] += amount;
        userShares[msg.sender] += shares;
        totalDeposits += amount;
        totalShares += shares;
        
        // 转移代币到合约
        require(token.transferFrom(msg.sender, address(this), amount), "代币转账失败");
        
        // 将资金部署到收益协议
        deployToYieldProtocols(amount);
    }
    
    // 提款函数
    function withdraw(uint256 shares) external nonReentrant {
        require(shares > 0 && shares <= userShares[msg.sender], "无效的份额数量");
        
        // 计算可提取的金额
        uint256 amount = (shares * totalDeposits) / totalShares;
        
        // 更新状态
        userShares[msg.sender] -= shares;
        userDeposits[msg.sender] -= amount;
        totalShares -= shares;
        totalDeposits -= amount;
        
        // 从收益协议中取回资金
        retrieveFromYieldProtocols(amount);
        
        // 转移代币给用户
        require(token.transfer(msg.sender, amount), "代币转账失败");
    }
    
    // 将资金部署到收益协议
    function deployToYieldProtocols(uint256 amount) internal {
        // 实现部署逻辑，可能包括多个协议的交互
        // 例如：先在DEX兑换，再在借贷协议存款
        
        // 批准代币给外部协议
        token.approve(address(lendingProtocol), amount);
        
        // 存入借贷协议
        lendingProtocol.deposit(amount);
    }
    
    // 从收益协议中取回资金
    function retrieveFromYieldProtocols(uint256 amount) internal {
        // 实现取回逻辑
        lendingProtocol.withdraw(amount);
    }
    
    // 更新策略（需要权限控制）
    function updateStrategy(address _newProtocol) external onlyOwner {
        // 实现策略更新逻辑
        // ...
    }
    
    // 修饰器：仅所有者
    modifier onlyOwner() {
        require(msg.sender == owner, "未授权");
        _;
    }
    
    // 修饰器：防止重入
    bool private locked;
    modifier nonReentrant() {
        require(!locked, "重入保护：已锁定");
        locked = true;
        _;
        locked = false;
    }
}

// 利率模型参数设计示例
class InterestRateModel {
  constructor() {
    // 基础利率 (年化)
    this.baseRatePerYear = ethers.utils.parseEther("0.02"); // 2%
    
    // 使用率阈值1
    this.optimalUtilizationRate = ethers.utils.parseEther("0.8"); // 80%
    
    // 使用率阈值1对应的利率斜率
    this.multiplierPerYear = ethers.utils.parseEther("0.04"); // 4%
    
    // 使用率阈值2对应的利率斜率
    this.jumpMultiplierPerYear = ethers.utils.parseEther("0.5"); // 50%
  }
  
  // 计算年化借款利率
  getBorrowRate(utilizationRate) {
    // 确保使用率在有效范围内
    utilizationRate = Math.min(utilizationRate, ethers.utils.parseEther("1"));
    
    // 根据使用率计算借款利率
    if (utilizationRate.lte(this.optimalUtilizationRate)) {
      // 使用率在最优范围内
      return this.baseRatePerYear.add(
        utilizationRate.mul(this.multiplierPerYear).div(ethers.utils.parseEther("1"))
      );
    } else {
      // 使用率超过最优范围
      const normalRate = this.baseRatePerYear.add(
        this.optimalUtilizationRate.mul(this.multiplierPerYear).div(ethers.utils.parseEther("1"))
      );
      
      const excessUtilizationRate = utilizationRate.sub(this.optimalUtilizationRate);
      const excessRate = excessUtilizationRate.mul(this.jumpMultiplierPerYear).div(
        ethers.utils.parseEther("1").sub(this.optimalUtilizationRate)
      );
      
      return normalRate.add(excessRate);
    }
  }
  
  // 计算年化存款利率
  getSupplyRate(utilizationRate, borrowRate) {
    // 存款利率 = 借款利率 * 使用率 * (1 - 手续费率)
    const feeRate = ethers.utils.parseEther("0.003"); // 0.3%
    return borrowRate.mul(utilizationRate).mul(ethers.utils.parseEther("1").sub(feeRate)).div(
      ethers.utils.parseEther("1").mul(ethers.utils.parseEther("1"))
    );
  }
  
  // 模拟不同使用率下的利率曲线
  simulateInterestRates() {
    const results = [];
    for (let u = 0; u <= 100; u += 5) {
      const utilization = ethers.utils.parseEther((u / 100).toString());
      const borrowRate = this.getBorrowRate(utilization);
      const supplyRate = this.getSupplyRate(utilization, borrowRate);
      
      results.push({
        utilization: u + "%",
        borrowRate: parseFloat(ethers.utils.formatEther(borrowRate)) * 100 + "%",
        supplyRate: parseFloat(ethers.utils.formatEther(supplyRate)) * 100 + "%"
      });
    }
    return results;
  }
}

// 使用示例
const rateModel = new InterestRateModel();
const simulationResults = rateModel.simulateInterestRates();
console.table(simulationResults);

// 多源预言机聚合器
contract MultiOracleAggregator {
    // 预言机来源
    address[] public oracleSources;
    uint256 public constant MIN_SOURCES = 3;
    uint256 public constant MAX_DEVIATION = 5; // 最大允许偏差百分比
    uint256 public constant UPDATE_INTERVAL = 1 hours;
    
    mapping(address => bool) public isActiveOracle;
    mapping(uint256 => uint256) public assetPrices; // assetId => price
    mapping(uint256 => uint256) public lastUpdateTime; // assetId => timestamp
    
    event OraclePriceUpdated(uint256 indexed assetId, uint256 price);
    event OracleAdded(address indexed oracle);
    event OracleRemoved(address indexed oracle);
    
    modifier onlyOracle() {
        require(isActiveOracle[msg.sender], "未授权的预言机");
        _;
    }
    
    // 添加预言机来源
    function addOracleSource(address _oracle) external {
        require(_oracle != address(0), "无效的预言机地址");
        require(!isActiveOracle[_oracle], "预言机已添加");
        
        oracleSources.push(_oracle);
        isActiveOracle[_oracle] = true;
        
        emit OracleAdded(_oracle);
    }
    
    // 移除预言机来源
    function removeOracleSource(address _oracle) external {
        require(isActiveOracle[_oracle], "预言机不存在");
        require(oracleSources.length > MIN_SOURCES, "预言机数量不能少于最小值");
        
        isActiveOracle[_oracle] = false;
        
        // 从数组中移除
        for (uint i = 0; i < oracleSources.length; i++) {
            if (oracleSources[i] == _oracle) {
                oracleSources[i] = oracleSources[oracleSources.length - 1];
                oracleSources.pop();
                break;
            }
        }
        
        emit OracleRemoved(_oracle);
    }
    
    // 提交价格数据
    function submitPrice(uint256 _assetId, uint256 _price) external onlyOracle {
        // 记录单条价格数据
        // 实际实现中应使用映射存储每个预言机的价格
    }
    
    // 获取聚合价格
    function getAssetPrice(uint256 _assetId) public view returns (uint256) {
        require(oracleSources.length >= MIN_SOURCES, "预言机数量不足");
        
        // 实际实现中应聚合多个预言机的价格数据
        // 例如：中位数或加权平均
        // 并验证价格偏差是否在允许范围内
        
        return assetPrices[_assetId];
    }
    
    // 更新聚合价格（内部函数或定时调用）
    function updateAggregatedPrice(uint256 _assetId) internal {
        // 实现价格聚合逻辑
        // 1. 收集所有活跃预言机的价格
        // 2. 过滤异常值
        // 3. 计算中位数或加权平均
        // 4. 更新价格并记录时间戳
    }
    
    // 验证价格是否在合理范围内
    function validatePrice(uint256 _assetId, uint256 _price) public view returns (bool) {
        uint256 currentPrice = assetPrices[_assetId];
        if (currentPrice == 0) return true; // 首次设置价格
        
        uint256 deviation;
        if (_price > currentPrice) {
            deviation = (_price - currentPrice) * 100 / currentPrice;
        } else {
            deviation = (currentPrice - _price) * 100 / currentPrice;
        }
        
        return deviation <= MAX_DEVIATION;
    }
}

// 简化的多签名钱包实现
contract MultiSigWallet {
    address[] public owners;
    mapping(address => bool) public isOwner;
    uint256 public requiredSignatures;
    
    struct Transaction {
        address to;
        uint256 value;
        bytes data;
        bool executed;
        uint256 confirmations;
    }
    
    Transaction[] public transactions;
    mapping(uint256 => mapping(address => bool)) public hasConfirmed;
    
    event TransactionSubmitted(uint256 indexed txId, address indexed submitter, address indexed to, uint256 value);
    event TransactionConfirmed(uint256 indexed txId, address indexed signer);
    event TransactionExecuted(uint256 indexed txId, address indexed executor);
    event TransactionCancelled(uint256 indexed txId, address indexed canceller);
    
    modifier onlyOwner() {
        require(isOwner[msg.sender], "未授权：不是所有者");
        _;
    }
    
    modifier txExists(uint256 _txId) {
        require(_txId < transactions.length, "交易不存在");
        _;
    }
    
    modifier notExecuted(uint256 _txId) {
        require(!transactions[_txId].executed, "交易已执行");
        _;
    }
    
    modifier notConfirmed(uint256 _txId) {
        require(!hasConfirmed[_txId][msg.sender], "交易已确认");
        _;
    }
    
    constructor(address[] memory _owners, uint256 _requiredSignatures) {
        require(_owners.length > 0, "至少需要一个所有者");
        require(
            _requiredSignatures > 0 && _requiredSignatures <= _owners.length,
            "所需签名数无效"
        );
        
        for (uint i = 0; i < _owners.length; i++) {
            address owner = _owners[i];
            require(owner != address(0), "无效的所有者地址");
            require(!isOwner[owner], "所有者地址重复");
            
            isOwner[owner] = true;
            owners.push(owner);
        }
        
        requiredSignatures = _requiredSignatures;
    }
    
    // 提交交易
    function submitTransaction(address _to, uint256 _value, bytes memory _data) public onlyOwner returns (uint256) {
        uint256 txId = transactions.length;
        
        transactions.push(Transaction({
            to: _to,
            value: _value,
            data: _data,
            executed: false,
            confirmations: 0
        }));
        
        emit TransactionSubmitted(txId, msg.sender, _to, _value);
        
        // 自动确认提交者的签名
        confirmTransaction(txId);
        
        return txId;
    }
    
    // 确认交易
    function confirmTransaction(uint256 _txId) public onlyOwner txExists(_txId) notExecuted(_txId) notConfirmed(_txId) {
        hasConfirmed[_txId][msg.sender] = true;
        transactions[_txId].confirmations += 1;
        
        emit TransactionConfirmed(_txId, msg.sender);
    }
    
    // 执行交易
    function executeTransaction(uint256 _txId) public onlyOwner txExists(_txId) notExecuted(_txId) {
        require(transactions[_txId].confirmations >= requiredSignatures, "签名数量不足");
        
        Transaction storage transaction = transactions[_txId];
        transaction.executed = true;
        
        // 执行交易
        (bool success, ) = transaction.to.call{value: transaction.value}(transaction.data);
        require(success, "交易执行失败");
        
        emit TransactionExecuted(_txId, msg.sender);
    }
    
    // 获取交易数量
    function getTransactionCount() public view returns (uint256) {
        return transactions.length;
    }
    
    // 获取所有者列表
    function getOwners() public view returns (address[] memory) {
        return owners;
    }
    
    // 接收以太币
    receive() external payable {}
}

DeFi协议安全审计流程：
1. 范围确定 → 2. 自动化扫描 → 3. 手动代码审查 → 4. 形式化验证 → 5. 经济模型分析 → 6. 渗透测试 → 7. 报告生成

// DeFi协议监控系统示例
class DeFiMonitoringSystem {
  constructor(provider, contracts) {
    this.provider = provider;
    this.contracts = contracts; // 协议合约配置
    this.alerts = [];
    this.thresholds = {
      transactionVolumeIncrease: 300, // 交易量突增300%
      priceDeviation: 5, // 价格偏离5%
      largeWithdrawal: 10000, // 大额提款阈值 (ETH)
      rapidSuccessionCalls: 10 // 短时间内调用次数
    };
    
    // 历史数据存储
    this.historicalData = {
      transactionVolumes: {}, // 按小时存储交易量
      prices: {}, // 价格历史
      userActions: {} // 用户行为历史
    };
    
    // 初始化监控
    this.initMonitoring();
  }
  
  // 初始化监控
  initMonitoring() {
    console.log('启动DeFi协议监控系统...');
    
    // 监控交易事件
    this.monitorEvents();
    
    // 定期检查指标
    setInterval(() => this.checkPeriodicMetrics(), 60000); // 每分钟检查
    
    // 收集历史数据
    this.collectHistoricalData();
  }
  
  // 监控合约事件
  monitorEvents() {
    Object.keys(this.contracts).forEach(contractName => {
      const contract = this.contracts[contractName];
      
      // 监控大额提款
      contract.on('Withdrawal', (user, amount) => {
        const amountInEth = ethers.utils.formatEther(amount);
        console.log(`${contractName}: 用户 ${user} 提款 ${amountInEth} ETH`);
        
        if (parseFloat(amountInEth) > this.thresholds.largeWithdrawal) {
          this.triggerAlert('大额提款', {
            contract: contractName,
            user: user,
            amount: amountInEth,
            timestamp: Date.now()
          });
        }
        
        // 记录用户操作
        this.recordUserAction(user, 'withdrawal', amountInEth);
      });
      
      // 监控价格更新（如果是预言机合约）
      if (contractName.includes('Oracle')) {
        contract.on('PriceUpdated', (asset, price) => {
          console.log(`${contractName}: 资产 ${asset} 价格更新为 ${price}`);
          this.checkPriceDeviation(asset, price);
        });
      }
      
      // 监控治理活动
      if (contractName.includes('Governance')) {
        contract.on('ProposalCreated', (proposalId, proposer, targets, values, signatures, calldatas, description) => {
          console.log(`${contractName}: 新提案 ${proposalId} 由 ${proposer} 创建`);
          this.analyzeGovernanceProposal(proposalId, proposer, description);
        });
      }
    });
  }
  
  // 检查周期性指标
  async checkPeriodicMetrics() {
    // 检查交易量异常
    await this.checkTransactionVolumeAnomaly();
    
    // 检查用户行为模式
    this.checkUserBehaviorPatterns();
    
    // 检查合约健康状态
    await this.checkContractHealth();
  }
  
  // 检查交易量异常
  async checkTransactionVolumeAnomaly() {
    const now = new Date();
    const currentHour = now.getHours();
    const currentDay = now.getDate();
    
    // 获取当前小时交易量
    const currentVolume = await this.getCurrentHourVolume();
    
    // 获取历史同期交易量（如昨天同一小时）
    const historicalVolume = this.getHistoricalHourVolume(currentDay - 1, currentHour);
    
    if (historicalVolume > 0) {
      const increasePercent = ((currentVolume - historicalVolume) / historicalVolume) * 100;
      
      if (increasePercent > this.thresholds.transactionVolumeIncrease) {
        this.triggerAlert('交易量异常增加', {
          currentVolume: currentVolume,
          historicalVolume: historicalVolume,
          increasePercent: increasePercent,
          timestamp: Date.now()
        });
      }
    }
    
    // 保存当前交易量到历史数据
    this.saveHourlyVolume(currentDay, currentHour, currentVolume);
  }
  
  // 检查价格偏差
  checkPriceDeviation(asset, price) {
    // 实现价格偏差检查逻辑
    // 例如：与外部交易所价格比较
    
    // 模拟实现
    const marketPrice = this.getExternalMarketPrice(asset);
    if (marketPrice > 0) {
      const deviation = Math.abs((price - marketPrice) / marketPrice) * 100;
      
      if (deviation > this.thresholds.priceDeviation) {
        this.triggerAlert('价格偏离异常', {
          asset: asset,
          oraclePrice: price,
          marketPrice: marketPrice,
          deviation: deviation,
          timestamp: Date.now()
        });
      }
    }
  }
  
  // 记录用户操作
  recordUserAction(user, action, amount) {
    if (!this.historicalData.userActions[user]) {
      this.historicalData.userActions[user] = [];
    }
    
    this.historicalData.userActions[user].push({
      action: action,
      amount: amount,
      timestamp: Date.now()
    });
    
    // 检查短时间内的操作频率
    this.checkActionFrequency(user);
  }
  
  // 检查用户操作频率
  checkActionFrequency(user) {
    const actions = this.historicalData.userActions[user];
    if (!actions || actions.length < this.thresholds.rapidSuccessionCalls) return;
    
    // 获取最近n次操作
    const recentActions = actions.slice(-this.thresholds.rapidSuccessionCalls);
    const timeSpan = recentActions[recentActions.length - 1].timestamp - recentActions[0].timestamp;
    
    // 如果在1分钟内有超过阈值的操作，触发警报
    if (timeSpan < 60000) {
      this.triggerAlert('操作频率异常', {
        user: user,
        actionCount: recentActions.length,
        timeSpan: timeSpan / 1000 + '秒',
        timestamp: Date.now()
      });
    }
  }
  
  // 获取外部市场价格
  getExternalMarketPrice(asset) {
    // 实际实现中应从外部API获取价格
    // 模拟返回
    return Math.random() * 1000;
  }
  
  // 获取当前小时交易量
  async getCurrentHourVolume() {
    // 实际实现中应查询区块链获取交易量
    // 模拟返回
    return Math.random() * 1000;
  }
  
  // 获取历史小时交易量
  getHistoricalHourVolume(day, hour) {
    const key = `${day}-${hour}`;
    return this.historicalData.transactionVolumes[key] || 0;
  }
  
  // 保存小时交易量
  saveHourlyVolume(day, hour, volume) {
    const key = `${day}-${hour}`;
    this.historicalData.transactionVolumes[key] = volume;
  }
  
  // 分析治理提案
  analyzeGovernanceProposal(proposalId, proposer, description) {
    // 实现治理提案分析逻辑
    // 例如：关键词分析、紧急提案检测等
    
    // 示例检查：紧急修改参数的提案
    if (description.includes('emergency') || description.includes('紧急')) {
      this.triggerAlert('紧急治理提案', {
        proposalId: proposalId,
        proposer: proposer,
        description: description,
        timestamp: Date.now()
      });
    }
  }
  
  // 检查合约健康状态
  async checkContractHealth() {
    // 实现合约健康检查逻辑
    // 例如：余额检查、关键功能测试等
  }
  
  // 收集历史数据
  async collectHistoricalData() {
    // 实现历史数据收集逻辑
    // 例如：从区块链获取过去的交易和事件数据
  }
  
  // 触发警报
  triggerAlert(type, details) {
    const alert = {
      id: this.alerts.length + 1,
      type: type,
      details: details,
      timestamp: Date.now(),
      status: 'new'
    };
    
    this.alerts.push(alert);
    
    // 发送警报通知
    this.sendAlertNotification(alert);
    
    // 对严重警报执行自动响应
    if (this.isCriticalAlert(type)) {
      this.executeAutomaticResponse(type, details);
    }
    
    return alert;
  }
  
  // 判断是否为严重警报
  isCriticalAlert(type) {
    const criticalTypes = ['大额提款', '价格偏离异常', '紧急治理提案'];
    return criticalTypes.includes(type);
  }
  
  // 发送警报通知
  sendAlertNotification(alert) {
    console.log(`[ALERT] ${alert.type}:`, alert.details);
    
    // 实际实现中应发送邮件、短信或其他通知
  }
  
  // 执行自动响应
  async executeAutomaticResponse(type, details) {
    // 实现自动响应逻辑
    // 例如：暂停合约、通知管理员等
    
    console.log(`[自动响应] 对警报类型 "${type}" 执行响应措施`);
    
    // 示例：如果是严重的价格偏离，暂停相关功能
    if (type === '价格偏离异常') {
      // await this.pausePriceSensitiveFunctions();
    }
  }
  
  // 获取所有警报
  getAlerts() {
    return this.alerts;
  }
}

// 使用示例
const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_INFURA_KEY');
const contracts = {
  lendingProtocol: new ethers.Contract(contractAddress, abi, provider),
  oracle: new ethers.Contract(oracleAddress, oracleAbi, provider),
  governance: new ethers.Contract(governanceAddress, governanceAbi, provider)
};

const monitor = new DeFiMonitoringSystem(provider, contracts);

// 具有紧急功能的DeFi协议示例
contract DeFiProtocolWithEmergency is Pausable, Ownable {
    // 紧急事件计数器
    uint256 public emergencyCount;
    
    // 紧急事件记录
    struct EmergencyEvent {
        uint256 timestamp;
        string reason;
        address initiator;
        bool resolved;
    }
    
    mapping(uint256 => EmergencyEvent) public emergencyEvents;
    
    // 事件定义
    event EmergencyActivated(uint256 indexed eventId, string reason, address indexed initiator);
    event EmergencyResolved(uint256 indexed eventId, address indexed resolver);
    event ProtocolPaused(address indexed operator);
    event ProtocolUnpaused(address indexed operator);
    
    // 紧急暂停功能
    function emergencyPause(string calldata reason) external onlyOwner {
        _pause();
        
        // 记录紧急事件
        uint256 eventId = emergencyCount++;
        emergencyEvents[eventId] = EmergencyEvent({
            timestamp: block.timestamp,
            reason: reason,
            initiator: msg.sender,
            resolved: false
        });
        
        emit EmergencyActivated(eventId, reason, msg.sender);
        emit ProtocolPaused(msg.sender);
    }
    
    // 解决紧急状态
    function resolveEmergency(uint256 eventId) external onlyOwner {
        EmergencyEvent storage eventData = emergencyEvents[eventId];
        require(eventData.timestamp > 0, "紧急事件不存在");
        require(!eventData.resolved, "紧急事件已解决");
        
        eventData.resolved = true;
        
        // 解除暂停状态
        _unpause();
        
        emit EmergencyResolved(eventId, msg.sender);
        emit ProtocolUnpaused(msg.sender);
    }
    
    // 紧急提款功能（允许用户在紧急情况下取回资金）
    function emergencyWithdraw(uint256 amount) external whenPaused {
        require(amount > 0, "提款金额必须大于0");
        require(getUserBalance(msg.sender) >= amount, "余额不足");
        
        // 从用户余额中扣除
        deductUserBalance(msg.sender, amount);
        
        // 转移资产给用户
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "转账失败");
    }
    
    // 部分功能暂停
    function pauseSpecificFunction(bytes32 functionId) external onlyOwner {
        // 实现特定功能的暂停逻辑
        // ...
    }
    
    // 获取用户余额（实际实现）
    function getUserBalance(address user) internal view returns (uint256) {
        // 实现用户余额查询逻辑
        return 0; // 示例返回
    }
    
    // 扣除用户余额（实际实现）
    function deductUserBalance(address user, uint256 amount) internal {
        // 实现用户余额扣除逻辑
    }
    
    // 其他业务逻辑函数，使用whenNotPaused修饰器
    function normalOperation(/* 参数 */) external whenNotPaused {
        // 正常业务逻辑
    }
}