@pendle/core-v2 6.7.1 → 6.8.0

package/contracts/pt-looping/money-market/implementations/aave/AaveMoneyMarketView.sol

@@ -0,0 +1,200 @@
+//SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IAaveRewardsController} from "./dependencies/IAaveRewardsController.sol";
+import {IPool} from "./dependencies/IPool.sol";
+import {IPoolAddressesProvider} from "./dependencies/IPoolAddressesProvider.sol";
+import {IPoolDataProviderV3} from "./dependencies/IPoolDataProviderV3.sol";
+import {IAaveOracle} from "./dependencies/IAaveOracle.sol";
+import {AaveDataTypes} from "./dependencies/AaveDataTypes.sol";
+
+import {IPLoopPositionBox, BoxData} from "../../../../interfaces/IPLoopPositionBox.sol";
+import {PMath} from "../../../../core/libraries/math/PMath.sol";
+import {BaseMoneyMarketView, Reward} from "../../BaseMoneyMarketView.sol";
+import {AaveMMPayloadLib} from "./AaveMMPayloadLib.sol";
+import {TokenHelper} from "../../../../core/libraries/TokenHelper.sol";
+
+contract AaveMoneyMarketView is BaseMoneyMarketView, TokenHelper {
+    using PMath for uint256;
+
+    uint256 internal constant RAY = 1e27;
+    /// @dev Aave returns LTV / liquidation thresholds in bps (×1e4); scale to WAD (×1e18).
+    uint256 internal constant BPS_TO_WAD = 1e14;
+    /// @dev Aave returns *annualized* reserve rates in RAY (×1e27); scale to WAD (÷1e9). `_rates`
+    /// then feeds the annual WAD rate to `_apy` with `perSeconds = 365 days` for compounding.
+    uint256 internal constant RAY_TO_WAD = 1e9;
+
+    IPoolAddressesProvider public immutable poolAddressesProvider;
+    IAaveRewardsController public immutable rewardsController;
+
+    constructor(
+        string memory _moneyMarketName,
+        address _ptLooper,
+        address _poolAddressesProvider,
+        address _rewardsController
+    ) BaseMoneyMarketView(_moneyMarketName, _ptLooper) {
+        poolAddressesProvider = IPoolAddressesProvider(_poolAddressesProvider);
+        rewardsController = IAaveRewardsController(_rewardsController);
+    }
+
+    function pool() public view virtual returns (IPool) {
+        return poolAddressesProvider.getPool();
+    }
+
+    function dataProvider() public view virtual returns (IPoolDataProviderV3) {
+        return poolAddressesProvider.getPoolDataProvider();
+    }
+
+    function oracle() public view virtual returns (IAaveOracle) {
+        return poolAddressesProvider.getPriceOracle();
+    }
+
+    // ========== IMoneyMarketView ==========
+
+    function _moneyMarketBalances(IPLoopPositionBox box, BoxData memory bd)
+        internal
+        virtual
+        override
+        returns (uint256 mmPtBalance, uint256 mmDebtBalance)
+    {
+        address account = box.SPOKE_MONEY_MARKET();
+        IPoolDataProviderV3 dp = dataProvider();
+        (mmPtBalance,,,,,,,,) = dp.getUserReserveData(bd.spokePt, account);
+        (,, mmDebtBalance,,,,,,) = dp.getUserReserveData(bd.spokeDebtToken, account);
+    }
+
+    function _thresholds(IPLoopPositionBox, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 ltv, uint256 liquidationThreshold)
+    {
+        (uint8 eModeCategoryId,) = AaveMMPayloadLib.unwrap(bd.mmPayload);
+
+        if (eModeCategoryId == 0) {
+            (, ltv, liquidationThreshold,,,,,,,) = dataProvider().getReserveConfigurationData(bd.spokePt);
+        } else {
+            (, ltv, liquidationThreshold) = pool().getEModeCategoryData(eModeCategoryId);
+        }
+
+        ltv *= BPS_TO_WAD;
+        liquidationThreshold *= BPS_TO_WAD;
+    }
+
+    function _liquidity(IPLoopPositionBox, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 borrowing, uint256 lending)
+    {
+        IPoolDataProviderV3 dp = dataProvider();
+        IPool _pool = pool();
+        AaveDataTypes.ReserveData memory prd = _pool.getReserveData(IERC20(bd.spokePt));
+
+        // calculate lending
+        {
+            (, uint256 supplyCap) = _getScaledReserveCap(dp, bd.spokePt);
+            if (supplyCap == 0) {
+                lending = IERC20(bd.spokePt).totalSupply(); // Infinite supply cap
+            } else {
+                uint256 currentSupply = (prd.aTokenAddress.scaledTotalSupply() + prd.accruedToTreasury)
+                    * _pool.getReserveNormalizedIncome(IERC20(bd.spokePt)) / RAY;
+                lending = supplyCap.subMax0(currentSupply);
+            }
+        }
+
+        // calculate borrowing
+        {
+            (uint256 borrowCap,) = _getScaledReserveCap(dp, bd.spokeDebtToken);
+            uint256 maxBorrowable =
+                borrowCap == 0 ? type(uint256).max : borrowCap.subMax0(dp.getTotalDebt(bd.spokeDebtToken));
+
+            borrowing = PMath.min(maxBorrowable, dp.getVirtualUnderlyingBalance(bd.spokeDebtToken));
+
+            uint256 debtCeiling = dp.getDebtCeiling(bd.spokePt);
+            if (debtCeiling > 0) {
+                IAaveOracle _oracle = oracle();
+                require(address(_oracle.BASE_CURRENCY()) == address(0), "Oracle base currency must be USD");
+
+                uint256 unscaledAvail = debtCeiling - prd.isolationModeTotalDebt;
+                uint256 available = unscaledAvail * _oracle.BASE_CURRENCY_UNIT() / (10 ** dp.getDebtCeilingDecimals());
+                uint256 debtPrice = _oracle.getAssetPrice(IERC20(bd.spokeDebtToken));
+                borrowing = PMath.min(borrowing, available * 10 ** IERC20(bd.spokeDebtToken).decimals() / debtPrice);
+            }
+        }
+    }
+
+    function _rates(IPLoopPositionBox, BoxData memory bd)
+        internal
+        view
+        virtual
+        override
+        returns (uint256 borrowing, uint256 lending)
+    {
+        IPool _pool = pool();
+        borrowing = _apy({
+            rate: _pool.getReserveData(IERC20(bd.spokeDebtToken)).currentVariableBorrowRate / RAY_TO_WAD,
+            perSeconds: 365 days
+        });
+        lending = _apy({ //
+            rate: _pool.getReserveData(IERC20(bd.spokePt)).currentLiquidityRate / RAY_TO_WAD,
+            perSeconds: 365 days
+        });
+    }
+
+    function _rewards(IPLoopPositionBox box, BoxData memory bd)
+        internal
+        virtual
+        override
+        returns (Reward[] memory borrowing, Reward[] memory lending)
+    {
+        if (address(rewardsController) != address(0)) {
+            address account = box.SPOKE_MONEY_MARKET();
+            borrowing = _asRewards(account, bd.spokeDebtToken, true);
+            lending = _asRewards(account, bd.spokePt, false);
+        }
+    }
+
+    // ========== Internal helpers ==========
+
+    function _asRewards(address account, address underlying, bool borrowing)
+        internal
+        view
+        returns (Reward[] memory res)
+    {
+        (address aTokenAddress,, address variableDebtTokenAddress) =
+            dataProvider().getReserveTokensAddresses(underlying);
+        address asset = borrowing ? variableDebtTokenAddress : aTokenAddress;
+
+        address[] memory assetArr = new address[](1);
+        assetArr[0] = asset;
+
+        address[] memory rewardTokens = rewardsController.getRewardsByAsset(asset);
+        res = new Reward[](rewardTokens.length);
+
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            res[i].token = rewardTokens[i];
+            res[i].claimable = rewardsController.getUserRewards(assetArr, account, rewardTokens[i]);
+        }
+    }
+
+    function _getScaledReserveCap(IPoolDataProviderV3 dp, address asset)
+        internal
+        view
+        virtual
+        returns (
+            uint256, /* borrowCap */
+            uint256 /* supplyCap */
+        )
+    {
+        (uint256 borrowCap, uint256 supplyCap) = dp.getReserveCaps(asset);
+        if (borrowCap == 0 && supplyCap == 0) return (0, 0);
+
+        uint256 scale = 10 ** IERC20(asset).decimals();
+        return (borrowCap * scale, supplyCap * scale);
+    }
+}

package/contracts/pt-looping/money-market/implementations/aave/dependencies/AaveDataTypes.sol

@@ -0,0 +1,259 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.4;
+
+import "./IAToken.sol";
+
+library AaveDataTypes {
+    struct ReserveData {
+        //stores the reserve configuration
+        ReserveConfigurationMap configuration;
+        //the liquidity index. Expressed in ray
+        uint128 liquidityIndex;
+        //the current supply rate. Expressed in ray
+        uint128 currentLiquidityRate;
+        //variable borrow index. Expressed in ray
+        uint128 variableBorrowIndex;
+        //the current variable borrow rate. Expressed in ray
+        uint128 currentVariableBorrowRate;
+        //the current stable borrow rate. Expressed in ray
+        uint128 currentStableBorrowRate;
+        //timestamp of last update
+        uint40 lastUpdateTimestamp;
+        //the id of the reserve. Represents the position in the list of the active reserves
+        uint16 id;
+        //aToken address
+        IAToken aTokenAddress;
+        //stableDebtToken address
+        IERC20 stableDebtTokenAddress;
+        //variableDebtToken address
+        IERC20 variableDebtTokenAddress;
+        //address of the interest rate strategy
+        address interestRateStrategyAddress;
+        //the current treasury balance, scaled
+        uint128 accruedToTreasury;
+        //the outstanding unbacked aTokens minted through the bridging feature
+        uint128 unbacked;
+        //the outstanding debt borrowed against this asset in isolation mode
+        uint128 isolationModeTotalDebt;
+    }
+
+    struct ReserveConfigurationMap {
+        //bit 0-15: LTV
+        //bit 16-31: Liq. threshold
+        //bit 32-47: Liq. bonus
+        //bit 48-55: Decimals
+        //bit 56: reserve is active
+        //bit 57: reserve is frozen
+        //bit 58: borrowing is enabled
+        //bit 59: stable rate borrowing enabled
+        //bit 60: asset is paused
+        //bit 61: borrowing in isolation mode is enabled
+        //bit 62-63: reserved
+        //bit 64-79: reserve factor
+        //bit 80-115 borrow cap in whole tokens, borrowCap == 0 => no cap
+        //bit 116-151 supply cap in whole tokens, supplyCap == 0 => no cap
+        //bit 152-167 liquidation protocol fee
+        //bit 168-175 eMode category
+        //bit 176-211 unbacked mint cap in whole tokens, unbackedMintCap == 0 => minting disabled
+        //bit 212-251 debt ceiling for isolation mode with (ReserveConfiguration::DEBT_CEILING_DECIMALS) decimals
+        //bit 252-255 unused
+        uint256 data;
+    }
+
+    struct UserConfigurationMap {
+        /**
+         * @dev Bitmap of the users collaterals and borrows. It is divided in pairs of bits, one pair per asset.
+         * The first bit indicates if an asset is used as collateral by the user, the second whether an
+         * asset is borrowed by the user.
+         */
+        uint256 data;
+    }
+
+    enum InterestRateMode {
+        NONE,
+        STABLE,
+        VARIABLE
+    }
+
+    struct ReserveCache {
+        uint256 currScaledVariableDebt;
+        uint256 nextScaledVariableDebt;
+        uint256 currPrincipalStableDebt;
+        uint256 currAvgStableBorrowRate;
+        uint256 currTotalStableDebt;
+        uint256 nextAvgStableBorrowRate;
+        uint256 nextTotalStableDebt;
+        uint256 currLiquidityIndex;
+        uint256 nextLiquidityIndex;
+        uint256 currVariableBorrowIndex;
+        uint256 nextVariableBorrowIndex;
+        uint256 currLiquidityRate;
+        uint256 currVariableBorrowRate;
+        uint256 reserveFactor;
+        ReserveConfigurationMap reserveConfiguration;
+        address aTokenAddress;
+        address stableDebtTokenAddress;
+        address variableDebtTokenAddress;
+        uint40 reserveLastUpdateTimestamp;
+        uint40 stableDebtLastUpdateTimestamp;
+    }
+
+    struct ExecuteLiquidationCallParams {
+        uint256 reservesCount;
+        uint256 debtToCover;
+        address collateral;
+        address debtAsset;
+        address user;
+        bool receiveAToken;
+        address priceOracle;
+        uint8 userEModeCategory;
+        address priceOracleSentinel;
+    }
+
+    struct ExecuteSupplyParams {
+        address asset;
+        uint256 amount;
+        address onBehalfOf;
+        uint16 referralCode;
+    }
+
+    struct ExecuteBorrowParams {
+        address asset;
+        address user;
+        address onBehalfOf;
+        uint256 amount;
+        InterestRateMode interestRateMode;
+        uint16 referralCode;
+        bool releaseUnderlying;
+        uint256 maxStableRateBorrowSizePercent;
+        uint256 reservesCount;
+        address oracle;
+        uint8 userEModeCategory;
+        address priceOracleSentinel;
+    }
+
+    struct ExecuteRepayParams {
+        address asset;
+        uint256 amount;
+        InterestRateMode interestRateMode;
+        address onBehalfOf;
+        bool useATokens;
+    }
+
+    struct ExecuteWithdrawParams {
+        address asset;
+        uint256 amount;
+        address to;
+        uint256 reservesCount;
+        address oracle;
+        uint8 userEModeCategory;
+    }
+
+    struct ExecuteSetUserEModeParams {
+        uint256 reservesCount;
+        address oracle;
+        uint8 categoryId;
+    }
+
+    struct FinalizeTransferParams {
+        address asset;
+        address from;
+        address to;
+        uint256 amount;
+        uint256 balanceFromBefore;
+        uint256 balanceToBefore;
+        uint256 reservesCount;
+        address oracle;
+        uint8 fromEModeCategory;
+    }
+
+    struct FlashloanParams {
+        address receiverAddress;
+        address[] assets;
+        uint256[] amounts;
+        uint256[] interestRateModes;
+        address onBehalfOf;
+        bytes params;
+        uint16 referralCode;
+        uint256 flashLoanPremiumToProtocol;
+        uint256 flashLoanPremiumTotal;
+        uint256 maxStableRateBorrowSizePercent;
+        uint256 reservesCount;
+        address addressesProvider;
+        uint8 userEModeCategory;
+        bool isAuthorizedFlashBorrower;
+    }
+
+    struct FlashloanSimpleParams {
+        address receiverAddress;
+        address asset;
+        uint256 amount;
+        bytes params;
+        uint16 referralCode;
+        uint256 flashLoanPremiumToProtocol;
+        uint256 flashLoanPremiumTotal;
+    }
+
+    struct FlashLoanRepaymentParams {
+        uint256 amount;
+        uint256 totalPremium;
+        uint256 flashLoanPremiumToProtocol;
+        address asset;
+        address receiverAddress;
+        uint16 referralCode;
+    }
+
+    struct CalculateUserAccountDataParams {
+        UserConfigurationMap userConfig;
+        uint256 reservesCount;
+        address user;
+        address oracle;
+        uint8 userEModeCategory;
+    }
+
+    struct ValidateBorrowParams {
+        ReserveCache reserveCache;
+        UserConfigurationMap userConfig;
+        address asset;
+        address userAddress;
+        uint256 amount;
+        InterestRateMode interestRateMode;
+        uint256 maxStableLoanPercent;
+        uint256 reservesCount;
+        address oracle;
+        uint8 userEModeCategory;
+        address priceOracleSentinel;
+        bool isolationModeActive;
+        address isolationModeCollateralAddress;
+        uint256 isolationModeDebtCeiling;
+    }
+
+    struct ValidateLiquidationCallParams {
+        ReserveCache debtReserveCache;
+        uint256 totalDebt;
+        uint256 healthFactor;
+        address priceOracleSentinel;
+    }
+
+    struct CalculateInterestRatesParams {
+        uint256 unbacked;
+        uint256 liquidityAdded;
+        uint256 liquidityTaken;
+        uint256 totalStableDebt;
+        uint256 totalVariableDebt;
+        uint256 averageStableBorrowRate;
+        uint256 reserveFactor;
+        address reserve;
+        address aToken;
+    }
+
+    struct InitReserveParams {
+        address asset;
+        address aTokenAddress;
+        address stableDebtAddress;
+        address variableDebtAddress;
+        address interestRateStrategyAddress;
+        uint16 reservesCount;
+        uint16 maxNumberReserves;
+    }
+}

package/contracts/pt-looping/money-market/implementations/aave/dependencies/IAToken.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.4;
+
+import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+interface IAToken is IERC20 {
+    function scaledTotalSupply() external view returns (uint256);
+}

package/contracts/pt-looping/money-market/implementations/aave/dependencies/IAaveOracle.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.4;
+
+import {IPriceOracleGetter, IERC20} from "./IPriceOracleGetter.sol";
+import {IPoolAddressesProvider} from "./IPoolAddressesProvider.sol";
+
+interface IAaveOracle is IPriceOracleGetter {
+    /**
+     * @notice Returns the PoolAddressesProvider
+     * @return The address of the PoolAddressesProvider contract
+     */
+    function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);
+
+    /**
+     * @notice Returns a list of prices from a list of assets addresses
+     * @param assets The list of assets addresses
+     * @return The prices of the given assets
+     */
+    function getAssetsPrices(IERC20[] calldata assets) external view returns (uint256[] memory);
+
+    /**
+     * @notice Returns the address of the source for an asset address
+     * @param asset The address of the asset
+     * @return The address of the source
+     */
+    function getSourceOfAsset(IERC20 asset) external view returns (address);
+
+    /**
+     * @notice Returns the address of the fallback oracle
+     * @return The address of the fallback oracle
+     */
+    function getFallbackOracle() external view returns (address);
+}

package/contracts/pt-looping/money-market/implementations/aave/dependencies/IAaveRewardsController.sol

@@ -0,0 +1,68 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";
+
+interface IAaveRewardsController {
+    struct RewardsConfigInput {
+        uint88 emissionPerSecond;
+        uint256 totalSupply;
+        uint32 distributionEnd;
+        address asset;
+        address reward;
+        address transferStrategy;
+        address rewardOracle;
+    }
+
+    struct RewardsData {
+        uint256 index;
+        uint256 emissionsPerSecond;
+        uint256 indexLastUpdated;
+        uint256 distributionEnd;
+    }
+
+    function EMISSION_MANAGER() external view returns (address);
+    function REVISION() external view returns (uint256);
+    function claimAllRewards(IERC20[] memory assets, address to)
+        external
+        returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
+    function claimAllRewardsOnBehalf(address[] memory assets, address user, address to)
+        external
+        returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
+    function claimAllRewardsToSelf(address[] memory assets)
+        external
+        returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
+    function claimRewards(address[] memory assets, uint256 amount, address to, address reward)
+        external
+        returns (uint256);
+    function claimRewardsOnBehalf(address[] memory assets, uint256 amount, address user, address to, address reward)
+        external
+        returns (uint256);
+    function claimRewardsToSelf(address[] memory assets, uint256 amount, address reward) external returns (uint256);
+    function configureAssets(RewardsConfigInput[] memory config) external;
+    function getAllUserRewards(address[] memory assets, address user)
+        external
+        view
+        returns (address[] memory rewardsList, uint256[] memory unclaimedAmounts);
+    function getAssetDecimals(address asset) external view returns (uint8);
+    function getAssetIndex(address asset, address reward) external view returns (uint256, uint256);
+    function getClaimer(address user) external view returns (address);
+    function getDistributionEnd(address asset, address reward) external view returns (uint256);
+    function getEmissionManager() external view returns (address);
+    // function getRewardOracle(IERC20 reward) external view returns (IAggregatorV2V3); // not used
+    function getRewardsByAsset(address asset) external view returns (address[] memory);
+    function getRewardsData(address asset, address reward) external view returns (RewardsData memory);
+    function getRewardsList() external view returns (address[] memory);
+    function getTransferStrategy(address reward) external view returns (address);
+    function getUserAccruedRewards(address user, address reward) external view returns (uint256);
+    function getUserAssetIndex(address user, address asset, address reward) external view returns (uint256);
+    function getUserRewards(address[] memory assets, address user, address reward) external view returns (uint256);
+    function handleAction(address user, uint256 totalSupply, uint256 userBalance) external;
+    function initialize(address) external;
+    function setClaimer(address user, address caller) external;
+    function setDistributionEnd(address asset, address reward, uint32 newDistributionEnd) external;
+    function setEmissionPerSecond(address asset, address[] memory rewards, uint88[] memory newEmissionsPerSecond)
+        external;
+    function setRewardOracle(address reward, address rewardOracle) external;
+    function setTransferStrategy(address reward, address transferStrategy) external;
+}