014_区块链预言机安全：数据引入与风险防护

预言机在DeFi中的应用分布：
价格预言机: 65%
随机数预言机: 15%
事件预言机: 10%
身份预言机: 5%
其他预言机: 5%

智能合约 → 请求数据 → 预言机网络 → 收集外部数据 → 数据聚合与验证 → 返回数据到智能合约

// 简单的中心化预言机实现
contract CentralizedOracle {
    address public owner;
    uint256 private price;
    uint256 private lastUpdate;
    
    constructor() {
        owner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not authorized");
        _;
    }
    
    // 更新价格数据
    function updatePrice(uint256 _newPrice) external onlyOwner {
        price = _newPrice;
        lastUpdate = block.timestamp;
    }
    
    // 获取价格数据
    function getPrice() external view returns (uint256) {
        // 检查数据是否过期（例如5分钟）
        require(block.timestamp - lastUpdate < 5 minutes, "Price data expired");
        return price;
    }
    
    // 紧急暂停机制
    bool public paused = false;
    
    function setPaused(bool _paused) external onlyOwner {
        paused = _paused;
    }
    
    modifier whenNotPaused() {
        require(!paused, "Contract is paused");
        _;
    }
}

// 简化的去中心化预言机网络实现
contract DecentralizedOracle {
    struct OracleNode {
        address nodeAddress;
        uint256 stake; // 节点质押金额
        uint256 accuracyScore; // 准确性评分
        bool isActive;
    }
    
    struct PriceReport {
        uint256 price;
        uint256 timestamp;
        mapping(address => bool) hasReported;
        mapping(address => uint256) nodeReports;
        uint256 reportCount;
        bool finalized;
    }
    
    // 预言机节点集合
    mapping(address => OracleNode) public oracleNodes;
    address[] public activeNodes;
    
    // 当前轮次的价格报告
    uint256 public currentRound = 0;
    mapping(uint256 => PriceReport) public priceReports;
    
    // 配置参数
    uint256 public minStake = 1 ether;
    uint256 public minNodes = 5;
    uint256 public maxDeviation = 10; // 最大允许偏差百分比
    uint256 public reportTimeout = 5 minutes;
    
    // 事件
    event NodeRegistered(address indexed node, uint256 stake);
    event PriceReported(address indexed node, uint256 price);
    event PriceFinalized(uint256 indexed round, uint256 price);
    event Slashed(address indexed node, uint256 amount);
    
    // 注册预言机节点
    function registerOracleNode() external payable {
        require(msg.value >= minStake, "Insufficient stake");
        require(!oracleNodes[msg.sender].isActive, "Already registered");
        
        oracleNodes[msg.sender] = OracleNode({
            nodeAddress: msg.sender,
            stake: msg.value,
            accuracyScore: 100,
            isActive: true
        });
        
        activeNodes.push(msg.sender);
        emit NodeRegistered(msg.sender, msg.value);
    }
    
    // 提交价格报告
    function reportPrice(uint256 _price) external {
        require(oracleNodes[msg.sender].isActive, "Not an active oracle node");
        require(!priceReports[currentRound].hasReported[msg.sender], "Already reported");
        
        // 记录节点报告
        priceReports[currentRound].hasReported[msg.sender] = true;
        priceReports[currentRound].nodeReports[msg.sender] = _price;
        priceReports[currentRound].reportCount++;
        
        emit PriceReported(msg.sender, _price);
        
        // 检查是否达到最终确定条件
        if (priceReports[currentRound].reportCount >= minNodes && !priceReports[currentRound].finalized) {
            finalizePrice();
        }
    }
    
    // 最终确定价格
    function finalizePrice() internal {
        PriceReport storage report = priceReports[currentRound];
        require(!report.finalized, "Already finalized");
        
        // 收集所有报告的价格
        uint256[] memory prices = new uint256[](activeNodes.length);
        uint256 validPricesCount = 0;
        uint256 totalPrice = 0;
        
        for (uint i = 0; i < activeNodes.length; i++) {
            address node = activeNodes[i];
            if (report.hasReported[node]) {
                prices[validPricesCount] = report.nodeReports[node];
                validPricesCount++;
                totalPrice += report.nodeReports[node];
            }
        }
        
        // 检查是否有足够的节点报告
        require(validPricesCount >= minNodes, "Not enough reports");
        
        // 计算中位数和平均值
        sortPrices(prices, validPricesCount);
        uint256 medianPrice = prices[validPricesCount / 2];
        uint256 averagePrice = totalPrice / validPricesCount;
        
        // 使用中位数作为最终价格（更能抵抗极端值）
        uint256 finalPrice = medianPrice;
        
        // 验证偏差
        for (uint i = 0; i < activeNodes.length; i++) {
            address node = activeNodes[i];
            if (report.hasReported[node]) {
                uint256 nodePrice = report.nodeReports[node];
                uint256 deviation = calculateDeviation(nodePrice, medianPrice);
                
                // 对偏离过大的节点进行惩罚
                if (deviation > maxDeviation) {
                    slashNode(node, nodePrice, medianPrice);
                } else {
                    // 奖励准确报告的节点
                    rewardNode(node);
                }
            }
        }
        
        // 更新状态
        report.finalized = true;
        report.price = finalPrice;
        report.timestamp = block.timestamp;
        
        emit PriceFinalized(currentRound, finalPrice);
        
        // 准备下一轮
        currentRound++;
    }
    
    // 计算价格偏差
    function calculateDeviation(uint256 price1, uint256 price2) internal pure returns (uint256) {
        if (price1 == price2) return 0;
        
        uint256 diff = price1 > price2 ? price1 - price2 : price2 - price1;
        return (diff * 100) / price2;
    }
    
    // 惩罚偏离过大的节点
    function slashNode(address node, uint256 reportedPrice, uint256 actualPrice) internal {
        OracleNode storage oracleNode = oracleNodes[node];
        uint256 slashAmount = (oracleNode.stake * 5) / 100; // 削减5%的质押
        
        // 更新质押和评分
        oracleNode.stake -= slashAmount;
        if (oracleNode.accuracyScore > 20) {
            oracleNode.accuracyScore -= 20;
        } else {
            oracleNode.accuracyScore = 10;
        }
        
        // 如果质押低于最低要求，将节点设为非活跃
        if (oracleNode.stake < minStake) {
            oracleNode.isActive = false;
            // 从活跃节点列表中移除
            removeActiveNode(node);
        }
        
        emit Slashed(node, slashAmount);
    }
    
    // 奖励准确报告的节点
    function rewardNode(address node) internal {
        OracleNode storage oracleNode = oracleNodes[node];
        // 增加准确性评分
        if (oracleNode.accuracyScore < 100) {
            oracleNode.accuracyScore += 5;
        }
    }
    
    // 从活跃节点列表中移除节点
    function removeActiveNode(address node) internal {
        for (uint i = 0; i < activeNodes.length; i++) {
            if (activeNodes[i] == node) {
                activeNodes[i] = activeNodes[activeNodes.length - 1];
                activeNodes.pop();
                break;
            }
        }
    }
    
    // 排序价格数组（冒泡排序简化版）
    function sortPrices(uint256[] memory prices, uint256 count) internal pure {
        for (uint i = 0; i < count - 1; i++) {
            for (uint j = 0; j < count - i - 1; j++) {
                if (prices[j] > prices[j + 1]) {
                    (prices[j], prices[j + 1]) = (prices[j + 1], prices[j]);
                }
            }
        }
    }
    
    // 获取最新价格
    function getLatestPrice() external view returns (uint256) {
        require(currentRound > 0, "No price data available");
        
        PriceReport storage report = priceReports[currentRound - 1];
        require(report.finalized, "Price not finalized");
        require(block.timestamp - report.timestamp < reportTimeout, "Price data expired");
        
        return report.price;
    }
}

// 预言机数据聚合算法示例
function aggregatePriceData(nodeReports) {
  // 1. 过滤异常值
  const filteredReports = filterOutliers(nodeReports);
  
  // 2. 计算中位数
  const median = calculateMedian(filteredReports);
  
  // 3. 计算加权平均值
  const weightedAvg = calculateWeightedAverage(filteredReports);
  
  // 4. 最终聚合结果（结合中位数和加权平均）
  const finalPrice = (median * 0.7 + weightedAvg * 0.3).toFixed(2);
  
  return parseFloat(finalPrice);
}

// 过滤异常值函数
function filterOutliers(reports) {
  // 复制数组并排序
  const sorted = [...reports].sort((a, b) => a.price - b.price);
  const len = sorted.length;
  
  // 计算四分位数
  const q1 = sorted[Math.floor(len * 0.25)].price;
  const q3 = sorted[Math.floor(len * 0.75)].price;
  const iqr = q3 - q1;
  
  // 定义异常值边界
  const lowerBound = q1 - 1.5 * iqr;
  const upperBound = q3 + 1.5 * iqr;
  
  // 过滤异常值
  return reports.filter(report => 
    report.price >= lowerBound && report.price <= upperBound
  );
}

// 计算中位数
function calculateMedian(filteredReports) {
  const sorted = [...filteredReports].sort((a, b) => a.price - b.price);
  const len = sorted.length;
  
  if (len % 2 === 0) {
    // 偶数个元素，取中间两个的平均值
    return (sorted[len/2 - 1].price + sorted[len/2].price) / 2;
  } else {
    // 奇数个元素，取中间值
    return sorted[Math.floor(len/2)].price;
  }
}

// 计算加权平均值
function calculateWeightedAverage(filteredReports) {
  let totalWeight = 0;
  let weightedSum = 0;
  
  filteredReports.forEach(report => {
    // 权重基于节点质押和声誉
    const weight = report.stake * (report.reputation / 100);
    totalWeight += weight;
    weightedSum += report.price * weight;
  });
  
  return weightedSum / totalWeight;
}

1. 攻击者获取大量预言机节点控制权或操纵数据源
2. 在DeFi协议中建立大额仓位
3. 提交错误的价格数据
4. 利用错误价格执行套利或清算操作
5. 获利后迅速撤资

// 闪电贷攻击与预言机操纵结合的简化示例
function flashLoanAttack(address lendingPool, address token, uint256 amount) external {
    // 步骤1: 获取闪电贷
    bytes memory data = abi.encode(token, amount);
    ILendingPool(lendingPool).flashLoan(address(this), token, amount, data);
}

// 闪电贷回调函数
function executeOperation(address token, uint256 amount, uint256 fee, bytes calldata data) external returns (bool) {
    // 解码参数
    (address asset, uint256 borrowAmount) = abi.decode(data, (address, uint256));
    
    // 步骤2: 在DEX上进行大额交易，操纵价格
    uint256 tokenBalance = IERC20(asset).balanceOf(address(this));
    IERC20(asset).approve(address(dex), tokenBalance);
    
    // 进行大额交易，使价格大幅波动
    if (attackDirection == AttackDirection.UP) {
        // 买入大量资产，推高价格
        dex.swapETHForExactTokens(tokenBalance, path, address(this), block.timestamp + 1);
    } else {
        // 卖出大量资产，压低价格
        dex.swapExactTokensForETH(tokenBalance, 1, path, address(this), block.timestamp + 1);
    }
    
    // 步骤3: 利用操纵后的预言机价格与DeFi协议交互
    // 例如，使用错误的低价格作为抵押品获取贷款，或触发清算
    if (attackType == AttackType.LIQUIDATION) {
        liquidatePosition();
    } else if (attackType == AttackType.BORROWING) {
        borrowWithManipulatedCollateral();
    }
    
    // 步骤4: 获利并归还闪电贷
    uint256 amountOwed = amount + fee;
    IERC20(asset).approve(address(msg.sender), amountOwed);
    
    return true;
}

// 带有时间加权和心跳机制的预言机客户端
contract SecureOracleClient {
    AggregatorV3Interface internal priceFeed;
    uint256 public lastUpdateTime;
    uint256 public lastPrice;
    uint256 public constant HEARTBEAT = 1 hours; // 预言机数据的最大有效时间
    uint256 public constant MAX_DEVIATION = 5; // 允许的最大价格偏差百分比
    
    event PriceUpdated(uint256 newPrice, uint256 timestamp);
    event OracleDataExpired(uint256 lastValidTimestamp);
    
    constructor(address _priceFeedAddress) {
        priceFeed = AggregatorV3Interface(_priceFeedAddress);
        updatePrice();
    }
    
    // 更新价格并验证其有效性
    function updatePrice() public returns (uint256) {
        (,int256 price,,uint256 timestamp,) = priceFeed.latestRoundData();
        
        require(price > 0, "Invalid price");
        require(timestamp > 0, "Invalid timestamp");
        
        uint256 currentPrice = uint256(price);
        
        // 检查数据是否过期
        if (block.timestamp - timestamp > HEARTBEAT) {
            emit OracleDataExpired(timestamp);
            // 可以选择使用最后有效值或拒绝更新
            return lastPrice;
        }
        
        // 如果有历史价格，检查偏差是否合理
        if (lastPrice > 0) {
            uint256 deviation = calculateDeviation(currentPrice, lastPrice);
            if (deviation > MAX_DEVIATION) {
                // 价格变化过大，可能被操纵
                // 1. 可以设置安全模式
                // 2. 或使用时间加权平均
                currentPrice = calculateTimeWeightedPrice(currentPrice);
            }
        }
        
        lastPrice = currentPrice;
        lastUpdateTime = block.timestamp;
        
        emit PriceUpdated(currentPrice, timestamp);
        return currentPrice;
    }
    
    // 计算价格偏差
    function calculateDeviation(uint256 newPrice, uint256 oldPrice) internal pure returns (uint256) {
        if (newPrice == oldPrice) return 0;
        
        uint256 diff = newPrice > oldPrice ? newPrice - oldPrice : oldPrice - newPrice;
        return (diff * 100) / oldPrice;
    }
    
    // 计算时间加权价格
    function calculateTimeWeightedPrice(uint256 newPrice) internal view returns (uint256) {
        // 如果距离上次更新时间很短，给予新价格较低权重
        uint256 timeSinceLastUpdate = block.timestamp - lastUpdateTime;
        uint256 maxInterval = 1 hours;
        
        // 时间间隔越长，新价格权重越高
        uint256 newPriceWeight = (timeSinceLastUpdate * 100) / maxInterval;
        if (newPriceWeight > 100) newPriceWeight = 100;
        
        uint256 oldPriceWeight = 100 - newPriceWeight;
        
        // 计算加权平均价格
        return (newPrice * newPriceWeight + lastPrice * oldPriceWeight) / 100;
    }
    
    // 获取当前有效价格
    function getValidPrice() public view returns (uint256) {
        // 检查最后更新的价格是否过期
        if (block.timestamp - lastUpdateTime > HEARTBEAT) {
            // 可以抛出异常或返回最后有效值，取决于安全需求
            revert("Oracle data expired, call updatePrice() first");
        }
        
        return lastPrice;
    }
    
    // 安全地执行需要价格数据的操作
    function executeWithPriceValidation(bytes calldata data) external {
        // 确保先更新价格
        uint256 currentPrice = updatePrice();
        
        // 使用当前价格执行操作
        // ...
    }
}

// 多源预言机客户端实现
contract MultiOracleClient {
    // 定义多个预言机接口
    AggregatorV3Interface internal primaryOracle;
    AggregatorV3Interface internal secondaryOracle;
    AggregatorV3Interface internal tertiaryOracle;
    
    // 配置参数
    uint256 public constant HEARTBEAT = 1 hours;
    uint256 public constant MAX_DEVIATION = 3; // 预言机之间的最大允许偏差
    uint256 public constant MIN_AGREEMENT = 2; // 至少需要多少个预言机数据一致
    
    // 事件
    event PriceUpdated(uint256 price, uint8 oracleCount);
    event OracleDisagreement(uint256[] prices);
    event FallbackActivated(string reason);
    
    constructor(address _primary, address _secondary, address _tertiary) {
        primaryOracle = AggregatorV3Interface(_primary);
        secondaryOracle = AggregatorV3Interface(_secondary);
        tertiaryOracle = AggregatorV3Interface(_tertiary);
    }
    
    // 获取最新有效价格，需要多个预言机数据一致
    function getLatestValidPrice() public view returns (uint256) {
        // 获取三个预言机的最新价格
        (uint256 primaryPrice, bool primaryValid) = getOraclePrice(primaryOracle);
        (uint256 secondaryPrice, bool secondaryValid) = getOraclePrice(secondaryOracle);
        (uint256 tertiaryPrice, bool tertiaryValid) = getOraclePrice(tertiaryOracle);
        
        // 收集有效价格
        uint256[] memory validPrices = new uint256[](3);
        uint8 validCount = 0;
        
        if (primaryValid) validPrices[validCount++] = primaryPrice;
        if (secondaryValid) validPrices[validCount++] = secondaryPrice;
        if (tertiaryValid) validPrices[validCount++] = tertiaryPrice;
        
        // 检查是否有足够的有效预言机
        require(validCount >= MIN_AGREEMENT, "Insufficient valid oracles");
        
        // 验证预言机之间的一致性
        if (!validateOracleAgreement(validPrices, validCount)) {
            revert("Oracle disagreement detected");
        }
        
        // 返回中位数价格
        return calculateMedian(validPrices, validCount);
    }
    
    // 从单个预言机获取价格并验证其有效性
    function getOraclePrice(AggregatorV3Interface oracle) internal view returns (uint256, bool) {
        try oracle.latestRoundData() returns (
            uint80 roundID,
            int256 price,
            uint256 startedAt,
            uint256 timeStamp,
            uint80 answeredInRound
        ) {
            // 验证数据有效性
            if (price <= 0) return (0, false);
            if (timeStamp == 0) return (0, false);
            if (block.timestamp - timeStamp > HEARTBEAT) return (0, false);
            if (answeredInRound < roundID) return (0, false);
            
            return (uint256(price), true);
        } catch {
            // 预言机调用失败
            return (0, false);
        }
    }
    
    // 验证多个预言机价格是否一致
    function validateOracleAgreement(uint256[] memory prices, uint8 count) internal pure returns (bool) {
        // 计算平均值
        uint256 sum = 0;
        for (uint8 i = 0; i < count; i++) {
            sum += prices[i];
        }
        uint256 average = sum / count;
        
        // 检查每个价格是否在允许的偏差范围内
        for (uint8 i = 0; i < count; i++) {
            uint256 deviation = calculateDeviation(prices[i], average);
            if (deviation > MAX_DEVIATION) {
                return false;
            }
        }
        
        return true;
    }
    
    // 计算价格偏差
    function calculateDeviation(uint256 price1, uint256 price2) internal pure returns (uint256) {
        if (price1 == price2) return 0;
        
        uint256 diff = price1 > price2 ? price1 - price2 : price2 - price1;
        return (diff * 100) / price2;
    }
    
    // 计算中位数价格
    function calculateMedian(uint256[] memory prices, uint8 count) internal pure returns (uint256) {
        // 排序数组
        for (uint8 i = 0; i < count - 1; i++) {
            for (uint8 j = 0; j < count - i - 1; j++) {
                if (prices[j] > prices[j + 1]) {
                    (prices[j], prices[j + 1]) = (prices[j + 1], prices[j]);
                }
            }
        }
        
        // 返回中位数
        if (count % 2 == 0) {
            return (prices[count/2 - 1] + prices[count/2]) / 2;
        } else {
            return prices[count/2];
        }
    }
    
    // 带有安全检查的价格更新函数
    function updatePrice() external returns (uint256) {
        try {
            uint256 price = getLatestValidPrice();
            emit PriceUpdated(price, 3);
            return price;
        } catch Error(string memory reason) {
            // 触发回退机制
            emit FallbackActivated(reason);
            // 可以实现紧急回退逻辑
            revert(reason);
        }
    }
    
    // 紧急暂停功能
    bool public paused = false;
    address public admin;
    
    constructor() {
        admin = msg.sender;
    }
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "Not authorized");
        _;
    }
    
    modifier whenNotPaused() {
        require(!paused, "Contract is paused");
        _;
    }
    
    function setPaused(bool _paused) external onlyAdmin {
        paused = _paused;
    }
}

// 价格偏差检测合约
contract PriceDeviationGuard {
    uint256 public lastPrice;
    uint256 public lastUpdateTime;
    uint256 public maxDeviationPercent; // 最大允许偏差百分比
    uint256 public minUpdateInterval;   // 最小更新间隔
    uint256 public maxUpdateInterval;   // 最大更新间隔
    
    event PriceUpdateRejected(uint256 proposedPrice, uint256 deviation);
    event PriceUpdated(uint256 newPrice, uint256 timestamp);
    
    constructor(uint256 _maxDeviationPercent, uint256 _minInterval, uint256 _maxInterval) {
        maxDeviationPercent = _maxDeviationPercent;
        minUpdateInterval = _minInterval;
        maxUpdateInterval = _maxInterval;
    }
    
    // 验证并更新价格
    function validateAndUpdatePrice(uint256 _newPrice) external returns (bool) {
        // 检查更新间隔
        require(block.timestamp >= lastUpdateTime + minUpdateInterval, "Update too frequent");
        
        // 如果存在历史价格，检查偏差
        if (lastPrice > 0) {
            uint256 deviation = calculateDeviation(_newPrice, lastPrice);
            
            // 如果偏差过大且更新不频繁，拒绝更新
            bool updateAfterLongInterval = block.timestamp > lastUpdateTime + maxUpdateInterval;
            if (deviation > maxDeviationPercent && !updateAfterLongInterval) {
                emit PriceUpdateRejected(_newPrice, deviation);
                return false;
            }
        }
        
        // 更新价格
        lastPrice = _newPrice;
        lastUpdateTime = block.timestamp;
        
        emit PriceUpdated(_newPrice, block.timestamp);
        return true;
    }
    
    // 计算偏差百分比
    function calculateDeviation(uint256 newPrice, uint256 oldPrice) internal pure returns (uint256) {
        if (newPrice == oldPrice) return 0;
        
        uint256 diff = newPrice > oldPrice ? newPrice - oldPrice : oldPrice - newPrice;
        return (diff * 100) / oldPrice;
    }
    
    // 获取当前有效价格
    function getCurrentPrice() external view returns (uint256) {
        require(block.timestamp <= lastUpdateTime + maxUpdateInterval, "Price data expired");
        return lastPrice;
    }
    
    // 紧急更新机制（由管理员使用）
    address public admin;
    
    constructor() {
        admin = msg.sender;
    }
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "Not authorized");
        _;
    }
    
    function emergencyUpdatePrice(uint256 _newPrice) external onlyAdmin {
        lastPrice = _newPrice;
        lastUpdateTime = block.timestamp;
        emit PriceUpdated(_newPrice, block.timestamp);
    }
}

// 时间加权平均价格（TWAP）实现
contract TWAPOracle {
    // 价格记录
    struct PriceRecord {
        uint256 price;
        uint256 timestamp;
    }
    
    // 配置参数
    uint256 public constant MAX_HISTORY = 10;      // 最大历史记录数量
    uint256 public constant MIN_UPDATE_INTERVAL = 1 hours; // 最小更新间隔
    uint256 public constant MAX_RECORD_AGE = 24 hours;    // 记录最大有效期
    
    // 状态变量
    PriceRecord[] public priceHistory;
    uint256 public lastUpdateTime;
    address public admin;
    
    event PriceAdded(uint256 price, uint256 timestamp);
    event TWAPCalculated(uint256 twap, uint256 recordCount);
    
    constructor() {
        admin = msg.sender;
    }
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "Not authorized");
        _;
    }
    
    // 添加新价格
    function addPrice(uint256 _price) external onlyAdmin {
        require(_price > 0, "Invalid price");
        require(block.timestamp >= lastUpdateTime + MIN_UPDATE_INTERVAL, "Update too frequent");
        
        // 添加新记录
        priceHistory.push(PriceRecord({
            price: _price,
            timestamp: block.timestamp
        }));
        
        // 维护历史记录数量
        if (priceHistory.length > MAX_HISTORY) {
            // 移除最旧的记录
            for (uint i = 1; i < priceHistory.length; i++) {
                priceHistory[i-1] = priceHistory[i];
            }
            priceHistory.pop();
        }
        
        lastUpdateTime = block.timestamp;
        emit PriceAdded(_price, block.timestamp);
    }
    
    // 计算时间加权平均价格
    function calculateTWAP() public view returns (uint256) {
        require(priceHistory.length > 0, "No price history available");
        
        // 过滤过期记录并计算加权平均
        uint256 totalWeightedPrice = 0;
        uint256 totalWeight = 0;
        uint256 currentTime = block.timestamp;
        
        for (uint i = 0; i < priceHistory.length; i++) {
            PriceRecord memory record = priceHistory[i];
            
            // 跳过过期记录
            if (currentTime - record.timestamp > MAX_RECORD_AGE) {
                continue;
            }
            
            // 计算权重（基于记录的时效性，越新权重越高）
            uint256 age = currentTime - record.timestamp;
            uint256 weight = MAX_RECORD_AGE - age + 1; // +1 确保权重不会为0
            
            totalWeightedPrice += record.price * weight;
            totalWeight += weight;
        }
        
        require(totalWeight > 0, "No valid price records");
        
        return totalWeightedPrice / totalWeight;
    }
    
    // 获取当前TWAP
    function getCurrentTWAP() external view returns (uint256) {
        uint256 twap = calculateTWAP();
        emit TWAPCalculated(twap, priceHistory.length);
        return twap;
    }
    
    // 清除过期记录
    function cleanExpiredRecords() external {
        uint256 currentTime = block.timestamp;
        uint256 validCount = 0;
        
        // 过滤有效记录
        for (uint i = 0; i < priceHistory.length; i++) {
            if (currentTime - priceHistory[i].timestamp <= MAX_RECORD_AGE) {
                if (validCount < i) {
                    priceHistory[validCount] = priceHistory[i];
                }
                validCount++;
            }
        }
        
        // 移除过期记录
        while (priceHistory.length > validCount) {
            priceHistory.pop();
        }
    }
    
    // 获取价格历史记录数
    function getHistoryCount() external view returns (uint256) {
        return priceHistory.length;
    }
    
    // 紧急清除历史记录
    function clearHistory() external onlyAdmin {
        delete priceHistory;
    }
}

区块链应用层
  |
安全验证层（偏差检测、时间检查、一致性验证）
  |
预言机聚合层（多源数据聚合、异常值过滤、加权平均）
  |
预言机网络层（Chainlink、Band Protocol、API3等）
  |
数据源层（交易所API、价格索引、链上数据）

// 预言机失效转移管理器
class OracleFailoverManager {
  constructor(config) {
    this.oracles = config.oracles;
    this.currentOracleIndex = 0;
    this.failureThreshold = config.failureThreshold || 3;
    this.failureCount = 0;
    this.recoveryTimeout = config.recoveryTimeout || 3600000; // 1小时
    this.lastFailureTime = 0;
    this.healthCheckInterval = config.healthCheckInterval || 60000; // 1分钟
    
    // 启动健康检查
    this.startHealthCheck();
  }
  
  // 获取当前活跃的预言机
  getActiveOracle() {
    return this.oracles[this.currentOracleIndex];
  }
  
  // 获取价格，如果当前预言机失败则切换到下一个
  async getPrice() {
    try {
      const oracle = this.getActiveOracle();
      const price = await oracle.getLatestPrice();
      
      // 验证价格有效性
      if (!this.isValidPrice(price)) {
        throw new Error('Invalid price received');
      }
      
      // 重置失败计数
      this.failureCount = 0;
      return price;
    } catch (error) {
      console.error(`Oracle ${this.currentOracleIndex} failed:`, error.message);
      this.handleOracleFailure();
      
      // 递归调用，尝试下一个预言机
      return this.getPrice();
    }
  }
  
  // 处理预言机失败
  handleOracleFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    
    // 如果达到失败阈值，切换到下一个预言机
    if (this.failureCount >= this.failureThreshold) {
      this.switchToNextOracle();
    }
  }
  
  // 切换到下一个预言机
  switchToNextOracle() {
    this.currentOracleIndex = (this.currentOracleIndex + 1) % this.oracles.length;
    this.failureCount = 0;
    console.log(`Switched to Oracle ${this.currentOracleIndex}`);
    
    // 触发切换事件
    this.emit('oracleSwitched', this.currentOracleIndex);
  }
  
  // 验证价格有效性
  isValidPrice(price) {
    if (typeof price !== 'number' || isNaN(price) || price <= 0) {
      return false;
    }
    
    // 可以添加更多验证逻辑，如价格范围检查等
    return true;
  }
  
  // 启动健康检查
  startHealthCheck() {
    setInterval(async () => {
      try {
        const price = await this.getPrice();
        console.log(`Health check: Oracle ${this.currentOracleIndex} is healthy, price: ${price}`);
        
        // 尝试恢复到主预言机（如果已经过了恢复超时）
        if (this.currentOracleIndex > 0 && 
            Date.now() - this.lastFailureTime > this.recoveryTimeout) {
          console.log('Attempting to switch back to primary oracle');
          this.currentOracleIndex = 0;
          this.failureCount = 0;
        }
      } catch (error) {
        console.error('Health check failed:', error.message);
      }
    }, this.healthCheckInterval);
  }
  
  // 模拟事件触发
  emit(event, data) {
    if (this.listeners && this.listeners[event]) {
      this.listeners[event].forEach(callback => callback(data));
    }
  }
  
  // 添加事件监听器
  on(event, callback) {
    if (!this.listeners) this.listeners = {};
    if (!this.listeners[event]) this.listeners[event] = [];
    this.listeners[event].push(callback);
  }
}

// 使用示例
const oracleManager = new OracleFailoverManager({
  oracles: [
    new ChainlinkOracle('BTC/USD'),
    new BandProtocolOracle('BTC/USD'),
    new API3Oracle('BTC/USD')
  ],
  failureThreshold: 2,
  healthCheckInterval: 30000
});

// 监听预言机切换事件
oracleManager.on('oracleSwitched', (oracleIndex) => {
  console.log(`ALERT: System switched to backup oracle ${oracleIndex}`);
  // 可以发送通知或执行其他操作
});

// 获取价格
async function getSecurePrice() {
  try {
    const price = await oracleManager.getPrice();
    console.log(`Secure price: ${price}`);
    return price;
  } catch (error) {
    console.error('Failed to get secure price:', error);
    // 实现紧急处理逻辑
  }
}

// 预言机安全风险评估工具
class OracleRiskAssessor {
  constructor(oracleConfig) {
    this.oracleConfig = oracleConfig;
    this.riskFactors = {
      decentralization: this.assessDecentralization(),
      dataSources: this.assessDataSources(),
      updateFrequency: this.assessUpdateFrequency(),
      validationMechanism: this.assessValidationMechanism(),
      failoverSystem: this.assessFailoverSystem(),
      historicalReliability: this.assessHistoricalReliability()
    };
  }
  
  // 评估去中心化程度
  assessDecentralization() {
    const { nodeCount, geographicDistribution, stakeRequirement } = this.oracleConfig;
    
    let score = 0;
    
    // 节点数量评分
    if (nodeCount >= 100) score += 30;
    else if (nodeCount >= 50) score += 25;
    else if (nodeCount >= 20) score += 20;
    else if (nodeCount >= 10) score += 15;
    else if (nodeCount >= 5) score += 10;
    else score += 5;
    
    // 地理分布评分
    if (geographicDistribution >= 15) score += 25;
    else if (geographicDistribution >= 10) score += 20;
    else if (geographicDistribution >= 5) score += 15;
    else score += 10;
    
    // 质押要求评分
    if (stakeRequirement >= 100000) score += 25;
    else if (stakeRequirement >= 50000) score += 20;
    else if (stakeRequirement >= 10000) score += 15;
    else if (stakeRequirement > 0) score += 10;
    else score += 5;
    
    // 去中心化治理评分
    if (this.oracleConfig.decentralizedGovernance) score += 20;
    else score += 10;
    
    return {
      score,
      rating: this.getRating(score),
      details: `Node count: ${nodeCount}, Geographic regions: ${geographicDistribution}, Stake requirement: ${stakeRequirement}`
    };
  }
  
  // 评估数据源多样性
  assessDataSources() {
    const { dataSourceCount, dataSourceDiversity } = this.oracleConfig;
    
    let score = 0;
    
    // 数据源数量评分
    if (dataSourceCount >= 20) score += 40;
    else if (dataSourceCount >= 10) score += 35;
    else if (dataSourceCount >= 5) score += 30;
    else if (dataSourceCount >= 3) score += 20;
    else if (dataSourceCount >= 2) score += 15;
    else score += 10;
    
    // 数据源多样性评分
    if (dataSourceDiversity >= 80) score += 30;
    else if (dataSourceDiversity >= 60) score += 25;
    else if (dataSourceDiversity >= 40) score += 20;
    else if (dataSourceDiversity >= 20) score += 15;
    else score += 10;
    
    // 数据源类型评分
    if (this.oracleConfig.dataSourceTypes && this.oracleConfig.dataSourceTypes.length >= 3) score += 30;
    else if (this.oracleConfig.dataSourceTypes && this.oracleConfig.dataSourceTypes.length >= 2) score += 25;
    else score += 20;
    
    return {
      score,
      rating: this.getRating(score),
      details: `Data sources: ${dataSourceCount}, Diversity: ${dataSourceDiversity}%`
    };
  }
  
  // 评估更新频率
  assessUpdateFrequency() {
    const { updateFrequency, heartbeat } = this.oracleConfig;
    
    let score = 0;
    
    // 更新频率评分
    if (updateFrequency <= 1) score += 40; // 每秒更新
    else if (updateFrequency <= 5) score += 35; // 每5秒
    else if (updateFrequency <= 30) score += 30; // 每30秒
    else if (updateFrequency <= 60) score += 25; // 每分钟
    else if (updateFrequency <= 300) score += 20; // 每5分钟
    else if (updateFrequency <= 3600) score += 15; // 每小时
    else score += 10; // 更慢
    
    // 心跳机制评分
    if (heartbeat) score += 30;
    else score += 15;
    
    // 异常更新机制评分
    if (this.oracleConfig.anomalyDetection) score += 30;
    else score += 15;
    
    return {
      score,
      rating: this.getRating(score),
      details: `Update frequency: ${updateFrequency}s, Heartbeat: ${heartbeat ? 'Yes' : 'No'}`
    };
  }
  
  // 评估验证机制
  assessValidationMechanism() {
    const { validationMethods } = this.oracleConfig;
    let score = 0;
    
    // 验证方法数量评分
    if (validationMethods && validationMethods.length >= 5) score += 30;
    else if (validationMethods && validationMethods.length >= 4) score += 25;
    else if (validationMethods && validationMethods.length >= 3) score += 20;
    else if (validationMethods && validationMethods.length >= 2) score += 15;
    else if (validationMethods && validationMethods.length >= 1) score += 10;
    else score += 5;
    
    // 聚合算法评分
    if (this.oracleConfig.aggregationAlgorithm === 'median') score += 25;
    else if (this.oracleConfig.aggregationAlgorithm === 'weighted') score += 20;
    else if (this.oracleConfig.aggregationAlgorithm === 'average') score += 15;
    else score += 10;
    
    // 异常检测评分
    if (this.oracleConfig.outlierDetection) score += 25;
    else score += 15;
    
    // 共识机制评分
    if (this.oracleConfig.consensusMechanism) score += 20;
    else score += 10;
    
    return {
      score,
      rating: this.getRating(score),
      details: `Validation methods: ${validationMethods ? validationMethods.join(', ') : 'None'}`
    };
  }
  
  // 评估故障转移系统
  assessFailoverSystem() {
    const { failoverMechanism, backupOracles } = this.oracleConfig;
    let score = 0;
    
    // 故障转移机制评分
    if (failoverMechanism === 'automatic') score += 40;
    else if (failoverMechanism === 'manual') score += 20;
    else score += 10;
    
    // 备用预言机评分
    if (backupOracles && backupOracles.length >= 3) score += 30;
    else if (backupOracles && backupOracles.length >= 2) score += 25;
    else if (backupOracles && backupOracles.length >= 1) score += 20;
    else score += 10;
    
    // 监控系统评分
    if (this.oracleConfig.monitoringSystem) score += 30;
    else score += 15;
    
    return {
      score,
      rating: this.getRating(score),
      details: `Failover: ${failoverMechanism}, Backup oracles: ${backupOracles ? backupOracles.length : 0}`
    };
  }
  
  // 评估历史可靠性
  assessHistoricalReliability() {
    const { uptime, historicalFailures, incidentResponseTime } = this.oracleConfig;
    let score = 0;
    
    // 正常运行时间评分
    if (uptime >= 99.99) score += 40;
    else if (uptime >= 99.9) score += 35;
    else if (uptime >= 99.5) score += 30;
    else if (uptime >= 99) score += 25;
    else if (uptime >= 98) score += 20;
    else score += 15;
    
    // 历史故障评分
    if (historicalFailures === 0) score += 30;
    else if (historicalFailures === 1) score += 25;
    else if (historicalFailures <= 3) score += 20;
    else if (historicalFailures <= 5) score += 15;
    else score += 10;
    
    // 事件响应时间评分
    if (incidentResponseTime <= 10) score += 30; // 10分钟内
    else if (incidentResponseTime <= 30) score += 25; // 30分钟内
    else if (incidentResponseTime <= 60) score += 20; // 1小时内
    else if (incidentResponseTime <= 120) score += 15; // 2小时内
    else score += 10; // 超过2小时
    
    return {
      score,
      rating: this.getRating(score),
      details: `Uptime: ${uptime}%, Historical failures: ${historicalFailures}`
    };
  }
  
  // 获取评级
  getRating(score) {
    if (score >= 90) return 'A+';
    else if (score >= 80) return 'A';
    else if (score >= 70) return 'B+';
    else if (score >= 60) return 'B';
    else if (score >= 50) return 'C+';
    else if (score >= 40) return 'C';
    else if (score >= 30) return 'D';
    else return 'F';
  }
  
  // 计算总体风险评分
  calculateOverallRiskScore() {
    let totalScore = 0;
    let totalWeight = 0;
    
    // 各风险因素权重
    const weights = {
      decentralization: 0.25,
      dataSources: 0.20,
      updateFrequency: 0.15,
      validationMechanism: 0.20,
      failoverSystem: 0.10,
      historicalReliability: 0.10
    };
    
    // 计算加权总分
    for (const [factor, data] of Object.entries(this.riskFactors)) {
      totalScore += data.score * weights[factor];
      totalWeight += weights[factor];
    }
    
    const overallScore = totalScore / totalWeight;
    
    return {
      overallScore: overallScore.toFixed(2),
      overallRating: this.getRating(overallScore),
      riskLevel: this.getRiskLevel(overallScore),
      recommendations: this.generateRecommendations()
    };
  }
  
  // 获取风险等级
  getRiskLevel(score) {
    if (score >= 80) return 'Low Risk';
    else if (score >= 70) return 'Moderate Risk';
    else if (score >= 60) return 'Medium Risk';
    else if (score >= 50) return 'High Risk';
    else return 'Critical Risk';
  }
  
  // 生成安全建议
  generateRecommendations() {
    const recommendations = [];
    
    // 基于各因素评分生成建议
    if (this.riskFactors.decentralization.score < 70) {
      recommendations.push('Increase node count and geographic distribution');
      recommendations.push('Implement or increase stake requirements');
    }
    
    if (this.riskFactors.dataSources.score < 70) {
      recommendations.push('Add more diverse data sources');
      recommendations.push('Ensure data sources are from different providers');
    }
    
    if (this.riskFactors.updateFrequency.score < 70) {
      recommendations.push('Increase update frequency');
      recommendations.push('Implement heartbeat mechanism if not present');
    }
    
    if (this.riskFactors.validationMechanism.score < 70) {
      recommendations.push('Implement median aggregation');
      recommendations.push('Add outlier detection mechanisms');
    }
    
    if (this.riskFactors.failoverSystem.score < 70) {
      recommendations.push('Implement automatic failover');
      recommendations.push('Add backup oracles');
    }
    
    if (this.riskFactors.historicalReliability.score < 70) {
      recommendations.push('Improve monitoring and incident response');
      recommendations.push('Conduct regular security audits');
    }
    
    return recommendations;
  }
  
  // 生成详细报告
  generateDetailedReport() {
    const overall = this.calculateOverallRiskScore();
    
    return {
      oracleConfig: this.oracleConfig,
      riskFactors: this.riskFactors,
      overallAssessment: overall,
      generatedAt: new Date().toISOString()
    };
  }
}

// 使用示例
const oracleConfig = {
  nodeCount: 150,
  geographicDistribution: 20,
  stakeRequirement: 100000,
  decentralizedGovernance: true,
  dataSourceCount: 15,
  dataSourceDiversity: 75,
  dataSourceTypes: ['exchanges', 'indexes', 'chainData'],
  updateFrequency: 30,
  heartbeat: true,
  anomalyDetection: true,
  validationMethods: ['median', 'deviation', 'timeCheck', 'consensus'],
  aggregationAlgorithm: 'median',
  outlierDetection: true,
  consensusMechanism: 'thresholdSignature',
  failoverMechanism: 'automatic',
  backupOracles: 2,
  monitoringSystem: true,
  uptime: 99.95,
  historicalFailures: 1,
  incidentResponseTime: 15
};

const assessor = new OracleRiskAssessor(oracleConfig);
const report = assessor.generateDetailedReport();
console.log(JSON.stringify(report, null, 2));

// 安全预言机集成的DeFi借贷协议示例
contract SecureDeFiLending {
    // 依赖项
    using SafeMath for uint256;
    
    // 代币接口
    IERC20 public collateralToken;
    IERC20 public loanToken;
    
    // 预言机配置
    MultiOracleClient public oracleClient;
    uint256 public collateralizationRatio = 150; // 150% 抵押率
    uint256 public liquidationThreshold = 130; // 130% 清算阈值
    uint256 public liquidationPenalty = 5; // 5% 清算惩罚
    
    // 用户借贷状态
    struct Borrower {
        uint256 collateralAmount; // 抵押的代币数量
        uint256 borrowedAmount;   // 借入的代币数量
        uint256 lastUpdateTime;   // 上次更新时间
    }
    
    mapping(address => Borrower) public borrowers;
    
    // 事件
    event CollateralDeposited(address indexed user, uint256 amount);
    event LoanTaken(address indexed user, uint256 amount);
    event LoanRepaid(address indexed user, uint256 amount);
    event CollateralWithdrawn(address indexed user, uint256 amount);
    event Liquidation(address indexed liquidator, address indexed borrower, uint256 debt, uint256 collateral);
    event OraclePriceUpdated(uint256 price);
    
    constructor(
        address _collateralToken,
        address _loanToken,
        address _primaryOracle,
        address _secondaryOracle,
        address _tertiaryOracle
    ) {
        collateralToken = IERC20(_collateralToken);
        loanToken = IERC20(_loanToken);
        
        // 初始化多源预言机客户端
        oracleClient = new MultiOracleClient(
            _primaryOracle,
            _secondaryOracle,
            _tertiaryOracle
        );
    }
    
    // 存款抵押品
    function depositCollateral(uint256 _amount) external {
        require(_amount > 0, "Amount must be greater than 0");
        
        // 转移代币
        require(collateralToken.transferFrom(msg.sender, address(this), _amount), "Transfer failed");
        
        // 更新用户状态
        borrowers[msg.sender].collateralAmount = borrowers[msg.sender].collateralAmount.add(_amount);
        borrowers[msg.sender].lastUpdateTime = block.timestamp;
        
        emit CollateralDeposited(msg.sender, _amount);
    }
    
    // 借入资金
    function borrow(uint256 _amount) external {
        require(_amount > 0, "Amount must be greater than 0");
        
        // 获取当前抵押率
        (uint256 currentRatio, uint256 collateralValue, uint256 loanValue) = getCollateralizationRatio(msg.sender);
        
        // 计算新的抵押率
        uint256 newLoanValue = loanValue.add(_amount);
        uint256 newRatio = collateralValue.mul(100).div(newLoanValue);
        
        // 检查是否满足抵押率要求
        require(newRatio >= collateralizationRatio, "Insufficient collateral");
        
        // 更新用户状态
        borrowers[msg.sender].borrowedAmount = borrowers[msg.sender].borrowedAmount.add(_amount);
        borrowers[msg.sender].lastUpdateTime = block.timestamp;
        
        // 发放贷款
        require(loanToken.transfer(msg.sender, _amount), "Transfer failed");
        
        emit LoanTaken(msg.sender, _amount);
    }
    
    // 偿还贷款
    function repay(uint256 _amount) external {
        require(_amount > 0, "Amount must be greater than 0");
        require(_amount <= borrowers[msg.sender].borrowedAmount, "Amount exceeds borrowed");
        
        // 转移代币
        require(loanToken.transferFrom(msg.sender, address(this), _amount), "Transfer failed");
        
        // 更新用户状态
        borrowers[msg.sender].borrowedAmount = borrowers[msg.sender].borrowedAmount.sub(_amount);
        borrowers[msg.sender].lastUpdateTime = block.timestamp;
        
        emit LoanRepaid(msg.sender, _amount);
    }
    
    // 提取抵押品
    function withdrawCollateral(uint256 _amount) external {
        require(_amount > 0, "Amount must be greater than 0");
        require(_amount <= borrowers[msg.sender].collateralAmount, "Amount exceeds collateral");
        
        // 获取当前抵押率
        (uint256 currentRatio, uint256 collateralValue, uint256 loanValue) = getCollateralizationRatio(msg.sender);
        
        // 计算新的抵押率
        uint256 collateralPrice = getCollateralPrice();
        uint256 collateralValueToWithdraw = _amount.mul(collateralPrice);
        uint256 newCollateralValue = collateralValue.sub(collateralValueToWithdraw);
        uint256 newRatio = newCollateralValue.mul(100).div(loanValue);
        
        // 检查是否满足抵押率要求
        require(newRatio >= collateralizationRatio, "Insufficient collateral");
        
        // 更新用户状态
        borrowers[msg.sender].collateralAmount = borrowers[msg.sender].collateralAmount.sub(_amount);
        borrowers[msg.sender].lastUpdateTime = block.timestamp;
        
        // 返还抵押品
        require(collateralToken.transfer(msg.sender, _amount), "Transfer failed");
        
        emit CollateralWithdrawn(msg.sender, _amount);
    }
    
    // 清算功能
    function liquidate(address _borrower) external {
        // 获取抵押率
        (uint256 currentRatio, uint256 collateralValue, uint256 loanValue) = getCollateralizationRatio(_borrower);
        
        // 检查是否达到清算阈值
        require(currentRatio < liquidationThreshold, "Not liquidatable");
        
        // 计算可清算金额（最多清算50%的债务）
        uint256 liquidatableDebt = loanValue.div(2);
        uint256 collateralPrice = getCollateralPrice();
        
        // 计算需要返还的抵押品（包含清算惩罚）
        uint256 collateralToLiquidate = liquidatableDebt
            .mul(100)
            .div(currentRatio)
            .mul(100 + liquidationPenalty)
            .div(100)
            .div(collateralPrice);
        
        // 确保不超过用户的抵押品
        collateralToLiquidate = collateralToLiquidate > borrowers[_borrower].collateralAmount 
            ? borrowers[_borrower].collateralAmount 
            : collateralToLiquidate;
        
        // 更新用户状态
        borrowers[_borrower].borrowedAmount = borrowers[_borrower].borrowedAmount.sub(liquidatableDebt);
        borrowers[_borrower].collateralAmount = borrowers[_borrower].collateralAmount.sub(collateralToLiquidate);
        
        // 转移代币
        require(loanToken.transferFrom(msg.sender, address(this), liquidatableDebt), "Transfer failed");
        require(collateralToken.transfer(msg.sender, collateralToLiquidate), "Transfer failed");
        
        emit Liquidation(msg.sender, _borrower, liquidatableDebt, collateralToLiquidate);
    }
    
    // 获取抵押率
    function getCollateralizationRatio(address _user) public view returns (uint256 ratio, uint256 collateralValue, uint256 loanValue) {
        Borrower memory borrower = borrowers[_user];
        uint256 collateralPrice = getCollateralPrice();
        
        collateralValue = borrower.collateralAmount.mul(collateralPrice);
        loanValue = borrower.borrowedAmount;
        
        if (loanValue == 0) {
            return (type(uint256).max, collateralValue, loanValue); // 无债务时返回最大值
        }
        
        ratio = collateralValue.mul(100).div(loanValue);
        return (ratio, collateralValue, loanValue);
    }
    
    // 获取抵押品价格（通过安全的预言机客户端）
    function getCollateralPrice() public view returns (uint256) {
        return oracleClient.getLatestValidPrice();
    }
    
    // 紧急暂停功能
    bool public paused = false;
    address public admin;
    
    constructor() {
        admin = msg.sender;
    }
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "Not authorized");
        _;
    }
    
    modifier whenNotPaused() {
        require(!paused, "Contract is paused");
        _;
    }
    
    function setPaused(bool _paused) external onlyAdmin {
        paused = _paused;
    }
    
    // 升级抵押率
    function updateCollateralizationRatio(uint256 _newRatio) external onlyAdmin {
        require(_newRatio > 0, "Invalid ratio");
        collateralizationRatio = _newRatio;
    }
    
    // 升级清算阈值
    function updateLiquidationThreshold(uint256 _newThreshold) external onlyAdmin {
        require(_newThreshold > 0 && _newThreshold < collateralizationRatio, "Invalid threshold");
        liquidationThreshold = _newThreshold;
    }
}

预言机安全实施路线图：
1. 需求分析 → 2. 技术选型 → 3. 架构设计 → 4. 安全实现 → 5. 测试验证 → 6. 部署监控 → 7. 持续优化