AAVE V1 源码阅读

    /**
     * @dev 将基础资产存入储备池中。同时会铸造相应数量的覆盖资产（aToken）
     * @param _reserve reserve 的地址
     * @param _amount 存入金额
     * @param _referralCode integrators are assigned a referral code and can potentially receive rewards.
     **/
    function deposit(
        address _reserve,
        uint256 _amount,
        uint16 _referralCode
    )
        external
        payable
        nonReentrant
        onlyActiveReserve(_reserve) // 检查储备池是否处于活跃状态
        onlyUnfreezedReserve(_reserve) // 检查储备池是否处于冻结状态
        onlyAmountGreaterThanZero(_amount) // 检查存入金额是否大于0
    {
        // 获取 aToken 合约地址
        AToken aToken = AToken(core.getReserveATokenAddress(_reserve));
        // 判断是否是第一次存入
        bool isFirstDeposit = aToken.balanceOf(msg.sender) == 0;
        // 更新状态
        core.updateStateOnDeposit(
            _reserve,
            msg.sender,
            _amount,
            isFirstDeposit
        );

        // 按特定兑换率以1:1比例向用户铸造AToken
        aToken.mintOnDeposit(msg.sender, _amount);

        // 将资产转账到核心合约
        core.transferToReserve.value(msg.value)(_reserve, msg.sender, _amount);

        //solium-disable-next-line
        // 发出存款事件
        emit Deposit(
            _reserve,
            msg.sender,
            _amount,
            _referralCode,
            block.timestamp
        );
    }

    function borrow(
        address _reserve,
        uint256 _amount,
        uint256 _interestRateMode,
        uint16 _referralCode
    )
        external
        nonReentrant
        onlyActiveReserve(_reserve)
        onlyUnfreezedReserve(_reserve)
        onlyAmountGreaterThanZero(_amount)
    {
        BorrowLocalVars memory vars;
        // 储备借款开关、利率模式、可用流动性检查
        ...
        // 将利率模式转换为 coreLibrary.interestRateMode
        vars.rateMode = CoreLibrary.InterestRateMode(_interestRateMode);
        // 检查储备池中是否有足够的可用金额，可用流动性即为核心合约的余额。
        vars.availableLiquidity = core.getReserveAvailableLiquidity(_reserve);
        ...

        (
            ,
            vars.userCollateralBalanceETH,
            vars.userBorrowBalanceETH,
            vars.userTotalFeesETH,
            vars.currentLtv,
            vars.currentLiquidationThreshold,
            ,
            vars.healthFactorBelowThreshold
        ) = dataProvider.calculateUserGlobalData(msg.sender); // 一次性获取抵押、借款、LTV、健康度

        // 抵押>0 与 Health Factor>1 的 require
        ...

        vars.borrowFee = feeProvider.calculateLoanOriginationFee(
            msg.sender,
            _amount
        ); // 计算开仓费
        ...

        vars.amountOfCollateralNeededETH = dataProvider
            .calculateCollateralNeededInETH(
                _reserve,
                _amount,
                vars.borrowFee,
                vars.userBorrowBalanceETH,
                vars.userTotalFeesETH,
                vars.currentLtv
            ); // 根据 LTV 推导所需抵押
        // 抵押覆盖校验
        ...
        /**
         *  如果用户以稳定利率借款，需要满足以下条件：
         *  1. 储备池必须启用稳定利率借款
         *  2. 用户不能从储备池借款，如果他们的抵押品主要是他们正在借款的货币，以防止滥用。
         *  3. 用户只能借款储备池总流动性的一个相对较小、可配置的金额。
         */
        if (vars.rateMode == CoreLibrary.InterestRateMode.STABLE) {
            // 检查借款模式是否为稳定利率，并且储备池是否启用了稳定利率借款
            ...

            uint256 maxLoanPercent = parametersProvider
                .getMaxStableRateBorrowSizePercent();
            uint256 maxLoanSizeStable = vars
                .availableLiquidity
                .mul(maxLoanPercent)
                .div(100);
            require(
                _amount <= maxLoanSizeStable,
                "User is trying to borrow too much liquidity at a stable rate"
            );
        }
        // 更新储备池状态
        (vars.finalUserBorrowRate, vars.borrowBalanceIncrease) = core
            .updateStateOnBorrow(
                _reserve,
                msg.sender,
                _amount,
                vars.borrowFee,
                vars.rateMode // 同步更新储备曲线和用户债务指数
            );
        // 转移储备池中的资产到借款人
        core.transferToUser(_reserve, msg.sender, _amount);
        emit Borrow(
            _reserve,
            msg.sender,
            _amount,
            _interestRateMode,
            vars.finalUserBorrowRate,
            vars.borrowFee,
            vars.borrowBalanceIncrease,
            _referralCode,
            block.timestamp
        );
    }

    function repay(
        address _reserve,
        uint256 _amount,ß
        address payable _onBehalfOf
    )
        external
        payable
        nonReentrant
        onlyActiveReserve(_reserve)
        onlyAmountGreaterThanZero(_amount)
    {
        RepayLocalVars memory vars;

        ( // 查询本金、复利余额与利息增量
            vars.principalBorrowBalance,
            vars.compoundedBorrowBalance,
            vars.borrowBalanceIncrease
        ) = core.getUserBorrowBalances(_reserve, _onBehalfOf);

        vars.originationFee = core.getUserOriginationFee(_reserve, _onBehalfOf);
        vars.isETH = EthAddressLib.ethAddress() == _reserve;

        ... // require: 仍有债务、msg.sender 代还约束、msg.value 校验

        vars.paybackAmount = vars.compoundedBorrowBalance.add(
            vars.originationFee // 需要偿还的总额 = 债务 + 开仓费
        );
        if (_amount != UINT_MAX_VALUE && _amount < vars.paybackAmount) {
            vars.paybackAmount = _amount;
        }
        ... // ETH 分支需要携带足量 msg.value

        // 如果还款金额小于初始费用，直接转给费用接收地址
        if (vars.paybackAmount <= vars.originationFee) {
            // 只剩开仓费待付，principal 不变
            core.updateStateOnRepay(
                _reserve,
                _onBehalfOf,
                0,
                vars.paybackAmount,
                vars.borrowBalanceIncrease,
                false
            );
            ... // core.transferToFeeCollectionAddress(... vars.paybackAmount ...)
            emit Repay(
                _reserve,
                _onBehalfOf,
                msg.sender,
                0,
                vars.paybackAmount,
                vars.borrowBalanceIncrease,
                block.timestamp
            );
            return;
        }

        vars.paybackAmountMinusFees = vars.paybackAmount.sub(
            vars.originationFee // 真正还掉的本金
        );

        core.updateStateOnRepay(
            _reserve,
            _onBehalfOf,
            vars.paybackAmountMinusFees,
            vars.originationFee,
            vars.borrowBalanceIncrease,
            vars.compoundedBorrowBalance == vars.paybackAmountMinusFees
        );
        // 如果没有支付初始费用，将费用转给费用接收地址
        if (vars.originationFee > 0) {
            ... // core.transferToFeeCollectionAddress(... vars.originationFee ...)
        }
        // 发送总 msg.value（如果是 ETH）。
        // transferToReserve() 函数会负责将多余的 ETH 退还给调用者。
        core.transferToReserve.value(
            vars.isETH ? msg.value.sub(vars.originationFee) : 0
        )(_reserve, msg.sender, vars.paybackAmountMinusFees);

        emit Repay(
            _reserve,
            _onBehalfOf,
            msg.sender,
            vars.paybackAmountMinusFees,
            vars.originationFee,
            vars.borrowBalanceIncrease,
            block.timestamp
        );
    }

    function flashLoan(
        address _receiver,
        address _reserve,
        uint256 _amount,
        bytes memory _params
    )
        public
        nonReentrant
        onlyActiveReserve(_reserve)
        onlyAmountGreaterThanZero(_amount)
    {
        // 检查储备池是否有足够的可用流动性
        // 避免使用 LendingPoolCore 中的 getAvailableLiquidity() 函数以节省 gas
        uint256 availableLiquidityBefore = _reserve ==
            EthAddressLib.ethAddress()
            ? address(core).balance
            : IERC20(_reserve).balanceOf(address(core));

        ... // require: 储备流动性必须覆盖 _amount

        (uint256 totalFeeBips, uint256 protocolFeeBips) = parametersProvider
            .getFlashLoanFeesInBips();
        uint256 amountFee = _amount.mul(totalFeeBips).div(10000);
        // 协议费用是 amountFee 中为协议保留的部分 - 剩余部分归存款人所有
        uint256 protocolFee = amountFee.mul(protocolFeeBips).div(10000);
        ... // require: 金额足够大且费用非零

        IFlashLoanReceiver receiver = IFlashLoanReceiver(_receiver);
        address payable userPayable = address(uint160(_receiver));
        // 转移资金给接收者
        core.transferToUser(_reserve, userPayable, _amount); 
        receiver.executeOperation(_reserve, _amount, amountFee, _params); // 外部合约需在此回调内完成借款逻辑


        // 检查核心合约的实际余额是否包含返回的金额
        uint256 availableLiquidityAfter = _reserve == EthAddressLib.ethAddress()
            ? address(core).balance
            : IERC20(_reserve).balanceOf(address(core));

        require(
            availableLiquidityAfter == availableLiquidityBefore.add(amountFee),
            "The actual balance of the protocol is inconsistent"
        );
        // 更新储备池状态
        core.updateStateOnFlashLoan(
            _reserve,
            availableLiquidityBefore,
            amountFee.sub(protocolFee),
            protocolFee // 结息：把收益分给存款人，协议抽象余
        );

        emit FlashLoan(
            _receiver,
            _reserve,
            _amount,
            amountFee,
            protocolFee,
            block.timestamp
        );
    }

    // LendingPool.sol
    function liquidationCall(
        address _collateral,
        address _reserve,
        address _user,
        uint256 _purchaseAmount,
        bool _receiveAToken
    )
        external
        payable
        nonReentrant
        onlyActiveReserve(_reserve)
        onlyActiveReserve(_collateral)
    {
        address liquidationManager = addressesProvider.getLendingPoolLiquidationManager();
        (bool success, bytes memory result) = liquidationManager.delegatecall(
            abi.encodeWithSignature(
                "liquidationCall(address,address,address,uint256,bool)",
                _collateral,
                _reserve,
                _user,
                _purchaseAmount,
                _receiveAToken
            )
        );
        require(success, "Liquidation call failed");

        (uint256 returnCode, string memory returnMessage) = abi.decode(
            result,
            (uint256, string)
        );
        require(returnCode == 0, string(abi.encodePacked("Liquidation failed: ", returnMessage)));
    }

    // LendingPoolLiquidationManager.sol
    function liquidationCall(
        address _collateral,
        address _reserve,
        address _user,
        uint256 _purchaseAmount,
        bool _receiveAToken
    ) external payable returns (uint256, string memory) {
        LiquidationCallLocalVars memory vars;
        (, , , , , , , vars.healthFactorBelowThreshold) = dataProvider.calculateUserGlobalData(
            _user
        );
        if (!vars.healthFactorBelowThreshold) {
            return (
                uint256(LiquidationErrors.HEALTH_FACTOR_ABOVE_THRESHOLD),
                "Health factor is not below the threshold"
            );
        }

        vars.userCollateralBalance = core.getUserUnderlyingAssetBalance(_collateral, _user);
        if (vars.userCollateralBalance == 0) {
            return (
                uint256(LiquidationErrors.NO_COLLATERAL_AVAILABLE),
                "Invalid collateral to liquidate"
            );
        }

        vars.isCollateralEnabled =
            core.isReserveUsageAsCollateralEnabled(_collateral) &&
            core.isUserUseReserveAsCollateralEnabled(_collateral, _user);
        if (!vars.isCollateralEnabled) {
            return (
                uint256(LiquidationErrors.COLLATERAL_CANNOT_BE_LIQUIDATED),
                "The collateral chosen cannot be liquidated"
            );
        }

        (, vars.userCompoundedBorrowBalance, vars.borrowBalanceIncrease) = core.getUserBorrowBalances(
            _reserve,
            _user
        );
        if (vars.userCompoundedBorrowBalance == 0) {
            return (
                uint256(LiquidationErrors.CURRRENCY_NOT_BORROWED),
                "User did not borrow the specified currency"
            );
        }

        vars.maxPrincipalAmountToLiquidate = vars
            .userCompoundedBorrowBalance
            .mul(LIQUIDATION_CLOSE_FACTOR_PERCENT)
            .div(100);
        vars.actualAmountToLiquidate = _purchaseAmount > vars.maxPrincipalAmountToLiquidate
            ? vars.maxPrincipalAmountToLiquidate
            : _purchaseAmount;

        (
            uint256 maxCollateralToLiquidate,
            uint256 principalAmountNeeded
        ) = calculateAvailableCollateralToLiquidate(
                _collateral,
                _reserve,
                vars.actualAmountToLiquidate,
                vars.userCollateralBalance
            );

        vars.originationFee = core.getUserOriginationFee(_reserve, _user);
        if (vars.originationFee > 0) {
            (
                vars.liquidatedCollateralForFee,
                vars.feeLiquidated
            ) = calculateAvailableCollateralToLiquidate(
                _collateral,
                _reserve,
                vars.originationFee,
                vars.userCollateralBalance.sub(maxCollateralToLiquidate)
            );
        }

        if (principalAmountNeeded < vars.actualAmountToLiquidate) {
            vars.actualAmountToLiquidate = principalAmountNeeded;
        }

        if (!_receiveAToken) {
            uint256 availableCollateral = core.getReserveAvailableLiquidity(_collateral);
            if (availableCollateral < maxCollateralToLiquidate) {
                return (
                    uint256(LiquidationErrors.NOT_ENOUGH_LIQUIDITY),
                    "There isn't enough liquidity available to liquidate"
                );
            }
        }

        core.updateStateOnLiquidation(
            _reserve,
            _collateral,
            _user,
            vars.actualAmountToLiquidate,
            maxCollateralToLiquidate,
            vars.feeLiquidated,
            vars.liquidatedCollateralForFee,
            vars.borrowBalanceIncrease,
            _receiveAToken
        );

        AToken collateralAtoken = AToken(core.getReserveATokenAddress(_collateral));
        if (_receiveAToken) {
            collateralAtoken.transferOnLiquidation(_user, msg.sender, maxCollateralToLiquidate);
        } else {
            collateralAtoken.burnOnLiquidation(_user, maxCollateralToLiquidate);
            core.transferToUser(_collateral, msg.sender, maxCollateralToLiquidate);
        }

        core.transferToReserve.value(msg.value)(
            _reserve,
            msg.sender,
            vars.actualAmountToLiquidate
        );

        if (vars.feeLiquidated > 0) {
            collateralAtoken.burnOnLiquidation(_user, vars.liquidatedCollateralForFee);
            core.liquidateFee(
                _collateral,
                vars.liquidatedCollateralForFee,
                addressesProvider.getTokenDistributor()
            );
            emit OriginationFeeLiquidated(
                _collateral,
                _reserve,
                _user,
                vars.feeLiquidated,
                vars.liquidatedCollateralForFee,
                block.timestamp
            );
        }

        emit LiquidationCall(
            _collateral,
            _reserve,
            _user,
            vars.actualAmountToLiquidate,
            maxCollateralToLiquidate,
            vars.borrowBalanceIncrease,
            msg.sender,
            _receiveAToken,
            block.timestamp
        );
        return (uint256(LiquidationErrors.NO_ERROR), "No errors");
    }

function updateStateOnDeposit(
    address _reserve,
    address _user,
    uint256 _amount,
    bool _isFirstDeposit
) external onlyLendingPool {
    // 累积上一个区块的收益，防止旧利率污染当前操作
    reserves[_reserve].updateCumulativeIndexes();
    // 将本次存入金额计入储备，刷新流动性利率与时间戳
    updateReserveInterestRatesAndTimestampInternal(_reserve, _amount, 0);
    if (_isFirstDeposit) {
        setUserUseReserveAsCollateral(_reserve, _user, true); // 首次存款直接作为抵押
    }
}

function updateStateOnBorrow(
    address _reserve,
    address _user,
    uint256 _amountBorrowed,
    uint256 _borrowFee,
    CoreLibrary.InterestRateMode _rateMode
) external onlyLendingPool returns (uint256, uint256) {
    (uint256 principalBorrowBalance, , uint256 balanceIncrease) = getUserBorrowBalances(_reserve, _user);
    // 先把储备维度的借款统计更新，否则用户状态会依赖旧的 `totalBorrows`
    updateReserveStateOnBorrowInternal(
        _reserve,
        _user,
        principalBorrowBalance,
        balanceIncrease,
        _amountBorrowed,
        _rateMode
    );
    // 再记录到用户维度：本金、费用与利率模式
    updateUserStateOnBorrowInternal(
        _reserve,
        _user,
        _amountBorrowed,
        balanceIncrease,
        _borrowFee,
        _rateMode
    );
    // 借款等价于抽离流动性，因此在负方向刷新利率
    updateReserveInterestRatesAndTimestampInternal(_reserve, 0, _amountBorrowed);
    return (getUserCurrentBorrowRate(_reserve, _user), balanceIncrease);
}

function transferToUser(
    address _reserve,
    address payable _user,
    uint256 _amount
) external onlyLendingPool {
    if (_reserve != EthAddressLib.ethAddress()) {
        // ERC20 路径直接将资产转出给用户
        ERC20(_reserve).safeTransfer(_user, _amount);
    } else {
        // ETH 路径使用 call，固定 50k gas 以降低重入面
        (bool result, ) = _user.call.value(_amount).gas(50000)("");
        require(result, "Transfer of ETH failed");
    }
}

function transferToReserve(
    address _reserve,
    address payable _user,
    uint256 _amount
) external payable onlyLendingPool {
    if (_reserve != EthAddressLib.ethAddress()) {
        // ERC20 入金必须通过 `safeTransferFrom`，防止多余 ETH
        require(msg.value == 0, "User is sending ETH along with the ERC20 transfer.");
        ERC20(_reserve).safeTransferFrom(_user, address(this), _amount);
    } else {
        // ETH 入金需要附带足量 msg.value，并在多付时立刻退款
        require(msg.value >= _amount, "The amount and the value sent to deposit do not match");
        if (msg.value > _amount) {
            uint256 excessAmount = msg.value.sub(_amount);
            (bool result, ) = _user.call.value(excessAmount).gas(50000)("");
            require(result, "Transfer of ETH failed");
        }
    }
}

function transferToFeeCollectionAddress(
    address _token,
    address _user,
    uint256 _amount,
    address _destination
) external payable onlyLendingPool {
    address payable feeAddress = address(uint160(_destination));
    if (_token != EthAddressLib.ethAddress()) {
        // 借款费的 ERC20 路径直接由 Core 从用户账户划走
        require(msg.value == 0, "User is sending ETH along with the ERC20 transfer...");
        ERC20(_token).safeTransferFrom(_user, feeAddress, _amount);
    } else {
        // ETH 费用需要携带 value，并直接转发给 TokenDistributor
        require(msg.value >= _amount, "The amount and the value sent to deposit do not match");
        (bool result, ) = feeAddress.call.value(_amount).gas(50000)("");
        require(result, "Transfer of ETH failed");
    }
}

function getUserBasicReserveData(address _reserve, address _user)
    external
    view
    returns (uint256, uint256, uint256, bool)
{
    CoreLibrary.ReserveData storage reserve = reserves[_reserve];
    CoreLibrary.UserReserveData storage user = usersReserveData[_user][_reserve];
    uint256 underlyingBalance = getUserUnderlyingAssetBalance(_reserve, _user);
    if (user.principalBorrowBalance == 0) {
        // 没有借款时只需要返回存款余额与抵押标记
        return (underlyingBalance, 0, 0, user.useAsCollateral);
    }
    return (
        underlyingBalance,
        // 通过用户的借款指数计算复利后的债务
        user.getCompoundedBorrowBalance(reserve),
        user.originationFee,
        user.useAsCollateral
    );
}

function isUserAllowedToBorrowAtStable(
    address _reserve,
    address _user,
    uint256 _amount
) external view returns (bool) {
    CoreLibrary.ReserveData storage reserve = reserves[_reserve];
    CoreLibrary.UserReserveData storage user = usersReserveData[_user][_reserve];
    if (!reserve.isStableBorrowRateEnabled) return false;
    return
        // 若用户未将该储备作为抵押或储备本身不可抵押，则允许稳定模式
        !user.useAsCollateral ||
        !reserve.usageAsCollateralEnabled ||
        // 否则要求借款金额大于其抵押余额，避免“同资产自借”套利
        _amount > getUserUnderlyingAssetBalance(_reserve, _user);
}

function mintOnDeposit(address _account, uint256 _amount) external onlyLendingPool {
    // 先把已有利息累积到本金，保证指数与余额同步
    (, , uint256 balanceIncrease, uint256 index) = cumulateBalanceInternal(_account);
    updateRedirectedBalanceOfRedirectionAddressInternal(
        _account,
        balanceIncrease.add(_amount),
        0
    ); // 若用户正在 redirect，先把新增余额同步给重定向地址
    _mint(_account, _amount);
    emit MintOnDeposit(_account, _amount, balanceIncrease, index);
}

function redeem(uint256 _amount) external {
    (, uint256 currentBalance, uint256 balanceIncrease, uint256 index) = cumulateBalanceInternal(msg.sender);
    uint256 amountToRedeem = _amount == UINT_MAX_VALUE ? currentBalance : _amount;
    require(amountToRedeem <= currentBalance, "User cannot redeem more than the available balance");
    require(isTransferAllowed(msg.sender, amountToRedeem), "Transfer cannot be allowed.");
    updateRedirectedBalanceOfRedirectionAddressInternal(
        msg.sender,
        balanceIncrease,
        amountToRedeem
    );
    _burn(msg.sender, amountToRedeem);
    // 若余额被清空，重置利息重定向以减少存储
    bool userIndexReset = currentBalance.sub(amountToRedeem) == 0 && resetDataOnZeroBalanceInternal(msg.sender);
    pool.redeemUnderlying(underlyingAssetAddress, msg.sender, amountToRedeem, currentBalance.sub(amountToRedeem));
    emit Redeem(msg.sender, amountToRedeem, balanceIncrease, userIndexReset ? 0 : index);
}

function calculateHealthFactorFromBalancesInternal(
    uint256 _collateralBalanceETH,
    uint256 _borrowBalanceETH,
    uint256 _totalFeesETH,
    uint256 _currentLiquidationThreshold
) internal pure returns (uint256) {
    if (_borrowBalanceETH == 0) return uint256(-1);
    return
        _collateralBalanceETH
            .wadMul(_currentLiquidationThreshold)
            .wadDiv(_borrowBalanceETH.add(_totalFeesETH));
}

function executeTransferInternal(
    address _from,
    address _to,
    uint256 _value
) internal {
    require(_value > 0, "Transferred amount needs to be greater than zero");
    (, uint256 fromBalance, uint256 fromBalanceIncrease, uint256 fromIndex) = cumulateBalanceInternal(_from);
    (, , uint256 toBalanceIncrease, uint256 toIndex) = cumulateBalanceInternal(_to);
    updateRedirectedBalanceOfRedirectionAddressInternal(_from, fromBalanceIncrease, _value);
    updateRedirectedBalanceOfRedirectionAddressInternal(_to, toBalanceIncrease.add(_value), 0);
    super._transfer(_from, _to, _value);
    bool fromIndexReset = fromBalance.sub(_value) == 0 && resetDataOnZeroBalanceInternal(_from);
    emit BalanceTransfer(
        _from,
        _to,
        _value,
        fromBalanceIncrease,
        toBalanceIncrease,
        fromIndexReset ? 0 : fromIndex,
        toIndex
    );
}

function redirectInterestStreamInternal(address _from, address _to) internal {
    address currentRedirectionAddress = interestRedirectionAddresses[_from];
    require(_to != currentRedirectionAddress, "Interest is already redirected to the user");
    (
        uint256 previousPrincipalBalance,
        uint256 fromBalance,
        uint256 balanceIncrease,
        uint256 fromIndex
    ) = cumulateBalanceInternal(_from);
    require(fromBalance > 0, "Interest stream can only be redirected if there is a valid balance");
    if (currentRedirectionAddress != address(0)) {
        // 旧重定向账户需要减去用户本金，否则会重复计息
        updateRedirectedBalanceOfRedirectionAddressInternal(_from, 0, previousPrincipalBalance);
    }
    if (_to == _from) {
        // 将利息重定向给自己意味着撤销重定向
        interestRedirectionAddresses[_from] = address(0);
        emit InterestStreamRedirected(_from, address(0), fromBalance, balanceIncrease, fromIndex);
        return;
    }
    interestRedirectionAddresses[_from] = _to;
    updateRedirectedBalanceOfRedirectionAddressInternal(_from, fromBalance, 0);
    emit InterestStreamRedirected(_from, _to, fromBalance, balanceIncrease, fromIndex);
}

function calculateUserGlobalData(address _user)
    public
    view
    returns (
        uint256 totalLiquidityBalanceETH,
        uint256 totalCollateralBalanceETH,
        uint256 totalBorrowBalanceETH,
        uint256 totalFeesETH,
        uint256 currentLtv,
        uint256 currentLiquidationThreshold,
        uint256 healthFactor,
        bool healthFactorBelowThreshold
    )
{
    IPriceOracleGetter oracle = IPriceOracleGetter(addressesProvider.getPriceOracle());
    address[] memory reserves = core.getReserves();
    for (uint256 i = 0; i < reserves.length; i++) {
        (
            uint256 compoundedLiquidityBalance,
            uint256 compoundedBorrowBalance,
            uint256 originationFee,
            bool userUsesReserveAsCollateral
        ) = core.getUserBasicReserveData(reserves[i], _user);
        if (compoundedLiquidityBalance == 0 && compoundedBorrowBalance == 0) continue;
        (
            uint256 reserveDecimals,
            uint256 baseLtv,
            uint256 liquidationThreshold,
            bool usageAsCollateralEnabled
        ) = core.getReserveConfiguration(reserves[i]);
        uint256 tokenUnit = 10 ** reserveDecimals;
        uint256 reserveUnitPrice = oracle.getAssetPrice(reserves[i]);
        if (compoundedLiquidityBalance > 0) {
            // 使用预言机价格将存款折算成 ETH
            uint256 liquidityBalanceETH = reserveUnitPrice.mul(compoundedLiquidityBalance).div(tokenUnit);
            totalLiquidityBalanceETH = totalLiquidityBalanceETH.add(liquidityBalanceETH);
            if (usageAsCollateralEnabled && userUsesReserveAsCollateral) {
                // 只有开启抵押的储备才会累加到 collateral
                totalCollateralBalanceETH = totalCollateralBalanceETH.add(liquidityBalanceETH);
                currentLtv = currentLtv.add(liquidityBalanceETH.mul(baseLtv));
                currentLiquidationThreshold = currentLiquidationThreshold.add(
                    liquidityBalanceETH.mul(liquidationThreshold)
                );
            }
        }
        if (compoundedBorrowBalance > 0) {
            // 借款和 origination fee 同样按 ETH 计价
            totalBorrowBalanceETH = totalBorrowBalanceETH.add(
                reserveUnitPrice.mul(compoundedBorrowBalance).div(tokenUnit)
            );
            totalFeesETH = totalFeesETH.add(
                originationFee.mul(reserveUnitPrice).div(tokenUnit)
            );
        }
    }
    currentLtv = totalCollateralBalanceETH > 0 ? currentLtv.div(totalCollateralBalanceETH) : 0;
    currentLiquidationThreshold = totalCollateralBalanceETH > 0
        ? currentLiquidationThreshold.div(totalCollateralBalanceETH)
        : 0;
    // Health Factor < 1 即可被清算
    healthFactor = calculateHealthFactorFromBalancesInternal(
        totalCollateralBalanceETH,
        totalBorrowBalanceETH,
        totalFeesETH,
        currentLiquidationThreshold
    );
    healthFactorBelowThreshold = healthFactor < HEALTH_FACTOR_LIQUIDATION_THRESHOLD;
}

function balanceDecreaseAllowed(address _reserve, address _user, uint256 _amount)
    external
    view
    returns (bool)
{
    balanceDecreaseAllowedLocalVars memory vars;
    (
        vars.decimals,
        ,
        vars.reserveLiquidationThreshold,
        vars.reserveUsageAsCollateralEnabled
    ) = core.getReserveConfiguration(_reserve);

    if (
        !vars.reserveUsageAsCollateralEnabled ||
        !core.isUserUseReserveAsCollateralEnabled(_reserve, _user)
    ) {
        return true;
    }

    (
        ,
        vars.collateralBalanceETH,
        vars.borrowBalanceETH,
        vars.totalFeesETH,
        ,
        vars.currentLiquidationThreshold,
        ,

    ) = calculateUserGlobalData(_user);

    if (vars.borrowBalanceETH == 0) {
        // 没有借款则随意转出
        return true;
    }

    IPriceOracleGetter oracle = IPriceOracleGetter(addressesProvider.getPriceOracle());
    vars.amountToDecreaseETH = oracle.getAssetPrice(_reserve).mul(_amount).div(10 ** vars.decimals);
    vars.collateralBalancefterDecrease = vars.collateralBalanceETH.sub(vars.amountToDecreaseETH);
    if (vars.collateralBalancefterDecrease == 0) {
        return false;
    }

    vars.liquidationThresholdAfterDecrease = vars
        .collateralBalanceETH
        .mul(vars.currentLiquidationThreshold)
        .sub(vars.amountToDecreaseETH.mul(vars.reserveLiquidationThreshold))
        .div(vars.collateralBalancefterDecrease);

    uint256 healthFactorAfterDecrease = calculateHealthFactorFromBalancesInternal(
        vars.collateralBalancefterDecrease,
        vars.borrowBalanceETH,
        vars.totalFeesETH,
        vars.liquidationThresholdAfterDecrease
    );

    // 只有在转出后 health factor 仍大于阈值时才允许
    return healthFactorAfterDecrease > HEALTH_FACTOR_LIQUIDATION_THRESHOLD;
}

function calculateInterestRates(
    address _reserve,
    uint256 _availableLiquidity,
    uint256 _totalBorrowsStable,
    uint256 _totalBorrowsVariable,
    uint256 _averageStableBorrowRate
)
    external
    view
    returns (uint256 currentLiquidityRate, uint256 currentStableBorrowRate, uint256 currentVariableBorrowRate)
{
    uint256 totalBorrows = _totalBorrowsStable.add(_totalBorrowsVariable);
    uint256 utilizationRate = (totalBorrows == 0 && _availableLiquidity == 0)
        ? 0
        : totalBorrows.rayDiv(_availableLiquidity.add(totalBorrows));

    // 稳定利率以预言机的市场借款利率为基线
    currentStableBorrowRate = ILendingRateOracle(addressesProvider.getLendingRateOracle())
        .getMarketBorrowRate(_reserve);

    if (utilizationRate > OPTIMAL_UTILIZATION_RATE) {
        uint256 excessUtilizationRateRatio = utilizationRate
            .sub(OPTIMAL_UTILIZATION_RATE)
            .rayDiv(EXCESS_UTILIZATION_RATE);
        // 超过拐点后使用 slope2 快速抬升借款利率
        currentStableBorrowRate = currentStableBorrowRate
            .add(stableRateSlope1)
            .add(stableRateSlope2.rayMul(excessUtilizationRateRatio));
        currentVariableBorrowRate = baseVariableBorrowRate
            .add(variableRateSlope1)
            .add(variableRateSlope2.rayMul(excessUtilizationRateRatio));
    } else {
        // 未超过拐点时按 slope1 线性插值
        currentStableBorrowRate = currentStableBorrowRate.add(
            stableRateSlope1.rayMul(
                utilizationRate.rayDiv(OPTIMAL_UTILIZATION_RATE)
            )
        );
        currentVariableBorrowRate = baseVariableBorrowRate.add(
            utilizationRate.rayDiv(OPTIMAL_UTILIZATION_RATE).rayMul(variableRateSlope1)
        );
    }

    currentLiquidityRate = getOverallBorrowRateInternal(
        _totalBorrowsStable,
        _totalBorrowsVariable,
        currentVariableBorrowRate,
        _averageStableBorrowRate
    ).rayMul(utilizationRate); // 存款收益 = 利用率 * 借款平均利率
}

function calculateLoanOriginationFee(address _user, uint256 _amount)
    external
    view
    returns (uint256)
{
    // 目前未根据 _user 区分费率，直接返回金额 * 0.25%
    return _amount.wadMul(originationFeePercentage);
}

function getFlashLoanFeesInBips() external pure returns (uint256, uint256) {
    // (总费率, 协议分润)；其余部分将流向存款人
    return (FLASHLOAN_FEE_TOTAL, FLASHLOAN_FEE_PROTOCOL);
}

function initReserve(
    address _reserve,
    uint8 _underlyingAssetDecimals,
    address _interestRateStrategyAddress
) external onlyLendingPoolManager {
    ERC20Detailed asset = ERC20Detailed(_reserve);
    string memory aTokenName = string(abi.encodePacked("Aave Interest bearing ", asset.name()));
    string memory aTokenSymbol = string(abi.encodePacked("a", asset.symbol()));
    // 若底层 ERC20 未提供 name/decimals，可使用 initReserveWithData 直接传自定义值
    initReserveWithData(
        _reserve,
        aTokenName,
        aTokenSymbol,
        _underlyingAssetDecimals,
        _interestRateStrategyAddress
    );
}

function enableBorrowingOnReserve(address _reserve, bool _stableRateEnabled)
    external
    onlyLendingPoolManager
{
    LendingPoolCore core = LendingPoolCore(poolAddressesProvider.getLendingPoolCore());
    // 直接调用 Core 的可借开关，顺便设置是否允许稳定利率
    core.enableBorrowingOnReserve(_reserve, _stableRateEnabled);
    emit BorrowingEnabledOnReserve(_reserve, _stableRateEnabled);
}

function enableReserveAsCollateral(
    address _reserve,
    uint256 _baseLTVasCollateral,
    uint256 _liquidationThreshold,
    uint256 _liquidationBonus
) external onlyLendingPoolManager {
    LendingPoolCore core = LendingPoolCore(poolAddressesProvider.getLendingPoolCore());
    core.enableReserveAsCollateral(
        _reserve,
        _baseLTVasCollateral,
        _liquidationThreshold,
        _liquidationBonus
    );
    // 事件中会带出新的 LTV、阈值与清算奖励，方便前端追踪
    emit ReserveEnabledAsCollateral(
        _reserve,
        _baseLTVasCollateral,
        _liquidationThreshold,
        _liquidationBonus
    );
}

function setLendingPoolImpl(address _pool) public onlyOwner {
    // 所有实现升级都统一通过 updateImplInternal，保持代理地址不变
    updateImplInternal(LENDING_POOL, _pool);
    emit LendingPoolUpdated(_pool);
}

function setLendingPoolCoreImpl(address _lendingPoolCore) public onlyOwner {
    updateImplInternal(LENDING_POOL_CORE, _lendingPoolCore);
    emit LendingPoolCoreUpdated(_lendingPoolCore);
}

function setLendingPoolConfiguratorImpl(address _configurator) public onlyOwner {
    updateImplInternal(LENDING_POOL_CONFIGURATOR, _configurator);
    emit LendingPoolConfiguratorUpdated(_configurator);
}

function updateImplInternal(bytes32 _id, address _newAddress) internal {
    address payable proxyAddress = address(uint160(getAddress(_id)));
    InitializableAdminUpgradeabilityProxy proxy = InitializableAdminUpgradeabilityProxy(proxyAddress);
    bytes memory params = abi.encodeWithSignature("initialize(address)", address(this));
    if (proxyAddress == address(0)) {
        // 首次设置时直接部署新的代理，并把实现与 admin 指向当前 provider
        proxy = new InitializableAdminUpgradeabilityProxy();
        proxy.initialize(_newAddress, address(this), params);
        _setAddress(_id, address(proxy));
        emit ProxyCreated(_id, address(proxy));
    } else {
        // 已存在则直接调用 upgradeToAndCall 完成滚动升级
        proxy.upgradeToAndCall(_newAddress, params);
    }
}