第七章：借贷协议

// cToken接口 - Compound的核心抽象
interface ICToken {
    // 存款
    function mint(uint mintAmount) external returns (uint);
    
    // 取款
    function redeem(uint redeemTokens) external returns (uint);
    function redeemUnderlying(uint redeemAmount) external returns (uint);
    
    // 借款
    function borrow(uint borrowAmount) external returns (uint);
    
    // 还款
    function repayBorrow(uint repayAmount) external returns (uint);
    
    // 查询函数
    function balanceOf(address owner) external view returns (uint);
    function borrowBalanceStored(address account) external view returns (uint);
    function exchangeRateStored() external view returns (uint);
}

// 稳定币专用的cToken实现
contract CStablecoin is ICToken, ERC20 {
    IERC20 public underlying;  // 底层稳定币
    uint public reserveFactorMantissa;  // 准备金率
    uint public accrualBlockNumber;  // 上次计息区块
    uint public borrowIndex;  // 借款指数
    uint public totalBorrows;  // 总借款
    uint public totalReserves;  // 总准备金
    
    // 关键参数
    uint constant expScale = 1e18;
    uint constant blocksPerYear = 2102400;  // 约15秒一个块
    
    // 利率模型
    IInterestRateModel public interestRateModel;
    
    struct BorrowSnapshot {
        uint principal;  // 本金
        uint interestIndex;  // 借款时的指数
    }
    
    mapping(address => BorrowSnapshot) internal accountBorrows;
    
    // 计算并累积利息
    function accrueInterest() public returns (uint) {
        uint currentBlockNumber = block.number;
        uint accrualBlockNumberPrior = accrualBlockNumber;
        
        if (accrualBlockNumberPrior == currentBlockNumber) {
            return 0;
        }
        
        uint cashPrior = getCashPrior();
        uint borrowsPrior = totalBorrows;
        uint reservesPrior = totalReserves;
        uint borrowIndexPrior = borrowIndex;
        
        // 计算借款利率
        uint borrowRateMantissa = interestRateModel.getBorrowRate(
            cashPrior,
            borrowsPrior,
            reservesPrior
        );
        
        // 计算区块数差
        uint blockDelta = currentBlockNumber - accrualBlockNumberPrior;
        
        // 计算利息因子
        uint simpleInterestFactor = borrowRateMantissa * blockDelta;
        uint interestAccumulated = simpleInterestFactor * borrowsPrior / expScale;
        
        // 更新状态
        totalBorrows = borrowsPrior + interestAccumulated;
        totalReserves = reservesPrior + (interestAccumulated * reserveFactorMantissa / expScale);
        borrowIndex = borrowIndexPrior + (simpleInterestFactor * borrowIndexPrior / expScale);
        accrualBlockNumber = currentBlockNumber;
        
        return interestAccumulated;
    }
    
    // 存款实现
    function mintInternal(uint mintAmount) internal returns (uint) {
        accrueInterest();
        
        // 转入底层代币
        underlying.transferFrom(msg.sender, address(this), mintAmount);
        
        // 计算兑换率
        uint exchangeRateMantissa = exchangeRateStoredInternal();
        uint mintTokens = mintAmount * expScale / exchangeRateMantissa;
        
        // 铸造cToken
        _mint(msg.sender, mintTokens);
        
        return mintTokens;
    }
}

// Aave V3的高级功能
contract AaveV3Pool {
    using WadRayMath for uint256;
    
    // 核心数据结构
    struct ReserveData {
        ReserveConfigurationMap configuration;
        uint128 liquidityIndex;
        uint128 variableBorrowIndex;
        uint128 currentLiquidityRate;
        uint128 currentVariableBorrowRate;
        uint128 currentStableBorrowRate;
        uint40 lastUpdateTimestamp;
        address aTokenAddress;
        address stableDebtTokenAddress;
        address variableDebtTokenAddress;
        address interestRateStrategyAddress;
        uint8 id;
    }
    
    // 效率模式（E-Mode）- 稳定币专用优化
    struct EModeCategory {
        uint16 ltv;  // 贷款价值比
        uint16 liquidationThreshold;  // 清算阈值
        uint16 liquidationBonus;  // 清算奖励
        address priceSource;  // 价格源
        string label;  // 类别标签
    }
    
    mapping(uint8 => EModeCategory) internal _eModeCategories;
    
    // 供应函数 - 支持多种模式
    function supply(
        address asset,
        uint256 amount,
        address onBehalfOf,
        uint16 referralCode
    ) external {
        DataTypes.ReserveData storage reserve = _reserves[asset];
        
        // 验证
        ValidationLogic.validateSupply(reserve, amount);
        
        // 更新状态
        reserve.updateState();
        reserve.updateInterestRates(asset, amount, 0);
        
        // 转入资产
        IERC20(asset).safeTransferFrom(msg.sender, reserve.aTokenAddress, amount);
        
        // 铸造aToken
        IAToken(reserve.aTokenAddress).mint(onBehalfOf, amount, reserve.liquidityIndex);
        
        emit Supply(asset, msg.sender, onBehalfOf, amount, referralCode);
    }
    
    // 隔离模式借款 - 风险隔离
    function borrowInIsolation(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        address onBehalfOf
    ) external {
        require(_usersConfig[onBehalfOf].isolationModeActive, "Not in isolation mode");
        
        DataTypes.ReserveData storage reserve = _reserves[asset];
        
        // 隔离模式特殊验证
        ValidationLogic.validateBorrowInIsolation(
            _reserves,
            _usersConfig[onBehalfOf],
            asset,
            amount
        );
        
        _executeBorrow(ExecuteBorrowParams({
            asset: asset,
            user: msg.sender,
            onBehalfOf: onBehalfOf,
            amount: amount,
            interestRateMode: interestRateMode,
            referralCode: 0,
            releaseUnderlying: true
        }));
    }
}

// 跳跃率模型实现
contract JumpRateModelV2 is IInterestRateModel {
    uint256 public constant blocksPerYear = 2102400;
    
    uint256 public baseRatePerBlock;
    uint256 public multiplierPerBlock;
    uint256 public jumpMultiplierPerBlock;
    uint256 public kink;  // 拐点
    
    constructor(
        uint256 baseRatePerYear,
        uint256 multiplierPerYear,
        uint256 jumpMultiplierPerYear,
        uint256 kink_
    ) {
        baseRatePerBlock = baseRatePerYear / blocksPerYear;
        multiplierPerBlock = multiplierPerYear / blocksPerYear;
        jumpMultiplierPerBlock = jumpMultiplierPerYear / blocksPerYear;
        kink = kink_;
    }
    
    function utilizationRate(
        uint256 cash,
        uint256 borrows,
        uint256 reserves
    ) public pure returns (uint256) {
        if (borrows == 0) {
            return 0;
        }
        return borrows * 1e18 / (cash + borrows - reserves);
    }
    
    function getBorrowRate(
        uint256 cash,
        uint256 borrows,
        uint256 reserves
    ) public view override returns (uint256) {
        uint256 util = utilizationRate(cash, borrows, reserves);
        
        if (util <= kink) {
            return baseRatePerBlock + util * multiplierPerBlock / 1e18;
        } else {
            uint256 normalRate = baseRatePerBlock + kink * multiplierPerBlock / 1e18;
            uint256 excessUtil = util - kink;
            return normalRate + excessUtil * jumpMultiplierPerBlock / 1e18;
        }
    }
    
    function getSupplyRate(
        uint256 cash,
        uint256 borrows,
        uint256 reserves,
        uint256 reserveFactorMantissa
    ) public view override returns (uint256) {
        uint256 oneMinusReserveFactor = 1e18 - reserveFactorMantissa;
        uint256 borrowRate = getBorrowRate(cash, borrows, reserves);
        uint256 rateToPool = borrowRate * oneMinusReserveFactor / 1e18;
        return utilizationRate(cash, borrows, reserves) * rateToPool / 1e18;
    }
}

// 稳定币优化利率模型
contract StablecoinRateStrategy is IInterestRateStrategy {
    using WadRayMath for uint256;
    
    // 稳定币特有参数
    uint256 public immutable OPTIMAL_UTILIZATION_RATE = 0.9e27;  // 90%
    uint256 public immutable BASE_VARIABLE_BORROW_RATE = 0.01e27;  // 1%
    uint256 public immutable VARIABLE_RATE_SLOPE1 = 0.04e27;  // 4%
    uint256 public immutable VARIABLE_RATE_SLOPE2 = 0.6e27;  // 60%
    uint256 public immutable STABLE_RATE_SLOPE1 = 0.02e27;  // 2%
    uint256 public immutable STABLE_RATE_SLOPE2 = 0.6e27;  // 60%
    
    // 动态调整机制
    uint256 public immutable OPTIMAL_STABLE_TO_TOTAL_DEBT_RATIO = 0.2e27;  // 20%
    
    function calculateInterestRates(
        DataTypes.CalculateInterestRatesParams memory params
    ) public view override returns (uint256, uint256, uint256) {
        uint256 utilizationRate = params.totalDebt.rayDiv(params.totalLiquidity);
        
        uint256 currentVariableBorrowRate;
        uint256 currentStableBorrowRate;
        
        if (utilizationRate <= OPTIMAL_UTILIZATION_RATE) {
            // 正常区间 - 线性增长
            currentVariableBorrowRate = BASE_VARIABLE_BORROW_RATE +
                utilizationRate.rayMul(VARIABLE_RATE_SLOPE1).rayDiv(OPTIMAL_UTILIZATION_RATE);
                
            currentStableBorrowRate = currentVariableBorrowRate +
                utilizationRate.rayMul(STABLE_RATE_SLOPE1).rayDiv(OPTIMAL_UTILIZATION_RATE);
        } else {
            // 高利用率区间 - 快速增长
            uint256 excessUtilizationRateRatio = 
                (utilizationRate - OPTIMAL_UTILIZATION_RATE).rayDiv(1e27 - OPTIMAL_UTILIZATION_RATE);
                
            currentVariableBorrowRate = BASE_VARIABLE_BORROW_RATE +
                VARIABLE_RATE_SLOPE1 +
                VARIABLE_RATE_SLOPE2.rayMul(excessUtilizationRateRatio);
                
            currentStableBorrowRate = currentVariableBorrowRate +
                STABLE_RATE_SLOPE1 +
                STABLE_RATE_SLOPE2.rayMul(excessUtilizationRateRatio);
        }
        
        // 稳定利率调整
        if (params.stableDebt > 0) {
            uint256 stableToTotalDebtRatio = params.stableDebt.rayDiv(params.totalDebt);
            
            if (stableToTotalDebtRatio > OPTIMAL_STABLE_TO_TOTAL_DEBT_RATIO) {
                uint256 excessStableDebtRatio = 
                    (stableToTotalDebtRatio - OPTIMAL_STABLE_TO_TOTAL_DEBT_RATIO)
                    .rayDiv(1e27 - OPTIMAL_STABLE_TO_TOTAL_DEBT_RATIO);
                    
                currentStableBorrowRate = currentStableBorrowRate +
                    STABLE_RATE_SLOPE2.rayMul(excessStableDebtRatio);
            }
        }
        
        // 计算流动性利率
        uint256 currentLiquidityRate = _getOverallBorrowRate(
            params.totalStableDebt,
            params.totalVariableDebt,
            currentVariableBorrowRate,
            params.averageStableBorrowRate
        ).rayMul(utilizationRate).rayMul(1e27 - params.reserveFactor);
        
        return (currentLiquidityRate, currentStableBorrowRate, currentVariableBorrowRate);
    }
}

// GHO利率策略实现
contract GhoInterestRateStrategy {
    // 基于市场价格的动态调整
    function calculateGhoRate(
        uint256 ghoMarketPrice,  // 当前市场价格
        uint256 targetPrice,     // 目标价格（1美元）
        uint256 currentRate,     // 当前利率
        uint256 bucketUtilization // Bucket利用率
    ) public pure returns (uint256 newRate) {
        // 价格偏离度计算
        int256 priceDelta = int256(ghoMarketPrice) - int256(targetPrice);
        int256 priceDeviation = (priceDelta * 1e18) / int256(targetPrice);
        
        // PID控制器调整利率
        int256 rateAdjustment = (priceDeviation * KP) / 1e18;
        
        // Bucket利用率影响
        if (bucketUtilization > OPTIMAL_UTILIZATION) {
            uint256 utilizationPremium = 
                (bucketUtilization - OPTIMAL_UTILIZATION) * UTILIZATION_SLOPE / 1e18;
            rateAdjustment += int256(utilizationPremium);
        }
        
        // 应用调整并限制范围
        newRate = uint256(int256(currentRate) + rateAdjustment);
        newRate = bound(newRate, MIN_RATE, MAX_RATE);
    }
}

// EIP-3156 闪电贷标准实现 - 生产级安全考量
contract FlashLoanProvider is IERC3156FlashLender, ReentrancyGuard {
    using SafeERC20 for IERC20;
    
    // 闪电贷费率（基点）
    uint256 public constant FLASH_LOAN_FEE = 9;  // 0.09%
    bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
    
    mapping(address => bool) public supportedTokens;
    
    // 防止重入攻击的状态变量
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;
    uint256 private _status;
    
    // 闪电贷核心函数 - 遵循 check-effects-interactions 模式
    function flashLoan(
        IERC3156FlashBorrower receiver,
        address token,
        uint256 amount,
        bytes calldata data
    ) external override nonReentrant returns (bool) {
        // 1. Checks - 验证输入
        require(supportedTokens[token], "Token not supported");
        require(amount > 0, "Invalid amount");
        
        uint256 fee = _flashFee(amount);
        uint256 balanceBefore = IERC20(token).balanceOf(address(this));
        require(balanceBefore >= amount, "Insufficient liquidity");
        
        // 2. Effects - 状态变更（此处无需变更状态）
        
        // 3. Interactions - 外部调用
        // 发送代币给借款人 - 使用 SafeERC20 防止假币攻击
        IERC20(token).safeTransfer(address(receiver), amount);
        
        // 执行回调 - 关键安全点：借款人可执行任意代码
        // 重入保护由 nonReentrant 修饰符提供
        require(
            receiver.onFlashLoan(msg.sender, token, amount, fee, data) == CALLBACK_SUCCESS,
            "Callback failed"
        );
        
        // 验证还款 - 必须在回调后立即检查
        uint256 balanceAfter = IERC20(token).balanceOf(address(this));
        require(
            balanceAfter >= balanceBefore + fee,
            "Flash loan not repaid"
        );
        
        emit FlashLoan(address(receiver), token, amount, fee);
        return true;
    }
    
    // 批量闪电贷 - Gas优化
    function flashLoanMultiple(
        IERC3156FlashBorrower receiver,
        address[] calldata tokens,
        uint256[] calldata amounts,
        bytes calldata data
    ) external returns (bool) {
        require(tokens.length == amounts.length, "Array length mismatch");
        
        uint256[] memory fees = new uint256[](tokens.length);
        uint256[] memory balancesBefore = new uint256[](tokens.length);
        
        // 批量转出
        for (uint256 i = 0; i < tokens.length; i++) {
            require(supportedTokens[tokens[i]], "Token not supported");
            fees[i] = _flashFee(amounts[i]);
            balancesBefore[i] = IERC20(tokens[i]).balanceOf(address(this));
            IERC20(tokens[i]).safeTransfer(address(receiver), amounts[i]);
        }
        
        // 执行回调
        require(
            IFlashLoanReceiverMultiple(receiver).onFlashLoanMultiple(
                msg.sender,
                tokens,
                amounts,
                fees,
                data
            ) == CALLBACK_SUCCESS,
            "Callback failed"
        );
        
        // 批量验证还款
        for (uint256 i = 0; i < tokens.length; i++) {
            uint256 balanceAfter = IERC20(tokens[i]).balanceOf(address(this));
            require(
                balanceAfter >= balancesBefore[i] + fees[i],
                "Flash loan not repaid"
            );
        }
        
        return true;
    }
    
    function _flashFee(uint256 amount) internal pure returns (uint256) {
        return amount * FLASH_LOAN_FEE / 10000;
    }
}

// 防御闪电贷攻击的措施
contract FlashLoanProtectedVault {
    using ReentrancyGuard for uint256;
    
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;
    uint256 private _status;
    
    // 闪电贷检测
    modifier noFlashLoan() {
        require(!_isFlashLoan(), "Flash loan detected");
        _;
    }
    
    // 延迟更新机制
    struct PriceSnapshot {
        uint256 price;
        uint256 timestamp;
        uint256 blockNumber;
    }
    
    mapping(address => PriceSnapshot) public priceSnapshots;
    uint256 public constant PRICE_DELAY = 1 hours;
    
    function _isFlashLoan() internal view returns (bool) {
        // 检查是否在同一区块内有大额借贷
        // 实际实现需要追踪借贷历史
        return false;
    }
    
    // 时间加权价格
    function getSecurePrice(address token) public view returns (uint256) {
        PriceSnapshot memory snapshot = priceSnapshots[token];
        require(
            block.timestamp >= snapshot.timestamp + PRICE_DELAY,
            "Price not yet valid"
        );
        return snapshot.price;
    }
    
    // 闪电贷保护的清算函数
    function liquidate(
        address borrower,
        address collateralAsset,
        address debtAsset,
        uint256 debtToCover
    ) external noFlashLoan nonReentrant {
        // 使用延迟价格
        uint256 collateralPrice = getSecurePrice(collateralAsset);
        uint256 debtPrice = getSecurePrice(debtAsset);
        
        // 计算清算
        uint256 collateralAmount = _calculateLiquidation(
            debtToCover,
            debtPrice,
            collateralPrice
        );
        
        // 执行清算
        _executeLiquidation(borrower, collateralAsset, debtAsset, collateralAmount);
    }
    
    // 多重签名延迟执行
    mapping(bytes32 => TimelockTransaction) public timelockTransactions;
    
    struct TimelockTransaction {
        address target;
        bytes data;
        uint256 executeTime;
        bool executed;
    }
    
    function scheduleTransaction(
        address target,
        bytes memory data,
        uint256 delay
    ) external onlyOwner returns (bytes32) {
        bytes32 txHash = keccak256(abi.encode(target, data, block.timestamp));
        
        timelockTransactions[txHash] = TimelockTransaction({
            target: target,
            data: data,
            executeTime: block.timestamp + delay,
            executed: false
        });
        
        emit TransactionScheduled(txHash, target, delay);
        return txHash;
    }
}

// 稳定币借贷池完整实现
contract StablecoinLendingPool is 
    ReentrancyGuard, 
    Pausable, 
    AccessControl,
    IERC3156FlashLender 
{
    using SafeERC20 for IERC20;
    using WadRayMath for uint256;
    
    // 角色定义
    bytes32 public constant CONFIGURATOR_ROLE = keccak256("CONFIGURATOR_ROLE");
    bytes32 public constant RISK_ADMIN_ROLE = keccak256("RISK_ADMIN_ROLE");
    
    // 核心状态变量
    struct Reserve {
        uint256 liquidityIndex;
        uint256 variableBorrowIndex;
        uint256 currentLiquidityRate;
        uint256 currentVariableBorrowRate;
        uint40 lastUpdateTimestamp;
        address aTokenAddress;
        address debtTokenAddress;
        address interestRateStrategyAddress;
        uint256 accruedToTreasury;
        ReserveConfiguration configuration;
    }
    
    struct ReserveConfiguration {
        uint256 ltv;  // 贷款价值比
        uint256 liquidationThreshold;  // 清算阈值
        uint256 liquidationBonus;  // 清算奖励
        uint256 reserveFactor;  // 准备金率
        bool borrowingEnabled;
        bool stableBorrowRateEnabled;
        bool isActive;
        bool isFrozen;
    }
    
    mapping(address => Reserve) public reserves;
    mapping(address => mapping(address => uint256)) public userCollateral;
    mapping(address => mapping(address => uint256)) public userDebt;
    
    // 事件
    event Deposit(address indexed user, address indexed asset, uint256 amount);
    event Withdraw(address indexed user, address indexed asset, uint256 amount);
    event Borrow(address indexed user, address indexed asset, uint256 amount);
    event Repay(address indexed user, address indexed asset, uint256 amount);
    event Liquidation(
        address indexed liquidator,
        address indexed borrower,
        address indexed asset,
        uint256 debtCovered,
        uint256 collateralLiquidated
    );
    
    constructor() {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(CONFIGURATOR_ROLE, msg.sender);
        _setupRole(RISK_ADMIN_ROLE, msg.sender);
    }
    
    // 初始化储备
    function initReserve(
        address asset,
        address aTokenAddress,
        address debtTokenAddress,
        address interestRateStrategy
    ) external onlyRole(CONFIGURATOR_ROLE) {
        reserves[asset] = Reserve({
            liquidityIndex: WadRayMath.ray(),
            variableBorrowIndex: WadRayMath.ray(),
            currentLiquidityRate: 0,
            currentVariableBorrowRate: 0,
            lastUpdateTimestamp: uint40(block.timestamp),
            aTokenAddress: aTokenAddress,
            debtTokenAddress: debtTokenAddress,
            interestRateStrategyAddress: interestRateStrategy,
            accruedToTreasury: 0,
            configuration: ReserveConfiguration({
                ltv: 8000,  // 80%
                liquidationThreshold: 8500,  // 85%
                liquidationBonus: 10500,  // 105%
                reserveFactor: 1000,  // 10%
                borrowingEnabled: true,
                stableBorrowRateEnabled: false,
                isActive: true,
                isFrozen: false
            })
        });
    }
    
    // 存款
    function deposit(
        address asset,
        uint256 amount,
        address onBehalfOf
    ) external nonReentrant whenNotPaused {
        Reserve storage reserve = reserves[asset];
        require(reserve.configuration.isActive, "Reserve not active");
        require(!reserve.configuration.isFrozen, "Reserve frozen");
        
        // 更新储备状态
        _updateIndexes(reserve);
        
        // 转入资产
        IERC20(asset).safeTransferFrom(msg.sender, address(this), amount);
        
        // 更新用户余额
        userCollateral[onBehalfOf][asset] += amount;
        
        // 铸造aToken
        IAToken(reserve.aTokenAddress).mint(onBehalfOf, amount, reserve.liquidityIndex);
        
        // 更新利率
        _updateInterestRates(reserve, asset, amount, 0);
        
        emit Deposit(onBehalfOf, asset, amount);
    }
    
    // 借款
    function borrow(
        address asset,
        uint256 amount,
        address onBehalfOf
    ) external nonReentrant whenNotPaused {
        Reserve storage reserve = reserves[asset];
        require(reserve.configuration.isActive, "Reserve not active");
        require(reserve.configuration.borrowingEnabled, "Borrowing not enabled");
        
        // 更新储备状态
        _updateIndexes(reserve);
        
        // 检查健康因子
        (, , , , uint256 healthFactor) = _calculateUserAccountData(onBehalfOf);
        require(healthFactor > WadRayMath.ray(), "Health factor too low");
        
        // 更新债务
        userDebt[onBehalfOf][asset] += amount;
        
        // 铸造债务代币
        IDebtToken(reserve.debtTokenAddress).mint(
            onBehalfOf,
            amount,
            reserve.variableBorrowIndex
        );
        
        // 转出资产
        IERC20(asset).safeTransfer(onBehalfOf, amount);
        
        // 更新利率
        _updateInterestRates(reserve, asset, 0, amount);
        
        emit Borrow(onBehalfOf, asset, amount);
    }
    
    // 清算
    function liquidationCall(
        address collateralAsset,
        address debtAsset,
        address user,
        uint256 debtToCover
    ) external nonReentrant whenNotPaused {
        Reserve storage collateralReserve = reserves[collateralAsset];
        Reserve storage debtReserve = reserves[debtAsset];
        
        // 更新储备状态
        _updateIndexes(collateralReserve);
        _updateIndexes(debtReserve);
        
        // 检查健康因子
        (, , , , uint256 healthFactor) = _calculateUserAccountData(user);
        require(healthFactor < WadRayMath.ray(), "Health factor not below 1");
        
        // 计算清算金额
        uint256 collateralAmount = _calculateAvailableCollateralToLiquidate(
            collateralReserve,
            debtReserve,
            collateralAsset,
            debtAsset,
            debtToCover,
            userCollateral[user][collateralAsset]
        );
        
        // 执行清算
        userDebt[user][debtAsset] -= debtToCover;
        userCollateral[user][collateralAsset] -= collateralAmount;
        
        // 转移债务
        IERC20(debtAsset).safeTransferFrom(msg.sender, address(this), debtToCover);
        
        // 转移抵押品（包含奖励）
        uint256 liquidationBonus = collateralAmount
            .wadMul(collateralReserve.configuration.liquidationBonus)
            .wadDiv(10000);
        IERC20(collateralAsset).safeTransfer(msg.sender, collateralAmount + liquidationBonus);
        
        emit Liquidation(msg.sender, user, debtAsset, debtToCover, collateralAmount);
    }
    
    // 辅助函数：更新指数
    function _updateIndexes(Reserve storage reserve) internal {
        uint256 scaledTotalSupply = IAToken(reserve.aTokenAddress).scaledTotalSupply();
        uint256 scaledTotalDebt = IDebtToken(reserve.debtTokenAddress).scaledTotalSupply();
        
        if (scaledTotalSupply == 0 && scaledTotalDebt == 0) {
            return;
        }
        
        uint256 cumulatedLiquidityInterest = _calculateLinearInterest(
            reserve.currentLiquidityRate,
            reserve.lastUpdateTimestamp
        );
        
        uint256 cumulatedVariableBorrowInterest = _calculateCompoundedInterest(
            reserve.currentVariableBorrowRate,
            reserve.lastUpdateTimestamp
        );
        
        reserve.liquidityIndex = cumulatedLiquidityInterest.rayMul(reserve.liquidityIndex);
        reserve.variableBorrowIndex = cumulatedVariableBorrowInterest.rayMul(
            reserve.variableBorrowIndex
        );
        
        reserve.lastUpdateTimestamp = uint40(block.timestamp);
    }
    
    // 计算用户账户数据
    function _calculateUserAccountData(address user)
        internal
        view
        returns (
            uint256 totalCollateralETH,
            uint256 totalDebtETH,
            uint256 availableBorrowsETH,
            uint256 currentLiquidationThreshold,
            uint256 healthFactor
        )
    {
        // 实现省略，需要遍历所有用户的抵押品和债务
        // 使用预言机价格转换为ETH计价
        // 计算加权平均清算阈值
        // 计算健康因子 = (totalCollateral * liquidationThreshold) / totalDebt
    }
}

// 高级清算引擎实现
contract AdvancedLiquidationEngine {
    using SafeMath for uint256;
    
    struct LiquidationParams {
        uint256 debtToCover;        // 需要清算的债务
        uint256 maxCollateralToLiquidate;  // 最大可清算抵押品
        uint256 userCollateralBalance;     // 用户抵押品余额
        uint256 userDebtBalance;           // 用户债务余额
        uint256 liquidationBonus;          // 清算奖励
        uint256 liquidationProtocolFee;    // 协议费用
        uint256 healthFactor;              // 健康因子
    }
    
    // 部分清算实现 - 2024年最佳实践
    function executeLiquidation(
        address collateralAsset,
        address debtAsset,
        address user,
        uint256 debtToCover,
        bool receiveAToken
    ) external nonReentrant {
        LiquidationParams memory params = _calculateLiquidationParams(
            collateralAsset,
            debtAsset,
            user,
            debtToCover
        );
        
        // 验证清算条件
        require(params.healthFactor < HEALTH_FACTOR_LIQUIDATION_THRESHOLD, "Health factor not below threshold");
        
        // 计算实际清算金额
        uint256 actualDebtToLiquidate = Math.min(
            params.debtToCover,
            params.maxCollateralToLiquidate.percentMul(LIQUIDATION_CLOSE_FACTOR_PERCENT)
        );
        
        // 执行清算
        _burnDebtTokens(debtAsset, user, actualDebtToLiquidate);
        _transferCollateral(collateralAsset, user, msg.sender, 
            actualDebtToLiquidate.mul(params.liquidationBonus).div(100)
        );
        
        emit LiquidationCall(
            collateralAsset,
            debtAsset,
            user,
            actualDebtToLiquidate,
            params.liquidationBonus,
            msg.sender,
            receiveAToken
        );
    }
}

# 风险参数优化示例（Python）
import numpy as np
from scipy.optimize import minimize
import pandas as pd

class DeFiRiskOptimizer:
    """
    基于历史数据和市场模拟的风险参数优化器
    """
    def __init__(self, historical_data, protocol_params):
        self.data = historical_data
        self.params = protocol_params
        
    def simulate_liquidations(self, ltv, liquidation_threshold, volatility_scenario):
        """模拟不同参数下的清算情况"""
        simulated_prices = self.generate_price_paths(volatility_scenario)
        liquidations = []
        
        for price_path in simulated_prices:
            health_factors = self.calculate_health_factors(
                price_path, ltv, liquidation_threshold
            )
            liquidation_events = (health_factors < 1.0).sum()
            liquidations.append(liquidation_events)
            
        return np.array(liquidations)
    
    def objective_function(self, params):
        """
        优化目标：最大化资本效率，同时控制坏账风险
        """
        ltv, liquidation_threshold = params
        
        # 资本效率得分
        capital_efficiency = ltv
        
        # 风险得分（坏账概率）
        bad_debt_prob = self.calculate_bad_debt_probability(
            ltv, liquidation_threshold
        )
        
        # 综合目标函数
        return -(capital_efficiency * (1 - bad_debt_prob))
    
    def optimize_parameters(self):
        """使用约束优化找到最优参数"""
        constraints = [
            {'type': 'ineq', 'fun': lambda x: x[1] - x[0] - 0.05},  # 清算阈值 > LTV + 5%
            {'type': 'ineq', 'fun': lambda x: 0.95 - x[0]},        # LTV < 95%
            {'type': 'ineq', 'fun': lambda x: x[0] - 0.5},         # LTV > 50%
        ]
        
        result = minimize(
            self.objective_function,
            x0=[0.75, 0.85],  # 初始值：LTV=75%, 清算阈值=85%
            method='SLSQP',
            constraints=constraints
        )
        
        return result.x

# 使用示例
optimizer = DeFiRiskOptimizer(historical_data, protocol_params)
optimal_ltv, optimal_threshold = optimizer.optimize_parameters()
print(f"优化后的LTV: {optimal_ltv:.2%}")
print(f"优化后的清算阈值: {optimal_threshold:.2%}")

// 稳定币风险隔离机制
contract StablecoinRiskIsolation {
    // 稳定币特殊参数
    mapping(address => StablecoinConfig) public stablecoinConfigs;
    
    struct StablecoinConfig {
        uint256 supplyCap;           // 供应上限
        uint256 borrowCap;           // 借款上限
        uint256 maxExposure;         // 最大敞口（占总TVL百分比）
        uint256 pegDeviationThreshold; // 脱锚阈值
        address[] acceptedCollaterals; // 可接受的抵押品
        bool emergencyPaused;        // 紧急暂停
    }
    
    // 稳定币健康度监控
    function checkStablecoinHealth(address stablecoin) public view returns (bool) {
        uint256 currentPrice = oracle.getPrice(stablecoin);
        uint256 pegDeviation = abs(int256(currentPrice) - int256(1e18)) * 100 / 1e18;
        
        if (pegDeviation > stablecoinConfigs[stablecoin].pegDeviationThreshold) {
            return false; // 触发风险控制
        }
        
        uint256 currentExposure = getProtocolExposure(stablecoin);
        if (currentExposure > stablecoinConfigs[stablecoin].maxExposure) {
            return false; // 敞口过大
        }
        
        return true;
    }
    
    // 自动风险响应
    function autoRiskResponse(address stablecoin) external {
        if (!checkStablecoinHealth(stablecoin)) {
            // 1. 提高该稳定币的借款利率
            _adjustInterestRate(stablecoin, 150); // +50%
            
            // 2. 降低LTV
            _adjustLTV(stablecoin, 50); // -50%
            
            // 3. 如果严重脱锚，暂停借贷
            uint256 currentPrice = oracle.getPrice(stablecoin);
            if (currentPrice < 0.95e18 || currentPrice > 1.05e18) {
                stablecoinConfigs[stablecoin].emergencyPaused = true;
                emit EmergencyPause(stablecoin, currentPrice);
            }
        }
    }
}