项目实战：完整DeFi借贷协议

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

library DataTypes {
    struct ReserveData {
        // 存储池配置
        address lTokenAddress;
        address interestRateModelAddress;
        uint128 liquidityIndex;
        uint128 variableBorrowIndex;
        uint128 currentLiquidityRate;
        uint128 currentVariableBorrowRate;
        uint40 lastUpdateTimestamp;
        // 风险参数
        uint16 collateralFactor;     // 抵押率 (basis points)
        uint16 liquidationThreshold;  // 清算阈值
        uint16 liquidationBonus;      // 清算奖励
        bool isActive;
        bool isFrozen;
        bool borrowingEnabled;
    }

    struct UserReserveData {
        uint256 currentLTokenBalance;
        uint256 currentVariableDebt;
        uint256 principalLTokenBalance;
        uint256 principalVariableDebt;
        uint128 liquidityIndex;
        uint128 variableBorrowIndex;
        bool useAsCollateral;
    }

    struct AccountLiquidity {
        uint256 totalCollateralInBase;
        uint256 totalDebtInBase;
        uint256 availableBorrowsInBase;
        uint256 currentLiquidationThreshold;
        uint256 ltv;
        uint256 healthFactor;
    }
}

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

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

contract InterestRateModel is Ownable {
    uint256 public constant SECONDS_PER_YEAR = 365 days;
    uint256 public constant RAY = 1e27;

    // 利率参数
    uint256 public baseVariableBorrowRate;  // 基础借款利率
    uint256 public variableRateSlope1;       // 利用率 < 最优时的斜率
    uint256 public variableRateSlope2;       // 利用率 > 最优时的斜率
    uint256 public optimalUtilizationRate;   // 最优利用率

    event RatesUpdated(
        uint256 baseRate,
        uint256 slope1,
        uint256 slope2,
        uint256 optimalRate
    );

    constructor(
        uint256 _baseVariableBorrowRate,
        uint256 _variableRateSlope1,
        uint256 _variableRateSlope2,
        uint256 _optimalUtilizationRate
    ) Ownable(msg.sender) {
        baseVariableBorrowRate = _baseVariableBorrowRate;
        variableRateSlope1 = _variableRateSlope1;
        variableRateSlope2 = _variableRateSlope2;
        optimalUtilizationRate = _optimalUtilizationRate;
    }

    /**
     * @dev 计算借款利率和存款利率
     * @param totalDebt 总借款量
     * @param totalLiquidity 总流动性
     * @param reserveFactor 储备金率
     */
    function calculateInterestRates(
        uint256 totalDebt,
        uint256 totalLiquidity,
        uint256 reserveFactor
    ) external view returns (uint256 liquidityRate, uint256 borrowRate) {
        if (totalLiquidity == 0) {
            return (0, baseVariableBorrowRate);
        }

        // 计算利用率
        uint256 utilizationRate = (totalDebt * RAY) / totalLiquidity;

        // 计算借款利率
        if (utilizationRate <= optimalUtilizationRate) {
            // 利用率在最优值以下
            borrowRate = baseVariableBorrowRate +
                (utilizationRate * variableRateSlope1) / optimalUtilizationRate;
        } else {
            // 利用率超过最优值
            uint256 excessUtilization = utilizationRate - optimalUtilizationRate;
            borrowRate = baseVariableBorrowRate +
                variableRateSlope1 +
                (excessUtilization * variableRateSlope2) /
                (RAY - optimalUtilizationRate);
        }

        // 计算存款利率
        // liquidityRate = borrowRate * utilizationRate * (1 - reserveFactor)
        liquidityRate = (borrowRate * utilizationRate * (RAY - reserveFactor)) / (RAY * RAY);
    }

    function updateRates(
        uint256 _baseVariableBorrowRate,
        uint256 _variableRateSlope1,
        uint256 _variableRateSlope2,
        uint256 _optimalUtilizationRate
    ) external onlyOwner {
        baseVariableBorrowRate = _baseVariableBorrowRate;
        variableRateSlope1 = _variableRateSlope1;
        variableRateSlope2 = _variableRateSlope2;
        optimalUtilizationRate = _optimalUtilizationRate;

        emit RatesUpdated(
            _baseVariableBorrowRate,
            _variableRateSlope1,
            _variableRateSlope2,
            _optimalUtilizationRate
        );
    }
}

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract LToken is ERC20, Ownable {
    using SafeERC20 for IERC20;

    IERC20 public immutable underlyingAsset;
    address public lendingPool;

    uint256 private constant RAY = 1e27;

    event Mint(address indexed user, uint256 amount, uint256 index);
    event Burn(address indexed user, address indexed target, uint256 amount, uint256 index);

    modifier onlyLendingPool() {
        require(msg.sender == lendingPool, "Caller must be lending pool");
        _;
    }

    constructor(
        address _underlyingAsset,
        string memory name,
        string memory symbol
    ) ERC20(name, symbol) Ownable(msg.sender) {
        underlyingAsset = IERC20(_underlyingAsset);
    }

    function setLendingPool(address _lendingPool) external onlyOwner {
        require(lendingPool == address(0), "Pool already set");
        lendingPool = _lendingPool;
    }

    /**
     * @dev 铸造LToken给用户
     * @param user 接收者
     * @param amount 数量
     * @param index 当前流动性指数
     */
    function mint(
        address user,
        uint256 amount,
        uint256 index
    ) external onlyLendingPool returns (bool) {
        uint256 amountScaled = (amount * RAY) / index;
        require(amountScaled != 0, "Invalid mint amount");

        _mint(user, amountScaled);

        emit Mint(user, amount, index);
        return true;
    }

    /**
     * @dev 销毁LToken
     * @param user 持有者
     * @param receiverOfUnderlying 接收底层资产的地址
     * @param amount 数量
     * @param index 当前流动性指数
     */
    function burn(
        address user,
        address receiverOfUnderlying,
        uint256 amount,
        uint256 index
    ) external onlyLendingPool returns (bool) {
        uint256 amountScaled = (amount * RAY) / index;
        require(amountScaled != 0, "Invalid burn amount");

        _burn(user, amountScaled);

        underlyingAsset.safeTransfer(receiverOfUnderlying, amount);

        emit Burn(user, receiverOfUnderlying, amount, index);
        return true;
    }

    /**
     * @dev 获取用户的实际余额（包含利息）
     */
    function balanceOf(address account) public view override returns (uint256) {
        uint256 scaledBalance = super.balanceOf(account);
        if (scaledBalance == 0) {
            return 0;
        }

        // 从lending pool获取当前index
        // 简化处理，实际需要调用lending pool
        return scaledBalance;
    }

    /**
     * @dev 获取缩放后的余额
     */
    function scaledBalanceOf(address account) external view returns (uint256) {
        return super.balanceOf(account);
    }

    /**
     * @dev 获取缩放后的总供应量
     */
    function scaledTotalSupply() external view returns (uint256) {
        return super.totalSupply();
    }
}

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

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

contract PriceOracle is Ownable {
    mapping(address => address) public assetPriceFeeds;
    mapping(address => uint256) public fallbackPrices;

    uint256 public constant PRICE_DECIMALS = 18;
    uint256 public constant STALENESS_THRESHOLD = 1 hours;

    event PriceFeedUpdated(address indexed asset, address indexed feed);
    event FallbackPriceUpdated(address indexed asset, uint256 price);

    constructor() Ownable(msg.sender) {}

    /**
     * @dev 设置资产的Chainlink价格源
     */
    function setAssetPriceFeed(address asset, address feed) external onlyOwner {
        require(asset != address(0), "Invalid asset");
        require(feed != address(0), "Invalid feed");

        assetPriceFeeds[asset] = feed;
        emit PriceFeedUpdated(asset, feed);
    }

    /**
     * @dev 设置后备价格（当Chainlink不可用时）
     */
    function setFallbackPrice(address asset, uint256 price) external onlyOwner {
        fallbackPrices[asset] = price;
        emit FallbackPriceUpdated(asset, price);
    }

    /**
     * @dev 获取资产价格（USD计价）
     * @return price 价格（18位小数）
     */
    function getAssetPrice(address asset) external view returns (uint256) {
        address feed = assetPriceFeeds[asset];

        if (feed == address(0)) {
            uint256 fallbackPrice = fallbackPrices[asset];
            require(fallbackPrice > 0, "No price source");
            return fallbackPrice;
        }

        try AggregatorV3Interface(feed).latestRoundData() returns (
            uint80,
            int256 price,
            uint256,
            uint256 updatedAt,
            uint80
        ) {
            require(price > 0, "Invalid price");
            require(
                block.timestamp - updatedAt <= STALENESS_THRESHOLD,
                "Stale price"
            );

            uint8 decimals = AggregatorV3Interface(feed).decimals();

            // 标准化到18位小数
            if (decimals < PRICE_DECIMALS) {
                return uint256(price) * (10 ** (PRICE_DECIMALS - decimals));
            } else if (decimals > PRICE_DECIMALS) {
                return uint256(price) / (10 ** (decimals - PRICE_DECIMALS));
            } else {
                return uint256(price);
            }
        } catch {
            uint256 fallbackPrice = fallbackPrices[asset];
            require(fallbackPrice > 0, "Price feed failed");
            return fallbackPrice;
        }
    }

    /**
     * @dev 批量获取价格
     */
    function getAssetsPrices(address[] calldata assets)
        external
        view
        returns (uint256[] memory)
    {
        uint256[] memory prices = new uint256[](assets.length);
        for (uint256 i = 0; i < assets.length; i++) {
            prices[i] = this.getAssetPrice(assets[i]);
        }
        return prices;
    }
}

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../libraries/DataTypes.sol";
import "./LToken.sol";
import "./InterestRateModel.sol";
import "../oracles/PriceOracle.sol";

contract LendingPool is Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    uint256 private constant RAY = 1e27;
    uint256 private constant SECONDS_PER_YEAR = 365 days;
    uint256 private constant LIQUIDATION_CLOSE_FACTOR = 5000; // 50%
    uint256 private constant MIN_HEALTH_FACTOR = 1e18;

    PriceOracle public immutable priceOracle;

    mapping(address => DataTypes.ReserveData) public reserves;
    mapping(address => mapping(address => DataTypes.UserReserveData)) public userReserves;

    address[] public reservesList;

    event Deposit(
        address indexed reserve,
        address indexed user,
        uint256 amount
    );

    event Withdraw(
        address indexed reserve,
        address indexed user,
        uint256 amount
    );

    event Borrow(
        address indexed reserve,
        address indexed user,
        uint256 amount,
        uint256 borrowRate
    );

    event Repay(
        address indexed reserve,
        address indexed user,
        uint256 amount
    );

    event LiquidationCall(
        address indexed collateralAsset,
        address indexed debtAsset,
        address indexed user,
        uint256 debtToCover,
        uint256 liquidatedCollateral
    );

    event ReserveInitialized(
        address indexed asset,
        address indexed lToken,
        address interestRateModel
    );

    constructor(address _priceOracle) Ownable(msg.sender) {
        require(_priceOracle != address(0), "Invalid oracle");
        priceOracle = PriceOracle(_priceOracle);
    }

    /**
     * @dev 初始化储备金
     */
    function initReserve(
        address asset,
        address lTokenAddress,
        address interestRateModelAddress,
        uint16 collateralFactor,
        uint16 liquidationThreshold,
        uint16 liquidationBonus
    ) external onlyOwner {
        require(reserves[asset].lTokenAddress == address(0), "Reserve already initialized");

        reserves[asset] = DataTypes.ReserveData({
            lTokenAddress: lTokenAddress,
            interestRateModelAddress: interestRateModelAddress,
            liquidityIndex: uint128(RAY),
            variableBorrowIndex: uint128(RAY),
            currentLiquidityRate: 0,
            currentVariableBorrowRate: 0,
            lastUpdateTimestamp: uint40(block.timestamp),
            collateralFactor: collateralFactor,
            liquidationThreshold: liquidationThreshold,
            liquidationBonus: liquidationBonus,
            isActive: true,
            isFrozen: false,
            borrowingEnabled: true
        });

        reservesList.push(asset);

        emit ReserveInitialized(asset, lTokenAddress, interestRateModelAddress);
    }

    /**
     * @dev 存款
     */
    function deposit(
        address asset,
        uint256 amount,
        bool useAsCollateral
    ) external nonReentrant {
        DataTypes.ReserveData storage reserve = reserves[asset];
        require(reserve.isActive, "Reserve not active");
        require(amount > 0, "Amount must be greater than 0");

        // 更新状态
        _updateState(asset);

        // 转入资产
        IERC20(asset).safeTransferFrom(msg.sender, address(this), amount);

        // 铸造lToken
        LToken(reserve.lTokenAddress).mint(
            msg.sender,
            amount,
            reserve.liquidityIndex
        );

        // 更新用户数据
        DataTypes.UserReserveData storage userReserve = userReserves[asset][msg.sender];
        userReserve.principalLTokenBalance += amount;
        userReserve.useAsCollateral = useAsCollateral;

        // 更新利率
        _updateInterestRates(asset);

        emit Deposit(asset, msg.sender, amount);
    }

    /**
     * @dev 提款
     */
    function withdraw(address asset, uint256 amount) external nonReentrant {
        DataTypes.ReserveData storage reserve = reserves[asset];
        require(reserve.isActive, "Reserve not active");

        _updateState(asset);

        uint256 userBalance = LToken(reserve.lTokenAddress).balanceOf(msg.sender);
        uint256 amountToWithdraw = amount == type(uint256).max ? userBalance : amount;

        require(amountToWithdraw > 0, "Amount must be greater than 0");
        require(amountToWithdraw <= userBalance, "Insufficient balance");

        // 检查健康因子
        if (userReserves[asset][msg.sender].useAsCollateral) {
            DataTypes.AccountLiquidity memory liquidity = _getAccountLiquidity(msg.sender);
            require(liquidity.healthFactor >= MIN_HEALTH_FACTOR, "Health factor too low");
        }

        // 销毁lToken并转出底层资产
        LToken(reserve.lTokenAddress).burn(
            msg.sender,
            msg.sender,
            amountToWithdraw,
            reserve.liquidityIndex
        );

        // 更新用户数据
        DataTypes.UserReserveData storage userReserve = userReserves[asset][msg.sender];
        userReserve.principalLTokenBalance -= amountToWithdraw;

        // 更新利率
        _updateInterestRates(asset);

        emit Withdraw(asset, msg.sender, amountToWithdraw);
    }

    /**
     * @dev 借款
     */
    function borrow(address asset, uint256 amount) external nonReentrant {
        DataTypes.ReserveData storage reserve = reserves[asset];
        require(reserve.isActive, "Reserve not active");
        require(reserve.borrowingEnabled, "Borrowing not enabled");
        require(amount > 0, "Amount must be greater than 0");

        _updateState(asset);

        // 检查流动性
        uint256 availableLiquidity = IERC20(asset).balanceOf(address(this));
        require(amount <= availableLiquidity, "Insufficient liquidity");

        // 检查用户借款能力
        DataTypes.AccountLiquidity memory liquidity = _getAccountLiquidity(msg.sender);
        uint256 assetPrice = priceOracle.getAssetPrice(asset);
        uint256 borrowValueInBase = (amount * assetPrice) / 1e18;

        require(
            borrowValueInBase <= liquidity.availableBorrowsInBase,
            "Exceeds borrow capacity"
        );

        // 更新用户借款数据
        DataTypes.UserReserveData storage userReserve = userReserves[asset][msg.sender];
        userReserve.principalVariableDebt += amount;
        userReserve.variableBorrowIndex = reserve.variableBorrowIndex;

        // 转出资产
        IERC20(asset).safeTransfer(msg.sender, amount);

        // 更新利率
        _updateInterestRates(asset);

        emit Borrow(asset, msg.sender, amount, reserve.currentVariableBorrowRate);
    }

    /**
     * @dev 还款
     */
    function repay(address asset, uint256 amount) external nonReentrant {
        DataTypes.ReserveData storage reserve = reserves[asset];
        require(reserve.isActive, "Reserve not active");

        _updateState(asset);

        DataTypes.UserReserveData storage userReserve = userReserves[asset][msg.sender];
        uint256 currentDebt = _getUserCurrentDebt(asset, msg.sender);

        require(currentDebt > 0, "No debt to repay");

        uint256 amountToRepay = amount > currentDebt ? currentDebt : amount;

        // 转入资产
        IERC20(asset).safeTransferFrom(msg.sender, address(this), amountToRepay);

        // 更新用户债务
        if (amountToRepay == currentDebt) {
            userReserve.principalVariableDebt = 0;
        } else {
            userReserve.principalVariableDebt -= amountToRepay;
        }

        // 更新利率
        _updateInterestRates(asset);

        emit Repay(asset, msg.sender, amountToRepay);
    }

    /**
     * @dev 清算
     */
    function liquidationCall(
        address collateralAsset,
        address debtAsset,
        address user,
        uint256 debtToCover
    ) external nonReentrant {
        _updateState(collateralAsset);
        _updateState(debtAsset);

        // 检查用户健康因子
        DataTypes.AccountLiquidity memory liquidity = _getAccountLiquidity(user);
        require(liquidity.healthFactor < MIN_HEALTH_FACTOR, "Health factor OK");

        uint256 userDebt = _getUserCurrentDebt(debtAsset, user);
        require(userDebt > 0, "No debt");

        // 计算实际清算金额（最多50%）
        uint256 maxLiquidatableDebt = (userDebt * LIQUIDATION_CLOSE_FACTOR) / 10000;
        uint256 actualDebtToCover = debtToCover > maxLiquidatableDebt
            ? maxLiquidatableDebt
            : debtToCover;

        // 计算要获得的抵押品数量
        uint256 collateralPrice = priceOracle.getAssetPrice(collateralAsset);
        uint256 debtPrice = priceOracle.getAssetPrice(debtAsset);

        DataTypes.ReserveData storage collateralReserve = reserves[collateralAsset];
        uint256 liquidationBonus = collateralReserve.liquidationBonus;

        // 抵押品价值 = 债务价值 * (1 + 清算奖励)
        uint256 collateralAmount = ((actualDebtToCover * debtPrice) *
            (10000 + liquidationBonus)) / (collateralPrice * 10000);

        // 转入债务资产
        IERC20(debtAsset).safeTransferFrom(msg.sender, address(this), actualDebtToCover);

        // 转出抵押品
        LToken(collateralReserve.lTokenAddress).burn(
            user,
            msg.sender,
            collateralAmount,
            collateralReserve.liquidityIndex
        );

        // 更新用户债务
        DataTypes.UserReserveData storage userDebtReserve = userReserves[debtAsset][user];
        userDebtReserve.principalVariableDebt -= actualDebtToCover;

        // 更新利率
        _updateInterestRates(debtAsset);
        _updateInterestRates(collateralAsset);

        emit LiquidationCall(
            collateralAsset,
            debtAsset,
            user,
            actualDebtToCover,
            collateralAmount
        );
    }

    /**
     * @dev 更新储备金状态
     */
    function _updateState(address asset) internal {
        DataTypes.ReserveData storage reserve = reserves[asset];

        if (reserve.lastUpdateTimestamp == block.timestamp) {
            return;
        }

        uint256 timeDelta = block.timestamp - reserve.lastUpdateTimestamp;

        // 更新索引
        if (reserve.currentVariableBorrowRate > 0) {
            uint256 cumulatedBorrowInterest = _calculateLinearInterest(
                reserve.currentVariableBorrowRate,
                timeDelta
            );

            reserve.variableBorrowIndex = uint128(
                (cumulatedBorrowInterest * reserve.variableBorrowIndex) / RAY
            );
        }

        if (reserve.currentLiquidityRate > 0) {
            uint256 cumulatedLiquidityInterest = _calculateLinearInterest(
                reserve.currentLiquidityRate,
                timeDelta
            );

            reserve.liquidityIndex = uint128(
                (cumulatedLiquidityInterest * reserve.liquidityIndex) / RAY
            );
        }

        reserve.lastUpdateTimestamp = uint40(block.timestamp);
    }

    /**
     * @dev 更新利率
     */
    function _updateInterestRates(address asset) internal {
        DataTypes.ReserveData storage reserve = reserves[asset];

        uint256 totalDebt = _getTotalDebt(asset);
        uint256 totalLiquidity = IERC20(asset).balanceOf(address(this)) + totalDebt;

        (uint256 newLiquidityRate, uint256 newBorrowRate) = InterestRateModel(
            reserve.interestRateModelAddress
        ).calculateInterestRates(totalDebt, totalLiquidity, 1000); // 10% reserve factor

        reserve.currentLiquidityRate = uint128(newLiquidityRate);
        reserve.currentVariableBorrowRate = uint128(newBorrowRate);
    }

    /**
     * @dev 计算线性利息
     */
    function _calculateLinearInterest(uint256 rate, uint256 timeDelta)
        internal
        pure
        returns (uint256)
    {
        return RAY + (rate * timeDelta) / SECONDS_PER_YEAR;
    }

    /**
     * @dev 获取用户当前债务
     */
    function _getUserCurrentDebt(address asset, address user)
        internal
        view
        returns (uint256)
    {
        DataTypes.UserReserveData storage userReserve = userReserves[asset][user];
        if (userReserve.principalVariableDebt == 0) {
            return 0;
        }

        DataTypes.ReserveData storage reserve = reserves[asset];
        return (userReserve.principalVariableDebt * reserve.variableBorrowIndex) /
            userReserve.variableBorrowIndex;
    }

    /**
     * @dev 获取总债务
     */
    function _getTotalDebt(address asset) internal view returns (uint256) {
        // 简化实现：遍历所有用户（实际应该维护总债务变量）
        return 0;
    }

    /**
     * @dev 获取账户流动性
     */
    function _getAccountLiquidity(address user)
        internal
        view
        returns (DataTypes.AccountLiquidity memory)
    {
        uint256 totalCollateralInBase;
        uint256 totalDebtInBase;
        uint256 avgLiquidationThreshold;

        for (uint256 i = 0; i < reservesList.length; i++) {
            address asset = reservesList[i];
            DataTypes.ReserveData storage reserve = reserves[asset];
            DataTypes.UserReserveData storage userReserve = userReserves[asset][user];

            uint256 assetPrice = priceOracle.getAssetPrice(asset);

            // 计算抵押品价值
            if (userReserve.useAsCollateral) {
                uint256 userBalance = LToken(reserve.lTokenAddress).balanceOf(user);
                uint256 collateralValueInBase = (userBalance * assetPrice) / 1e18;

                totalCollateralInBase +=
                    (collateralValueInBase * reserve.collateralFactor) / 10000;

                avgLiquidationThreshold +=
                    collateralValueInBase * reserve.liquidationThreshold;
            }

            // 计算债务价值
            uint256 userDebt = _getUserCurrentDebt(asset, user);
            if (userDebt > 0) {
                totalDebtInBase += (userDebt * assetPrice) / 1e18;
            }
        }

        if (totalCollateralInBase > 0) {
            avgLiquidationThreshold = avgLiquidationThreshold / totalCollateralInBase;
        }

        uint256 availableBorrows = totalCollateralInBase > totalDebtInBase
            ? totalCollateralInBase - totalDebtInBase
            : 0;

        uint256 healthFactor = totalDebtInBase > 0
            ? (totalCollateralInBase * avgLiquidationThreshold * 1e18) /
                (totalDebtInBase * 10000)
            : type(uint256).max;

        return DataTypes.AccountLiquidity({
            totalCollateralInBase: totalCollateralInBase,
            totalDebtInBase: totalDebtInBase,
            availableBorrowsInBase: availableBorrows,
            currentLiquidationThreshold: avgLiquidationThreshold,
            ltv: totalCollateralInBase > 0
                ? (totalDebtInBase * 10000) / totalCollateralInBase
                : 0,
            healthFactor: healthFactor
        });
    }

    /**
     * @dev 获取用户账户数据
     */
    function getUserAccountData(address user)
        external
        view
        returns (
            uint256 totalCollateralBase,
            uint256 totalDebtBase,
            uint256 availableBorrowsBase,
            uint256 currentLiquidationThreshold,
            uint256 ltv,
            uint256 healthFactor
        )
    {
        DataTypes.AccountLiquidity memory liquidity = _getAccountLiquidity(user);

        return (
            liquidity.totalCollateralInBase,
            liquidity.totalDebtInBase,
            liquidity.availableBorrowsInBase,
            liquidity.currentLiquidationThreshold,
            liquidity.ltv,
            liquidity.healthFactor
        );
    }

    /**
     * @dev 获取储备金数据
     */
    function getReserveData(address asset)
        external
        view
        returns (
            uint256 availableLiquidity,
            uint256 totalDebt,
            uint256 liquidityRate,
            uint256 borrowRate,
            uint256 liquidityIndex,
            uint256 borrowIndex,
            uint40 lastUpdateTimestamp
        )
    {
        DataTypes.ReserveData storage reserve = reserves[asset];

        return (
            IERC20(asset).balanceOf(address(this)),
            _getTotalDebt(asset),
            reserve.currentLiquidityRate,
            reserve.currentVariableBorrowRate,
            reserve.liquidityIndex,
            reserve.variableBorrowIndex,
            reserve.lastUpdateTimestamp
        );
    }
}